How are Daily Active Users measured? (App)

What is a DAU?

A Daily Active User (DAU) represents one unique device that interacts with your app at least once during a calendar day.

Usercentrics counts a DAU when the Usercentrics SDK initializes on a device. This can happen when the app is opened or when the operating system wakes the app in the background.

How Usercentrics counts DAU

• One count per device per day: 
  Usercentrics counts a DAU the moment the SDK initializes on a device. 
  Initialization can happen when the app is:

  • Opened (user launches it)

  • Resumed (the app was in the background and the user comes back to it)

  • Woken by the system (the operating system briefly starts the app to handle things like notifications or background tasks).

• Daily window (UTC)
  DAU is calculated based on calendar days, meaning UTC time 00:00:00 to 23:59:59 UTC. If the SDK initializes before and after this window boundary (e.g., 23:58 and 00:02 UTC), the device is counted once for each day.

• Deduplication mechanism
  To avoid multiple counts, the SDK stores the last day the device was counted. If another initialization happens on the same day, Usercentrics ignores it.

What is ADAU?

ADAU (Average Daily Active Users) represents the average number of DAUs your app has during a month.

Formula:

ADAU = (DAU Day 1 + DAU Day 2 + … + DAU Day n) / number of days in the month

Usercentrics uses monthly ADAU as the basis for pricing.

Why use an average?

Daily usage naturally fluctuates depending on the nature of the app.
Using an average ensures pricing reflects real usage patterns without penalizing spikes.

Examples:

• A football app may see high activity only on match days.

• A shopping app may peak during sales or holiday periods.

ADAU smooths these variations to give a fair and stable view of app activity.

When a device might be counted twice

There is one valid exception where a device may be counted more than once on the same day:

• User manually clears app data
  Clearing data removes the stored timestamp used for deduplication. The next initialization is treated as a new device state and results in another DAU count on the same day.

• Session restore
  A session is restored when the app automatically deletes or rebuilds its local storage.
  This can happen if the user reinstalls the app, the app restores a backup, or the app resets its own data. In these cases, the SDK timestamp is removed, and the next initialization may be counted as another DAU on the same day.

This behavior is expected, as the SDK cannot identify the device once its data has been erased.

Why DAU can differ between iOS and Android

The two platforms behave differently when handling background events. This affects how often the SDK initializes, and therefore how often a device can be counted (with deduplication still preventing overcounting within a day).

Conclusion

• On iOS, SDK initialization usually reflects real user activity.

• On Android, SDK initialization can also happen due to system-triggered background events.

• Deduplication ensures only one DAU per day, but these differences affect when the first initialization happens.

What the SDK counts vs. what counts as an active user

These two things are related but not the same:

• How the SDK counts (technical mechanism). The Usercentrics SDK registers a DAU the moment it initializes on a device. Initialization is tied to your app's lifecycle, so, depending on where you call initialize()/configure() and on platform behavior (see the iOS vs. Android table above), it can also run when the operating system briefly wakes your app in the background (push delivery, device boot, scheduled tasks), with no user actively using the app.
• What counts as an active user (contractual definition). Daily Active Users are defined as the number of unique mobile users who had at least one active session in a 24-hour time frame, hence a genuine user who engaged with the app that day.

They can diverge when initialization is placed at a lifecycle entry point that also fires on background or OS-triggered launches: in that case the SDK may register initializations that don't correspond to an active user session as defined above. The SDK measures exactly what it's built to. It treats 'the app's lifecycle started' as a proxy for 'a user is active,' and that proxy breaks on background wake-ups.

What this means for your integration: To keep your reported DAU aligned with genuine active users, initialize the SDK at a point tied to the app being brought to the foreground by a user, rather than from a lifecycle hook that also runs on background or OS-triggered launches.