Skip to content

Privacy and network

Scoring happens on the device. With a production appId, the input the SDK captures feeds the on-device core and nothing else: it is never uploaded. The SDK makes network requests for three things only, each described below: model updates, attestation, and proofs.

What the SDK captures

Input What is recorded Where
Touches, stylus, mouse Position, timing, pressure and its range, contact size, stylus tilt, buttons, the kind of tool Every platform
Scrolling Wheel and trackpad deltas Every platform
Device motion Accelerometer and gyroscope readings, at the rate your app sets. On Android, iOS and Flutter only one reading every 3 seconds is kept while the user is idle Phones and tablets, including their browsers
Keys The class of the key (letter, digit, space, and so on), modifiers and timing, never the character Desktop browsers, except in password fields. Typing on mobile browsers. Android, iOS and Flutter only when your app reports key classes
What a touch landed on The kind of control, and a short hash of the identifier your app gave it Android, iOS, Flutter, React Native. On the web, only when you turn on targets, and then the kind of control only
App state Foreground and background Every platform
The device Screen size and density, rotation, number of touch points. On the web, also the operating system from the user agent and, in Chromium browsers, the platform version and device model from the high-entropy User-Agent Client Hints (getHighEntropyValues), which show no prompt Every platform

The SDK never reads text: not what is typed, not field values, not labels, and not what is on screen. Nothing is captured before the user consents, where consent is required, or while capture is paused (see each platform's User Consent and Sensitive Screens pages).

Where captured input goes

With a production appId the captured input goes to the on-device core, which turns it into the score and keeps only the most recent actions. Nothing captured is written to storage or sent over the network. Custom events your app records stay on the device too.

Network requests

Purpose Requests When What is sent
Model updates GET https://sdk.dep-protocol.com/models/prod/manifest.json, then the model file it names Each time the SDK starts, and on Android, iOS, Flutter and React Native again when the app returns to the foreground a day after the last check. The web skips it with modelUpdates: false, and waits for consent when consent is required Nothing about the app, the user or the device: a plain request with If-None-Match, no cookies
Attestation GET https://poh-api.dep-protocol.com/api/attest/challenge, then POST https://poh-api.dep-protocol.com/api/attest Only after your app calls attest(). Android, iOS and Flutter then renew it shortly before it expires, about once an hour while the app runs; the web registers again on the next attest() call after that X-App-Key, the challenge, the device's public key, the platform's attestation token (none on the web), and on Android and iOS, device-integrity codes
Proofs POST https://poh-api.dep-protocol.com/api/sessions and PUT https://poh-api.dep-protocol.com/api/sessions/{id} Only through Ads and activities: the ad session on the Web, and the proof calls your app makes on Flutter, Android, iOS and React Native X-App-Key, and a proof signed with the device key: the score, the number of actions behind it, the model version, the session id, the event it is for, the ad unit or activity id you named, and your app user id when you pass one
AI Data Tasks POST https://poh-api.dep-protocol.com/api/tasks/projects, POST https://poh-api.dep-protocol.com/api/tasks/fetch, POST https://poh-api.dep-protocol.com/api/consent and POST https://poh-api.dep-protocol.com/api/contributions; the task's widget and images from https://sdk.dep-protocol.com Only when your app lists the projects or runs a task: see AI Data Tasks on the Web, Flutter, Android, iOS and React Native X-App-Key, and requests signed with the device key: your app user id, the platform, the SDK version, the project, the consent version, and the user's answer with the score

During attestation the operating system also contacts Google Play Integrity (Android) or Apple App Attest (iOS).

The device-integrity codes are short names for what the SDK found on the device, such as a root or jailbreak indicator, a hooking framework, a debugger or an emulator. They never include file paths or other content. With automationDetection on, the SDK also reads them when it starts, to stop on a rooted or jailbroken device; that reading stays on the device.

On the web, a Content Security Policy must allow these requests and the SDK's core; the Web guide lists the directives.

What the SDK stores on the device

What Android iOS Web
The consent answer SharedPreferences file ai.dea, key ai.dea.consent UserDefaults key ai.dea.consent localStorage key deapnetwork.consent
The device signing key, after Attest Android Keystore alias dea.device-key (StrongBox or TEE when available) Keychain, tag ai.dea.device-key, in the Secure Enclave when available, this device only IndexedDB database deapnetwork.device-core, a non-extractable key
The attestation receipt SharedPreferences file ai.dea, key ai.dea.receipt Keychain, service ai.dea; it survives reinstalling the app In memory only
Downloaded models noBackupFilesDir/dea/models/ota/ Application Support/dea/models/ IndexedDB database deapnetwork.device-core

Flutter and React Native store the same values as Android and iOS, in the same places. Flutter keeps downloaded models in the app support folder, or in the modelDirectory you pass. The SDK sets no cookies. Captured input is held in memory only.

For app store disclosures

Google Play's Data safety form and Apple's App Privacy details ask what data leaves the device. These are the facts they ask about, for a production appId; how you answer each form is your decision.

Data Leaves the device? When
Touches, scrolling, device motion, key classes and their timing No: the core reads them on the device and keeps none of them —
Text, screen content, contacts, location, advertising ID, device identifiers Never read —
The public half of the device key Yes, to DEA When your app calls attest()
The Google Play Integrity or Apple App Attest token Yes, to DEA When your app calls attest() on Android or iOS
Device-integrity codes (root, jailbreak, hooking framework, debugger, emulator indicators) Yes, to DEA When your app calls attest() on Android or iOS
A signed proof: the score, the number of scored actions, the model version, the ad session id DEA issued, the ad event, and the ad unit or activity id Yes, to DEA Only through Ads
Your app user id Yes, to DEA In AI Data Tasks, and in Ads when your app passes appScopedUid
The user's answer to an AI data task, with the score Yes, to DEA Only through AI Data Tasks, after the user consents on the task's consent screen
The model update check A plain request that carries no data about the app, the user or the device Each time the SDK starts

On iOS the SDK ships no privacy manifest (PrivacyInfo.xcprivacy): your app's own manifest declares the required-reason APIs the SDK calls, listed in the iOS guide.

Permissions

Platform What the SDK needs
Android INTERNET, merged from the SDK's manifest. No runtime permission prompt. The SDK depends on Google's Play Integrity library
iOS No permission prompt and no Info.plist entry. Attest needs the App Attest capability. The SDK ships no privacy manifest; see the iOS guide for what your app declares
Web A secure origin (HTTPS or localhost). On iOS and iPadOS browsers, the motion permission prompt, shown on the user's first tap, or when the page calls setMotion(true); it appears even before the user has consented when consent is required. No other prompt

Logging

The published packages log nothing in production builds, and the SDK never sends logs anywhere. On Android, debug = true prints one line per captured object to Logcat with an SDK build of the test channel only, and nothing in a production build: keep it off in release builds.

Telemetry

Telemetry is what the SDK reports while it runs: its log, one entry per step it takes, and the input it captures. On the staging and test packages both reach your app, and your code decides where they go. The production package reports neither.

Log Captured input
What it holds One entry per SDK step: the SDK started, a device key was registered, a proof was accepted Every object the SDK captures: pointer, wheel and key-class events, device motion, app state, your custom events
How your app receives it The onLog callback An integration of your own, passed in integrations
Packages Staging logs INFO and up, test down to DEBUG. Production logs nothing Staging and test. Production refuses your integrations
Leaves the device Only when your code sends it. The SDK never sends a log entry Only when your code sends it, or when you attach DEA's collection transporter, which sends it to DEA: see Collecting data
Turn it off logLevel: 'off' on the web, or the production package Remove your integration, or the production package

Each platform's Telemetry guide shows both, with the fields of a log entry and of a captured object: Web, Android, iOS and Flutter. On React Native neither reaches JavaScript.