Consent Management

Overview

Alke Analytics is designed for privacy compliance. The SDK:

Reads consent status from your CMP (Consent Management Platform)
Adapts data collection based on user choices

How It Works

The SDK automatically listens for the IAB TCF 2.0 __tcfapi:

Detects if a CMP is present
Listens for consent changes
Queues events while CMP UI is shown
Releases/discards events based on consent decision

// No configuration needed - automatic detection
alkeAnalytics.setConfig({
    propertyId: 'your-property-uuid'
});

Purpose	ID	Description
Store/access information	1	Required for cookies (userId, sessionId)
Measure advertising	7	Ad creative tracking
Understand audiences	9	Analytics and segmentation
Develop/improve services	10	Performance metrics

No-exemption mode

By default the SDK collects data under the consent exemption: reports are sent immediately and individual sensitive fields are degraded until the relevant consent is granted.

Set requireExplicitConsent: true to switch to no-exemption mode. While consent applies, no report leaves the browser until the user grants explicit consent to the Alke Tech vendor (IAB TCF vendor 1506):

alkeAnalytics.setConfig({
    propertyId: 'your-property-uuid',
    requireExplicitConsent: true
});

Behaviour:

The tag keeps working normally — pageview/event tracking and ad-request targeting (alke_id) run as usual, so you never miss ad requests. Only the transmission of data to the Alke Analytics servers is held back. Cookie behaviour (alke_u, alke_s, alke_v) is unchanged compared to the default mode — cookies still follow the same consent rules and are not written before consent regardless of this option.
While consent is pending, reports are buffered client-side, keyed per logical event (a counter per tracking call; the video id for videos — not the pageview id). If the same event is updated (for example a partial then a final report, or video heartbeats), only its most recent version is kept. Two distinct events (e.g. a pageview and a custom event) remain separate reports.
As soon as explicit vendor consent is granted, all pending reports are flushed at once — each logical event sent once, at its most recent version — and every later report is sent without delay.
If explicit consent is never obtained, no data is sent at all and the buffered reports are dropped when the page unloads. This is the intended behaviour of the mode — without verifiable explicit consent, nothing is reported (unlike the default mode, which would still send degraded data).
Explicit vendor consent is the only thing that releases a report. Consent is not required is not consent was given, so none of the following sends anything: a refusal, no decision, a CMP that errors or never loads, a CMP blocked by an ad blocker, a cmpId absent from the bundled allowlist, a CMP reporting gdprApplies = false, and a visitor outside the GDPR perimeter.
This is the trade-off of the mode, and it is deliberate: traffic that never consents is never measured. If you want the consent exemption to keep carrying that traffic, use the default mode. Cookie behaviour and the consent-wrapped fields are unaffected — they keep following their own rules, identical in both modes.
The client-side buffer is bounded (up to 1000 reports, de-duplicated per logical event); beyond that the least recently updated held report is dropped (a continuously re-reported event, like the current pageview or video heartbeats, is kept). A normal page never reaches this limit — it just caps memory on a long-lived SPA that never obtains consent.

Use this mode when a publisher requires that analytics collection be strictly gated behind explicit consent rather than relying on the legitimate-interest / exemption basis.

Available on the native SDKs too, with one platform caveat — see the iOS, Android and Tizen tabs.

CMP Integration

The SDK reads consent from UserDefaults using IAB TCF keys:

AlkeAnalytics.setConfig(AlkeConfig(
    propertyId: "your-property-uuid",
    appVersion: "1.0.0",
    cmpEnabled: true  // Reads from UserDefaults
))

The SDK automatically adapts tracking behavior based on consent status read from your CMP.

No-exemption mode

AlkeAnalytics.setConfig(AlkeConfig(
    propertyId: "your-property-uuid",
    appVersion: "1.0.0",
    cmpEnabled: true,
    requireExplicitConsent: true
))

Every report is withheld until your CMP records consent for Alke Tech, IAB TCF vendor 1506. Held reports are de-duplicated per logical event — only the most recent version of each is sent — released as soon as that consent arrives, and kept in memory only: if consent never comes, or the process dies first, nothing is sent and nothing was stored. That consent is the only release: a CMP that never writes its keys and a gdprApplies = false report nothing either, so a reader who never consents is never measured.

CMP Integration

CMP mode is enabled by default. The SDK reads consent from SharedPreferences (IAB TCF 2.0):

AlkeAnalytics.setConfig(
    context = this,
    config = AlkeConfig(
        propertyId = "your-property-uuid",
        appVersion = BuildConfig.VERSION_NAME
        // consentMode = AlkeConfig.ConsentMode.CMP is the default
    )
)

The SDK automatically adapts tracking behavior based on consent status read from your CMP.

By default, the SDK uses CMP mode. To disable consent checks for non-GDPR regions:

AlkeConfig(
    propertyId = "...",
    appVersion = "...",
    consentMode = AlkeConfig.ConsentMode.DISABLED
)

No-exemption mode

AlkeConfig(
    propertyId = "...",
    appVersion = "...",
    requireExplicitConsent = true
)

Same contract as iOS: nothing leaves the device until your CMP records consent for IAB TCF vendor 1506, held reports are de-duplicated per logical event and kept in memory only, and that consent is the only thing that releases them.

Tizen has no IAB TCF source, so consent comes from the built-in consent UI rather than from a CMP. consentMode tells the SDK which of the two situations it is in:

AlkeAnalytics.configure({
    propertyId: 'your-property-uuid',
    appVersion: '1.0.0',
    consentMode: 'integrated'   // 'disabled' (default) | 'integrated' | 'external'
});

Mode	Consent applies	Storage	Visit state
`disabled` (default)	No	Allowed	Counted, `vq` reported
`integrated` / `external`, no answer yet	Yes	Held — nothing written, nothing erased	`vq = 0`, `nl` not sent
`integrated` / `external`, accepted	Yes	Allowed	Counted, `vq` reported
`integrated` / `external`, refused	Yes	Erased	`vq = 0`, `nl` not sent

disabled is a publisher setting, not a reader’s answer: it is never written to storage, so switching back to integrated restores the choice the reader had already made instead of asking again.

No-exemption mode

AlkeAnalytics.configure({
    propertyId: 'your-property-uuid',
    appVersion: '1.0.0',
    consentMode: 'integrated',
    requireExplicitConsent: true
});

Platform caveat. Tizen carries no IAB vendor bitfield, so there is no vendor 1506 entry to read. What plays that role is the integrated consent UI’s own answer: accepting it is the explicit, verifiable yes the mode requires, and it is the only one this platform can produce. Use requireExplicitConsent on Tizen only together with consentMode: 'integrated' — with disabled there is nothing that could ever answer, so no report would ever be sent.

The Report Always Goes Out

Consent degrades a report; it never suppresses one. A reader who refused, and a reader who has not answered yet, both produce a report — with vq = 0, no nl, no campaign, and cr telling the two apart.

This matters for your numbers: until this change the iOS and tvOS SDKs dropped a refused reader’s report entirely, so Apple traffic never appeared in the unknown engagement bucket and any web-versus-app volume comparison was short by your refusal rate. Expect a step up in reported app pageviews when this ships.

Campaign parameters are gated too. utm_source, utm_medium, utm_campaign, utm_term and utm_content require purposes 1, 7 and 9 — the same ones the web tag requires — and are simply absent without them. The campaign still drives the arrival category, the newsletter rule and the visit count internally: knowing it is not reporting it.

The SDKs follow the web contract: an identifier is always produced and always sent. Consent decides only whether it is kept.

Consent state	Identifier reported	Stored identifier
Not required, or accepted	the stored one, created if absent	written
Required, no answer yet	the stored one if any, otherwise ephemeral	left alone — neither created nor deleted
Refused	the one the page started with	deleted

Two consequences worth planning for:

Granting consent promotes, it does not renumber. An identifier the current page has already reported is written to storage as-is, so one page never reports two readers. Refusing and later accepting, on the other hand, yields a new identifier: the erased one is never recovered.
Without storage consent the identifier lives for one page, regenerated at every pushNavigation(). On native this is deliberately stricter than the web tag, which keeps one identifier for the whole document — so a single-page web app reports one reader where a native app reports one per screen. Expect a one-off rise in “new users” proportional to your refusal rate when this ships.

On iOS and tvOS the stored identifier lives in the Keychain, which survives app deletion — which is exactly why a refusal deletes it rather than leaving it in place.

The same three states apply to the session and to the buffered report queue, with one distinction the user ID does not have: a read is not a write.

Consent state	Reading	Writing
Not required, or accepted	passes	written
Required, no answer yet	passes	nothing
Refused	nothing, and what was left is purged	nothing

Reads pass while the CMP has not answered because the web tag does the same — it reads alke_s unconditionally and gates only the write — so a session opened before the answer keeps being used once it arrives.

Two consequences:

Without storage consent the session does not survive an app restart, so pageNumberInSession starts again at 1 on each launch. It still grows from screen to screen within one launch, where the web restarts at 1 on every page load: a native screen is not a document load.
The offline queue is kept in memory only, so events buffered without storage consent are lost if the process is killed. The web behaves the same way, dropping its buffer at unload.

Wrap sensitive values so they’re only sent with consent. The wrapper checks both vendor consent (Alke vendor ID: 1506) and purpose consent before sending the actual value.

// holdUntilConsent(value, fallback, purposes)

// Email only sent with purpose 1 consent
alkeAnalytics.setCustomData(1,
    alkeAnalytics.holdUntilConsent(userEmail, null, [1])
);

// User ID with anonymous fallback
alkeAnalytics.setCustomData(2,
    alkeAnalytics.holdUntilConsent(userId, "anonymous", [1, 9])
);

// Named dimensions accept the same wrapper
alkeAnalytics.setDimension('goal',
    alkeAnalytics.holdUntilConsent('subscription', 'account', [1, 7])
);

On setDimension(), both branches of the wrapper are validated — the consented value and the fallback. A fallback outside the dimension’s accepted shape rejects the whole call and returns false, rather than being accepted here and dropped on arrival. See Content Dimensions.

// Email only sent with purpose 1 consent
let emailWrapper = AlkeAnalytics.holdUntilConsent(
    value: userEmail,
    defaultValue: nil,
    purposes: [.storeAndAccessInformation]
)
AlkeAnalytics.setCustomData(1, value: emailWrapper)

// User ID with anonymous fallback
let userWrapper = AlkeAnalytics.holdUntilConsent(
    value: userId,
    defaultValue: "anonymous",
    purposes: [.storeAndAccessInformation, .understandAudiences]
)
AlkeAnalytics.setCustomData(2, value: userWrapper)

Available TCF Purposes

Purpose	Enum Value	ID
Store/access information	`.storeAndAccessInformation`	1
Measure advertising	`.measureAdvertisingPerformance`	7
Understand audiences	`.understandAudiences`	9
Develop/improve services	`.developAndImproveServices`	10

// Email only sent with purpose 1 consent
val emailWrapper = AlkeAnalytics.holdUntilConsent(
    value = userEmail,
    defaultValue = null,
    purposes = listOf(TCFPurpose.STORE_AND_ACCESS_INFORMATION)
)
AlkeAnalytics.setCustomData(1, emailWrapper)

// User ID with anonymous fallback
val userWrapper = AlkeAnalytics.holdUntilConsent(
    value = userId,
    defaultValue = "anonymous",
    purposes = listOf(
        TCFPurpose.STORE_AND_ACCESS_INFORMATION,
        TCFPurpose.UNDERSTAND_AUDIENCES
    )
)
AlkeAnalytics.setCustomData(2, userWrapper)

Available TCF Purposes

Purpose	Enum Value	ID
Store/access information	`TCFPurpose.STORE_AND_ACCESS_INFORMATION`	1
Measure advertising	`TCFPurpose.MEASURE_ADVERTISING_PERFORMANCE`	7
Understand audiences	`TCFPurpose.UNDERSTAND_AUDIENCES`	9
Develop/improve services	`TCFPurpose.DEVELOP_AND_IMPROVE_SERVICES`	10

Behavior

If consent is not granted for all required purposes:

null fallback → dimension not sent
String fallback → fallback value sent instead

The consent status is checked at send time, so if consent changes after setting the wrapper, the latest status is used.

Blocking Tracking (Web)

Allow users to opt-out completely, regardless of CMP:

// Permanently block tracking (sets cookie for 13 months)
alkeAnalytics.blockTracking();

// Re-enable tracking
alkeAnalytics.unblockTracking();

This sets a alke_no_tracking cookie that persists across sessions.

Event Queuing

When a CMP UI is displayed (consent not yet given):

Events are queued (not dropped)
After 30 seconds without decision, queued events are sent with partial data
When consent is given, queued events are sent with full data
When consent is refused, sensitive fields are stripped

No Data Loss

Pageviews are never lost. If consent is refused, they’re sent without consent-dependent fields (user ID, UTM parameters, etc.).

Personal Data Scrubbing (Web)

UTM parameters arrive from the URL, where you do not control what a third party may have put in them. The five of them — utm_source, utm_medium, utm_campaign, utm_term, utm_content — are scanned before being reported, and a value shaped like personal or identifying data is discarded rather than stored:

an email address
a UUID
a hash digest: MD5, SHA-1, SHA-256, SHA-384, SHA-512

This is a floor, not a consent-gated behaviour: it applies whatever the consent state. It covers the UTM parameters and the URL dimensions pageUrl and assetUrl, whether the collector derived them or you set them yourself. Everything else you set — setCustomData() and the non-URL dimensions — is reported as given, so wrap anything sensitive with holdUntilConsent().

CMP Compatibility

The SDK works with any IAB TCF 2.0 compliant CMP, including:

AppConsent
Cookiebot
Didomi
OneTrust
Quantcast Choice
Sourcepoint
TrustArc

CMP Validation

The SDK validates the CMP ID against the official IAB vendor list. Unregistered CMPs are ignored.

Overview

How It Works

Consent Purposes Used

No-exemption mode

CMP Integration

No-exemption mode

CMP Integration

Bypass Consent (Non-GDPR regions)

No-exemption mode

Consent Mode

No-exemption mode

The Report Always Goes Out

What Consent Gates on the User ID

What Consent Gates on the Session and the Offline Queue

Consent-Wrapped Data

Available TCF Purposes

Available TCF Purposes

Behavior

Blocking Tracking (Web)

Event Queuing

Personal Data Scrubbing (Web)

CMP Compatibility