Understanding how many users are getting repeat trials

If your product gives users free or discounted trial periods, then you likely have users repeatedly signing up for these trials instead of converting to a fully paid account. The first step in addressing repeat trials in 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 analysis in the Dashboard to see users that have multiple accounts, and hence, multiple trials. 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 using multiple accounts to get repeat trials, we firstly 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 register for an account:

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 register for an account.
upollo.track(
  { userEmail: "person@example.com" },
  EventType.EVENT_TYPE_REGISTER
);

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 register for an account.
if let u = upollo {
  u.track(UpProto_UserInfo.with { i in
      i.userEmail = "person@example.com"
  }, did: UpProto_EventType.register)
}

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 register for an account.
upollo.track(userInfo {
    userEmail = "person@example.com"
}, EventType.EVENT_TYPE_REGISTER)

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 register for an account.
upollo.track(
    UserInfo.newBuilder().setUserEmail("person@example.com").build(),
    EventType.EVENT_TYPE_REGISTER)

Once the user successfully registers, you should also send an EVENT_TYPE_REGISTER_SUCCESS so that Upollo knows the registration 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:

• Registration: EVENT_TYPE_REGISTER and EVENT_TYPE_REGISTER_SUCCESS
• Login: EVENT_TYPE_LOGIN and EVENT_TYPE_LOGIN_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 have signed up for multiple accounts, and the size of the opportunity to convert them into paying customers.

Step 2: Analyse results in the Dashboard

To access 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 (multiple people using the same account), multi-accounting (the same person using different accounts) and repeated actions (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.

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 having multiple accounts:

In the example above, the user has created multiple accounts to continually use a free trial, instead of signing up for a paid account. We can see the details of the other accounts, as well as when we last received an event for the account.

Next steps

Now that you understand the prevalence of multi-accounting 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 repeat sign-ups as they attempt to register, 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.