Privacy and data
What each mode does with the data, so you can write your consent and your record of processing: what leaves the device, retention layer by layer, what the SDK keeps in the browser, Engine and DevLab.
There are two modes and they handle the data differently. Read the part for the mode you use, and both if you offer both: On-device (real time) and Deferred (server-side). See Integration paths for what each one is.
What leaves the device, by mode
Section titled “What leaves the device, by mode”- On-device (real time): Landmarks, expression coefficients and head pose, to Engine, which computes the indicators; with an interpretation, Engine sends the indicators to an LLM that writes it. Only if you turn them on: the transcript (speech recognition runs in the browser, so the audio stays and the text goes; Engine passes it, with the indicators, to the LLM) and the extra signals (voice as numbers, pulse, hands, body). Never image, video or audio.
- Deferred (server-side): Video and audio (with the camera, the microphone is always on) to your receiver, and from there to the processing service, which, with transcription on, transcribes the whole audio of the recording on the server and passes to Engine only the text of the steps the job asks for (
transcribeSteps). As on-device, Engine computes the indicators and, with an interpretation, sends them and any text to the LLM.
On top of that:
- In both modes, the enrolment id goes in most URLs: it will appear in your proxy’s access logs next to the person’s IP address, so give those logs a retention policy.
- On-device (real time): the device downloads the capture software from third-party servers, which see its IP address and user agent but receive nothing captured: the vision runtime from
cdn.jsdelivr.netand the face model fromstorage.googleapis.com; the hand and body models fromstorage.googleapis.com(only if you ask for them); with transcription, the speech runtime fromcdn.jsdelivr.netand the speech model (about 136 MB) fromhuggingface.coand*.hf.co. You can host the files yourself: see CSP and transcription. - When it downloads. Without
client.prepare()the device downloads those files when the capture starts. With it (Prepare before Start) it does so earlier, when your page calls it, so the same servers see the IP address and user agent before the person presses anything, and the data is spent even if they never start (about 13.5 MB for the face; about 160 MB more for speech). Decide where to call it, and say so in your notice. - In the DevLab playground. With a session and an active team, entering Measure downloads the face model (from
cdn.jsdelivr.netandstorage.googleapis.com) with no gesture from you. Speech (fromcdn.jsdelivr.net,huggingface.coand*.hf.co) downloads the same way only on a good connection, without data saver and on a wide screen; otherwise it waits for Measure or for Download now (being in the browser’s cache does not ask for it on its own). Nothing captured goes to those servers. The playground keeps the models in the page’s memory between sessions (the SDK’skeepPrepared; on Safari and iOS, only the face), so the next session does not load them again. It releases them when the test person changes, when the source switches between Camera and Sample video, when you choose another protocol, language or way, and when you leave the page; after a change of person or source it loads them again for the next one (speech only under the conditions above). After a session that loaded speech on a slow connection, with data saver or on a small screen (unless you chose Download now), and after one where you chose Continue without speech, it releases everything and loads the face again, without speech. - The startup report. The SDK keeps a report of each startup (stages, times, device checks) in the browser. DevLab does not include the user agent in it and sends it nowhere (no
startup.report.url). If you set aurl, your receiver stores browser data: your consent and notice must cover it (Your backend); DevLab mounts no receiver. - Deferred (server-side): the device downloads no models, so those servers see nothing from it. Only a download that happens exposes the IP address and user agent.
- Deferred, what the recording carries: raw audio and video, which identify a person more than numbers do, and the manifest that travels with it holds the browser’s full
userAgent(client.userAgent). The processing service keeps the full text it transcribes (also what is said outside the steps) only until the job ends, at most 2 h; Engine receives the text of the requested steps only.
What your consent must say
Section titled “What your consent must say”Neither the SDK nor Engine checks consent: collecting and recording it is your job. Collect it before captureProtocol, from a gesture of the person (a button they press), and keep the record. It has to cover:
- Both modes. Facial geometry is biometric data, and in practice a special category. On-device, the 478 points of a face are sent even though no photograph is; in deferred, the video that holds the face is what leaves. The purpose of the capture, how long you keep the results, and that deleting the person is physical and irreversible.
- On-device (real time). No video or audio is recorded. Landmarks and expression data go to Engine. With an interpretation, the indicators go to an LLM. With transcription, the literal transcript goes to Engine and to that LLM, and the speech models (about 136 MB) download from a third-party CDN. The microphone is only requested when transcription is on, and a
transcribeobject in the kit of your context turns transcription on. The DevLab kit of every context protocol carries one by default (Measurement’s does not). If your kit carries atranscribeobject, onlytranscribe: falsein your code keeps it off; with none, there is no microphone. Say it in the consent whenever your kit carries one. - Deferred (server-side). Video and audio are recorded, kept in the browser until they are uploaded, uploaded to your backend, processed by our processing service (with transcription on, it transcribes the whole audio of the recording, and only the text of the steps the job asks for (
transcribeSteps) reaches Engine). With an interpretation, the indicators and any transcript go to an LLM. The service deletes its working files; the copy in your receiver stays until you delete it (receiver.remove()). With the camera, the microphone is always on.
For your record of processing
Section titled “For your record of processing”- What data: facial geometry (478 landmarks, 52 expression coefficients, head pose); with transcription, the transcript; with extra signals, those values; in deferred, video and audio.
- Whose: the people you capture, identified by the opaque ids you choose.
- What for: the purpose you state in your consent; the interpretation is written by a language model and does not decide the result.
- Where it goes: Engine, in your organization. In deferred, also your receiver and the processing service. Third-party servers only deliver software and see the IP address.
- For how long: layer by layer, in the table below.
- Who deletes: you, with
DELETE /users/{externalId}and its required body{ confirm: externalId }for Engine, andreceiver.remove()for your receiver. The rest is automatic or the SDK’s.
Deletion and retention
Section titled “Deletion and retention”Layer by layer, from the browser to Engine:
| What | Where | Until | Who deletes it |
|---|---|---|---|
| The local copy of a recording | The browser (IndexedDB neuro-capture-recordings) | The 200 of complete, or a 410 | The SDK (uploadRecording, after the 200 or the 410; release() to discard it without uploading) |
| An unconfirmed upload | Your receiver | 72 h without activity | receiver.sweep() |
| A confirmed video | Your receiver | Until your backend removes it: it never expires on its own. Remove it at interpreting or at succeeded, whichever comes first. | receiver.remove(), which leaves a 7-day tombstone with no content |
| The service's copy, audio and transcript | The processing service | The end of the replay, when the job enters interpreting, or the end of the job (orphans are swept after 2 h) | The processing service |
| The job record (with the signed URL and the manifest) | The processing service | 30 days | The processing service |
| Results and frames | Engine | There is no automatic expiry today. | You, deleting the person (DELETE /users/{externalId}, physical) |
Two caveats about the receiver. It only deletes the unconfirmed uploads it holds (after abandonedAfterMs, 72 h by default) when your code calls receiver.sweep(): it starts no timers. And a confirmed video never expires on its own, so its retention is yours and belongs in your record.
The signed URL of a video (receiver.signedUrl) is a bearer credential: whoever holds it can download the video. It lasts 24 hours by default and never more than 7 days. Never log it; a reverse proxy keeps the query string in its logs.
Deleting a person (DELETE /users/{externalId} with the required body { confirm: externalId }) removes what Engine holds for them, physically. Whether it also reaches what the analysis store kept has not been measured: ask Neurologyca (see In Engine). In deferred with our service, the video, with its voice, is processed on Neurologyca’s servers, and your backend hands the service an Engine token to send the results: today a developer token, not limited to that capture, until Engine in production offers a token for a single capture. Neurologyca processes that data as your processor under the Data Processing Addendum (DPA) that your organization accepts with the DevLab Terms; use the deferred mode, a Preview feature, only with people who have given their informed consent.
What the SDK keeps in your browser
Section titled “What the SDK keeps in your browser”The SDK sets no cookies. What it writes in the device:
- While recording (deferred): the recording, in the IndexedDB database of recordings (its name, below), until your receiver confirms it. What nobody releases expires 72 h after the first chunk, but it is only deleted the next time that page uses recordings; if it never returns, it stays until the site data is cleared. On a shared device, the list of pending recordings holds everyone’s: filter by the current person before you upload.
- With transcription (on-device): the browser caches the speech models (about 136 MB). It is not personal data, but it shows that the site used transcription.
- With transcription, from kodec: in
localStorage, the keykodec.stt.v4keeps device facts for speech: whether a configuration killed the tab, the worst stall and latency measured, the browser version. No text and no identifiers. It never expires. InsessionStorage,kodec.stt.tabholds a random id of that tab and dies with it. Older keys (kodec.stt.v3,kodec.stt.intentando.v2) are removed by kodec itself. - Nothing captured on disk in the on-device mode: the transcript stays in memory and the SDK releases it when the capture stops. That is the device: Engine stores the text the SDK sends and serves it in
/results(see In Engine).
The names, as the browser shows them in its developer tools:
IndexedDB neuro-capture-recordings (deferred: the recording)localStorage kodec.stt.v4 (speech: device facts)sessionStorage kodec.stt.tab (speech: id of the tab)Cache Storage speech models (about 136 MB)Cookies noneOn a shared device, what stays in localStorage and in the cache passes from one person to the next. Clearing the site’s data in the browser removes all of it. With keepPrepared the models also stay in the page’s memory from one capture to the next, until client.release() or the page goes away; what is kept is models, not what was captured, but the face model may carry state from the last frame of one capture into the next, so on a shared device call client.release() between one person and the next, or leave the option off.
In Engine
Section titled “In Engine”What Engine keeps
Section titled “What Engine keeps”For each end user: the profile you send (external id, name, role, audience, narrative preferences, time zone), when the user was created and last active, which key created them, whether they are blocked, every frame received, the transcript, the results, the interpretations and the baseline.
There is no automatic expiry today: Engine keeps the data until you delete the user.
Who reads the text. /results returns, in speech, the question shown in each step and what was said (only in the test environment’s Engine; see speech). An admin key reads it for every person of its organization, a read_all key for the people it created, and a capture token reads only its own capture. It is deleted with the person.
Deleting a user
Section titled “Deleting a user”DELETE /users/{external_id} with { "confirm": "<external id>" } deletes the user and everything above, in one step: all or nothing, and irreversible. The answer counts what was deleted; keep it as your record.
Engine keeps a record of the deletion itself (the external id, the key that asked and the counts), and its server logs mention the external id. For what the interpretation service keeps, ask Neurologyca.
A read_all key deletes only the users it created. See the API reference (DeleteUser).
Blocking a user
Section titled “Blocking a user”POST /users/block makes every activity route answer 403 for that user (captures, results, interpretation, microinterventions) without deleting anything. You can still list, edit, delete and unblock them with POST /users/unblock. Both take the user in the query (?externalId=…); with no filter they act on every user within your key’s reach. Inside DevLab, deleting and blocking are for the organization admin only (see Access model).
The interpretation
Section titled “The interpretation”The interpretation receives the indicators, the transcript, your query and the narrative preferences of the user’s profile, together with your organization and the enrolment id. It does not receive the user’s name or external id. A language model writes the narrative; it does not decide the result.
In DevLab
Section titled “In DevLab”DevLab records your activity as a developer. In short (details in What DevLab records):
- Activity (sign-ins, key reveals, management actions and your team’s milestones): kept 12 months. After that, milestones stay but no longer say who triggered them.
- IP address: only for sign-in, activation, password reset and key reveals.
- End-user identifiers your team reaches through DevLab: kept 24 hours, only to apply the per-team limits.
- Playground: if you accept its consent, DevLab records its version, the language and a hash of the text with your activity (12 months; then it asks again). Each run creates a test person on your team’s organization with a random id; DevLab deletes it in Engine after 24 hours, or when you or your organization admin press Delete now, and then keeps the run only as a count, without ids. To let you go back to a session of the last 24 hours, DevLab’s server keeps, for each session, closed metadata: when it was enrolled, the audience it was enrolled with and the one Engine applied, the way (SDK or HTTP API), live or deferred and the state of its deferred job, and how it ended (whether the interpretation arrived, the number of steps, the duration and the state of the baseline). Only fixed values and numbers, never text or the transcript; they are deleted with the test person (after 24 hours, with Delete now or, if deleting it in Engine fails, when a retry succeeds). The calls you see stay in your tab; DevLab keeps their metadata (route, status, timing) in memory for 30 minutes, never their bodies. To capture with the camera, your browser downloads the face tracking software from a CDN, as an SDK integration does. An export is made in your tab, with placeholders instead of ids and without tokens or frames.
- Playground, deferred recordings: where the playground records, DevLab’s own receiver deletes the video when the job ends (success or final failure) and, as a cap, after 24 hours; an upload nobody confirms is deleted after 72 hours.
- Assistant: off unless your DevLab enables it. Your questions, the latest turns of the conversation, the language of the answer, the page you ask from and the docs pages it reads to answer go to Google (paid Gemini API, which does not use them to improve its models). Of a docs page, its text goes; of a DevLab screen, its name and, if «Where everything is» describes it, that description; you can remove the page before asking. With each question, DevLab also sends your role (developer, organization admin or Neurologyca admin), the state of your team (no team, inactive or active) and whether this DevLab offers invitations and hosted processing: values with no names or identifiers, so that the answer fits your situation. Invitations and hosted processing are a setting of this DevLab, not something about you. Before sending, DevLab removes Engine and Google API keys in their known format, JWT-shaped tokens, emails and the internal addresses of Engine; any other secret you paste is sent as is, so do not paste it. Google processes what is sent under the Gemini API terms; DevLab asks it not to store the conversation and cannot delete what has already been sent. DevLab keeps that you asked, when, from which page and in which language, which docs pages the answer cited, whether it answered from the docs, which destination it proposed, if any, whether something was removed, how it ended, the model and how much work it took (rounds, characters read, timings, tokens and an estimated cost) and your rating with its reason (from a fixed list), never the text, for 12 months. The conversation stays in your tab.
- DevLab updates by email: when something changes in DevLab, an administrator of Neurologyca can send a short email with the update (in English). It goes to the active accounts, to an extra list that an administrator maintains and, one-off, to the addresses they type. Every email carries an unsubscribe link: it opens a page where you confirm with one button, which stops the emails, and you still see the updates inside DevLab. The administrators of Neurologyca see the list of unsubscribed addresses, with the date, and can take an address off it (for example, if that person asks to get the emails again). For each send, DevLab keeps the address of every recipient (also the one-off ones, who may have no account) and its status (sent, failed or skipped); for each email, the unsubscribe token as a hash next to the address it was sent to; the list of unsubscribed addresses; and the extra list until an administrator removes an address. All of this is kept for as long as the feature exists, longer than the 12 months of activity: there is no automatic purge. Activity records that a send happened and its counts, never the addresses or the text of the email.
- Deferred processing credentials: DevLab keeps your organization’s processor key and webhook secret encrypted, and sends the service the secret (over TLS) and only a hash of the key. Each reveal, each generation of new values and each zip download with keys is recorded with your IP; activating or discarding is recorded too. Never the values.
- Acceptance of the terms: a record of each acceptance (email, account, team, organization, role, capacity, version, a fingerprint of each document, language, time, IP address and browser), kept for the life of the account and 10 years after it closes; the IP address and browser are cleared after 12 months. You see yours in Your account › My agreements.
- Never request bodies, keys or your end users’ data.
The documentation has no analytics; the only cookie is your session once you sign in.