General information, not legal advice
Privacy law differs between countries and changes. This article is about design choices. Have a lawyer check what you collect against the rules that apply to your customers.
Start with what you already have
A licensed app already produces useful data, and none of it requires watching the customer. If you use Clavem, three signals come with the license records.
| Question | Where the answer is |
|---|---|
| How many people bought it? | Stripe, and the license list |
| How many of them ever activated it? | License status: inactive is issued with no active device, active has at least one |
| Is anyone still using it? | last_validated_at on each license, and last_seen_at on each device |
| Who is about to churn? | Subscription licenses that expired |
One caveat. inactive means no device is active now. It covers a license that was never activated and one whose every device was later removed, so read it as “not in use” rather than “never used”.
A script can compute those numbers from the management API without touching the app. It pages through licenses, newest first, using limit up to 100 and the next_before cursor:
async function* allLicenses(get) {
let before = null;
do {
const page = await get(before); // GET /v1/admin/licenses?limit=100&before=...
yield* page.data;
before = page.next_before;
} while (before);
}
// For each license: count by status, and count last_validated_at within 30 days.
I ran it against a mock that served 250 licenses in three pages, to check the pagination and the counting. It is not production data. The point is that “purchases, activated and recently seen” needs no analytics SDK.
What these numbers cannot tell you
License data says that a device checked in. It does not say which features people use, where they get stuck or why they stop. For those you need events from the app, and that is where privacy choices begin.
Six events that cover most decisions
Keep the list short. Each event you add is something to explain.
| Event | Properties | Question it answers |
|---|---|---|
app_launched |
App version, operating system family | Is it used, and on what |
license_state |
licensed, expired, needs-network or unlicensed |
How many launches are paid, and how often the offline fallback runs |
activation_result |
ok or an error category such as limit or not_found |
Where activation fails |
update_prompt |
shown, installed or skipped, and the version |
Do customers update |
feature_used |
A feature name from a fixed list | What matters in the product |
crash_reported |
A coarse error category | Stability by version |
The license_state event is the one specific to paid software, and it pays off. A rising share of needs-network points to an offline-fallback bug, and a rising share of expired is a renewal reminder waiting to be sent.
What never goes in an event
- The license key. It is a credential and it links to a person.
- The buyer’s email or name. The same reason.
- File names, document titles, paths or text the user typed. Those are content.
- The device fingerprint you send to the license server. Keep that in the license system only.
- Free-text error messages. They can contain paths and names. Send a category.
- Precise location. If you need a region, derive a country from the connection on the server and discard the address.
Keep the analytics path separate from the licensing path. If both carried the same identifier, anyone with access to both could connect a feature log to a named customer.
Anonymous counting without a stable id
Counting unique active users needs some identifier. There are ways to count without keeping one.
A daily hashed id. Aptabase’s privacy policy describes this. It builds an anonymous daily identifier on the server from a keyed hash, SipHash, of the client’s IP address and user agent. The key is a random salt that is unique for each app, rotated every 24 hours and deleted within 48 hours of its creation. The IP address and user agent are processed in memory and not stored. Once the salt is gone, the hash cannot be traced back to the address, and the same person gets a different id on different days. The trade-off is that you can count daily actives but not follow a person over weeks.
A random install id. The app generates a random id on first run, stores it locally and sends it with events. It lets you measure retention across weeks. It is still an identifier tied to an installation, so describe it in your privacy statement and let users reset it.
No id. Count events, not people. Launches per day and per version tell you plenty.
TelemetryDeck states in its privacy FAQ that it collects only the data you explicitly send, anonymizes user identifiers before they leave the device, uses no cookies, and that in its view no opt-out is legally required. Those are the vendor’s statements about its own product. They are useful when you choose a tool, and they do not replace your own legal check.
Opt-in, opt-out or neither
| Approach | Effect | Fits |
|---|---|---|
| No analytics | Nothing to explain | Very small apps, tools for privacy-focused users |
| Anonymous counts, disclosed | Low friction, honest | Most paid apps |
| Opt-in for richer data | Smaller sample, high trust | Apps whose users handle sensitive material |
A visible switch in settings that turns analytics off earns trust at almost no cost. A switch hidden in a config file does not.
Document it
Write three sentences for your privacy statement: what you collect, where it goes and how long you keep it. The license check belongs there too, and it is short. The call sends the license key, a device name and an optional hashed fingerprint, and receives the license status and a signed token. Tell users that, and you have described both.
Reading the numbers
Numbers without a baseline mislead. A few habits keep small-app analytics honest.
- Compare like with like. Launches per day rise when you ship a release and when a customer scripts your tool. Count distinct daily ids as well as launches.
- Watch ratios, not totals. The share of launches in the
licensedstate, and the share of licenses seen in the last 30 days, say more than raw counts. - Expect gaps. Customers who switch analytics off, block the host, or run offline never report. Treat the figures as a floor.
- Keep a short retention period. If aggregates answer your questions, delete raw events after a few weeks and keep only the daily counts.
- Review the list twice a year. Remove events nobody looked at. Fewer events mean less to disclose and less to leak.
Doing this with Clavem
Clavem’s dashboard shows active licenses, activations and validations over 30 days, with per-license devices and last-seen times, and the management API returns the same fields. It does not collect any behavior from inside your app, and it does not need to. Pick an analytics tool separately, send the six events above, and keep the two systems apart. For how the license check itself should fail, see offline-first apps and licensing.
Questions
Can I use the license key as the user identifier in analytics?
Avoid it. A license key identifies a paying customer and joins to their email and purchase. Sending it to an analytics tool turns anonymous usage into personal data. Use a random id made at install, or no id at all.
Do I need consent for app analytics?
It depends on what you collect and where your users are. Tools that send no personal data may avoid the need for consent, but the tool's own claim is not a legal opinion. Describe what you collect in your privacy statement and ask a lawyer who knows the laws that apply to you.
What can I learn without any analytics?
From license data you can count purchases, activated and never-activated licenses, devices seen in the last 30 days and licenses that expired. That answers whether people use what they bought, without watching what they do in the app.