Understanding how many users are sharing accounts

The first step in addressing account sharing on your product is to understand how much of it is occurring. In this guide, we'll illustrate how to use Upollo's free track API to send user events to Upollo, and then view Upollo's account sharing analysis in the Dashboard to determine the extent of any account sharing. These tools are free and easy to integrate into your application.

Prerequisites

• Be signed up to Upollo at app.upollo.ai/login.

• Add the Upollo libraries to your project by following the quick start instructions.

Step 1: track events

To understand if customers are sharing accounts, we need to know when they are using your application. This is done via calling Upollo's client-side track API with the type of event the user is doing. For example, you will likely want to call track when users attempt to login:

Web JavaScript

import { EventType, UpolloClient } from "@upollo/web";

// Sign up to Upollo to get your API key.
const upollo = new UpolloClient("your-public-API-key");

// When the user attempts to login.
upollo.track({ userEmail: "person@example.com" }, EventType.EVENT_TYPE_LOGIN);

iOS Swift

import Upollo

var upollo: UpolloClient?
do {
  // Sign up to Upollo to get your API key.
  upollo = try UpolloClient(publicApiKey: "your-public-API-key")
} catch {
  print("UpolloClient setup failed: \(error)")
}

// When the user attempts to login.
if let u = upollo {
  u.track(UpProto_UserInfo.with { i in
      i.userEmail = "person@example.com"
  }, did: UpProto_EventType.login)
}

Android Kotlin

import ai.upollo.proto.EventType
import ai.upollo.proto.userInfo
import ai.upollo.android.UpolloClient

// Sign up to Upollo to get your API key.
val upollo = UpolloClient(applicationContext, "your-public-API-key")

// When the user attempts to login.
upollo.track(userInfo {
    userEmail = "person@example.com"
}, EventType.EVENT_TYPE_LOGIN)

Android Java

import ai.upollo.proto.EventType
import ai.upollo.proto.userInfo
import ai.upollo.android.UpolloClient

// Sign up to Upollo to get your API key.
UpolloClient upollo = new UpolloClient(applicationContext,
    "your-public-API-key");

// When the user attempts to login.
upollo.track(
    UserInfo.newBuilder().setUserEmail("person@example.com").build(),
    EventType.EVENT_TYPE_LOGIN)

Once the user successfully logs in, you should also send an EVENT_TYPE_LOGIN_SUCCESS so that Upollo knows the login attempt was successful.

We suggest you send as many events as you can, as this will improve the analysis we are able to do for you. We find most sites should send events about:

• Login: EVENT_TYPE_LOGIN and EVENT_TYPE_LOGIN_SUCCESS

• Registration: EVENT_TYPE_REGISTER and EVENT_TYPE_REGISTER_SUCCESS

• Page visits: EVENT_TYPE_PAGE_VISIT

• Purchases: EVENT_TYPE_ATTEMPT_PURCHASE, EVENT_TYPE_ATTEMPT_REDEEM_OFFER, EVENT_TYPE_COMPLETE_PURCHASE, EVENT_TYPE_END_SUBSCRIPTION, EVENT_TYPE_REDEEMED_OFFER and EVENT_TYPE_START_SUBSCRIPTION

For details on how and when to send events, see the Event Type Documentation. If your app already uses Segment to track analytics events, you can additionally connect Upollo to Segment to further improve the analysis we give you.

At this point you can deploy your code and start sending events to Upollo. Once Upollo starts to receive these events you will be able to log in to the dashboard and see information about your customers and get an understanding for how many are sharing accounts, and the size of the opportunity to convert them into paying customers.

Step 2: analyse results in the Dashboard

To access to the Dashboard, visit app.upollo.ai/login and sign in.

Once signed in, you should see:

1. A graph showing the amount of account sharing, multi-accounting (the same person using different accounts) and repeated actions (signups, redemptions).

2. A list of users that have been flagged

If you don't see the data above, check that your code is deployed and events are being sent to Upollo. The events are immediately processed, so you should see them in the Dashboard soon after they are sent to Upollo.

Viewing the graph

The graph gives you a summary of the incidences of account sharing, multi-accounting and repeated actions.

You can split the analysis by device, user, or requests:

• Devices: the number of distinct devices that are flagged. A user may use multiple devices (e.g. laptop and phone).

• Users: the number of users that are flagged. Multiple people may login as the same user.

• Requests: the number of requests that were flagged, regardless of the user or device that made the request. Depending on the extent of account sharing, you could have 10% of your users account sharing, but because of the number of people they share with, they could account for 50% of your requests!

Viewing flagged users

The list of flagged users gives you details on what users have been flagged, when they were flagged, and what flags we have associated with them. You can see more details by clicking the actions on the right hand side. Here's an example user that was flagged as sharing an account:

In the example above, the user has logged in on different devices across multiple cities.

Next steps

Now that you understand the prevalence of account sharing in your product, you can begin to convert those users into happy, paying customers. One of the most effective ways to do this is to use Upollo's analysis in real time to detect account sharers as they use your product, and then show in-product prompts and nudges to suggest a paid offering. Upollo's real time analysis APIs are available on both client and server: try them out for yourself with a free trial of the Growth plan.