Ir al contenido
DevLab

Privacidad y datos

Qué hace cada modo con los datos, para que puedas redactar tu consentimiento y tu registro de tratamiento: qué sale del dispositivo, la retención capa a capa, qué guarda el SDK en el navegador, Engine y DevLab.

En esta página
  1. Qué sale del dispositivo, por modo
  2. Qué tiene que decir tu consentimiento
  3. Para tu registro de tratamiento
  4. Supresión y retención
  5. Qué guarda el SDK en tu navegador
  6. En Engine
  7. Qué guarda Engine
  8. Borrar un usuario
  9. Bloquear un usuario
  10. La interpretación
  11. En DevLab

Hay dos modos y tratan los datos de forma distinta. Lee la parte del modo que usas, y las dos si ofreces ambos: En el dispositivo (tiempo real) y Diferido (en servidor). En Vías de integración está qué es cada uno.

  • En el dispositivo (tiempo real): Landmarks, coeficientes de expresión y pose, hacia Engine, que calcula los indicadores; con interpretación, Engine envía los indicadores a un LLM que la redacta. Solo si los activas: el transcrito (el reconocimiento de voz corre en el navegador, así que el audio se queda y el texto sale; Engine lo pasa, con los indicadores, al LLM) y las señales extra (la voz como números, el pulso, las manos, el cuerpo). Nunca imagen, vídeo ni audio.
  • Diferido (en servidor): Vídeo y audio (con la cámara, el micrófono va siempre) hacia tu receptor y, de ahí, al servicio de procesado, que, con la transcripción activada, transcribe en el servidor todo el audio de la grabación y solo pasa a Engine el texto de los steps que pide el trabajo (transcribeSteps). Como en el dispositivo, Engine calcula los indicadores y, con interpretación, los envía al LLM con el texto, si lo hay.

Además:

  • En los dos modos, el id de la inscripción va en la mayoría de las URLs: aparecerá en los logs de acceso de tu proxy junto a la dirección IP de la persona, así que dales una política de retención.
  • En el dispositivo (tiempo real): el dispositivo descarga el software de captura de servidores de terceros, que ven su dirección IP y su user agent pero no reciben nada capturado: el runtime de visión desde cdn.jsdelivr.net y el modelo de la cara desde storage.googleapis.com; los modelos de manos y de cuerpo desde storage.googleapis.com (solo si los pides); con transcripción, el runtime de voz desde cdn.jsdelivr.net y el modelo de voz (unos 136 MB) desde huggingface.co y *.hf.co. Puedes alojar los ficheros tú: ver CSP y transcripción.
  • Cuándo se descarga. Sin client.prepare() el dispositivo descarga esos ficheros al empezar la captura. Con él (Preparar antes de Empezar) lo hace antes, cuando tu página lo llama: esos mismos servidores ven la dirección IP y el user agent antes de que la persona pulse nada, y se gastan sus datos aunque nunca empiece (unos 13,5 MB la cara; unos 160 MB más la voz). Decide dónde lo llamas y dilo en tu aviso.
  • En el playground de DevLab. Con sesión y equipo activo, al entrar en Medir se descarga el modelo de la cara (de cdn.jsdelivr.net y storage.googleapis.com) sin ningún gesto tuyo. La voz (de cdn.jsdelivr.net, huggingface.co y *.hf.co) se descarga igual solo con buena conexión, sin ahorro de datos y en pantalla ancha; si no, espera a Medir o a Descargar ahora (estar en la caché del navegador no la pide por sí solo). Nada de lo capturado va a esos servidores. El playground guarda los modelos en la memoria de la página entre sesiones (el keepPrepared del SDK; en Safari e iOS, solo la cara), así que la sesión siguiente no los vuelve a cargar. Los suelta al cambiar la persona de prueba, al pasar el origen entre Cámara y Vídeo de muestra, al elegir otro protocolo, idioma o vía, y al salir de la página; tras un cambio de persona o de origen los vuelve a cargar para la siguiente (la voz, solo en las condiciones de arriba). Tras una sesión que cargó la voz con red lenta, con ahorro de datos o en pantalla pequeña (salvo que hayas elegido Descargar ahora), y tras una en la que elegiste Seguir sin voz, lo suelta todo y vuelve a cargar la cara, sin voz.
  • El informe de arranque. El SDK guarda en el navegador un informe de cada arranque (etapas, tiempos, comprobaciones del dispositivo). DevLab no incluye en él el user agent y no lo envía a ningún sitio (sin startup.report.url). Si fijas una url, tu receptor guarda datos del navegador: tu consentimiento y tu aviso deben cubrirlo (Tu backend); DevLab no monta ningún receptor.
  • Diferido (en servidor): el dispositivo no descarga ningún modelo, así que esos servidores no ven nada de él. Solo una descarga que ocurre expone la dirección IP y el user agent.
  • Diferido, lo que lleva la grabación: audio y vídeo crudos, que identifican más a una persona que los números, y el manifiesto que viaja con ella lleva el userAgent completo del navegador (client.userAgent). El servicio de procesado guarda el texto completo que transcribe (también lo dicho fuera de los steps) solo hasta que acaba el trabajo, como mucho 2 h; a Engine solo llega el texto de los steps pedidos.

Ni el SDK ni Engine comprueban el consentimiento: recogerlo y registrarlo es trabajo tuyo. Recógelo antes de captureProtocol, con un gesto de la persona (un botón que pulsa), y guarda el registro. Tiene que cubrir:

  • Los dos modos. La geometría facial es un dato biométrico y, en la práctica, de categoría especial. En el dispositivo se envían los 478 puntos de una cara aunque no se envíe ninguna fotografía; en diferido, lo que sale es el vídeo, que contiene la cara. La finalidad de la captura, cuánto tiempo conservas los resultados, y que borrar a la persona es físico e irreversible.
  • En el dispositivo (tiempo real). No se graba vídeo ni audio. Landmarks y datos de expresión van a Engine. Con interpretación, los indicadores van a un LLM. Con transcripción, el transcrito literal va a Engine y a ese LLM, y los modelos de voz (unos 136 MB) se descargan de una CDN de terceros. El micrófono solo se pide con la transcripción encendida, y un objeto transcribe en el kit de tu contexto la enciende. El kit de DevLab de todo protocolo de contexto lleva uno por defecto (el de Measurement no). Si tu kit lleva un objeto transcribe, solo transcribe: false en tu código lo mantiene apagado; sin ninguno, no hay micrófono. Dilo en el consentimiento siempre que tu kit lleve uno.
  • Diferido (en servidor). Se graban vídeo y audio, se guardan en el navegador hasta subirlos, se suben a tu backend, los procesa nuestro servicio de procesado (con la transcripción activada, transcribe todo el audio de la grabación, y a Engine solo llega el texto de los steps que pide el trabajo (transcribeSteps)). Con interpretación, los indicadores y el transcrito, si lo hay, van a un LLM. El servicio de procesado borra sus ficheros de trabajo; la copia de tu receptor se queda hasta que la borres tú (receiver.remove()). Con la cámara, el micrófono va siempre.
  • Qué datos: geometría facial (478 landmarks, 52 coeficientes de expresión, pose de la cabeza); con transcripción, el transcrito; con señales extra, esos valores; en diferido, vídeo y audio.
  • De quién: de las personas que capturas, identificadas por los ids opacos que elijas.
  • Para qué: la finalidad que declares en tu consentimiento; la interpretación la escribe un modelo de lenguaje y no decide el resultado.
  • Adónde van: a Engine, en tu organización. En diferido, también a tu receptor y al servicio de procesado. Los servidores de terceros solo entregan software y ven la dirección IP.
  • Cuánto tiempo: capa a capa, en la tabla de abajo.
  • Quién borra: tú, con DELETE /users/{externalId} y su cuerpo obligatorio { confirm: externalId } en Engine y receiver.remove() en tu receptor. Lo demás es automático o del SDK.

Capa a capa, del navegador a Engine:

Retención, capa a capa
QuéDóndeHasta cuándoQuién lo borra
La copia local de una grabaciónEl navegador (IndexedDB neuro-capture-recordings)El 200 de complete, o un 410El SDK (uploadRecording, tras el 200 o el 410; release() para descartarla sin subirla)
Una subida sin confirmarTu receptor72 h sin actividadreceiver.sweep()
Un vídeo confirmadoTu receptorHasta que tu backend lo borra: nunca caduca solo. Bórralo en interpreting o en succeeded, lo que llegue antes.receiver.remove(), que deja una lápida de 7 días sin contenido
La copia del servicio, el audio y el transcritoEl servicio de procesadoEl final de la repetición, cuando el trabajo entra en interpreting, o el final del trabajo (los huérfanos se barren a las 2 h)El servicio de procesado
El registro del trabajo (con la URL firmada y el manifiesto)El servicio de procesado30 díasEl servicio de procesado
Resultados y framesEngineNo hay caducidad automática hoy.Tú, al borrar a la persona (DELETE /users/{externalId}, físico)

Dos matices sobre el receptor. Solo borra las subidas sin confirmar que guarda (pasado abandonedAfterMs, 72 h por defecto) cuando tu código llama a receiver.sweep(): no arranca temporizadores. Y un vídeo confirmado nunca caduca solo, así que su retención es tuya y debe constar en tu registro.

La URL firmada de un vídeo (receiver.signedUrl) es una credencial al portador: quien la tenga descarga el vídeo. Vale 24 horas por defecto y nunca más de 7 días. No la registres; un proxy inverso guarda la query en sus logs.

Borrar a una persona (DELETE /users/{externalId} con el cuerpo obligatorio { confirm: externalId }) elimina, físicamente, lo que Engine guarda de ella. Si alcanza también a lo que guardó el almacén de análisis no está medido: pregunta a Neurologyca (ver En Engine). En diferido con nuestro servicio, el vídeo, con su voz, se trata en servidores de Neurologyca, y tu backend le entrega al servicio un token de Engine para enviar los resultados: hoy un token de desarrollador, sin acotar a esa captura, hasta que Engine en producción ofrezca un token de una sola captura. Neurologyca trata esos datos como encargado tuyo según el Anexo de tratamiento de datos (DPA) que tu organización acepta con los Términos de DevLab; usa el modo diferido, una función Preview, solo con personas que hayan dado su consentimiento informado.

El SDK no pone cookies. Lo que escribe en el dispositivo:

  • Al grabar (diferido): la grabación, en la base IndexedDB de las grabaciones (su nombre, abajo), hasta que tu receptor la confirma. Lo que nadie libera caduca a las 72 h del primer trozo, pero solo se borra la siguiente vez que esa página usa grabaciones; si no vuelve, sigue ahí hasta que se borren los datos del sitio. En un dispositivo compartido, la lista de pendientes contiene las de todos: filtra por la persona actual antes de subir.
  • Con transcripción (en el dispositivo): el navegador guarda en caché los modelos de voz (unos 136 MB). No es un dato personal, pero delata que el sitio usó transcripción.
  • Con transcripción, de kodec: en localStorage, la clave kodec.stt.v4 guarda hechos del aparato para la voz: si una configuración mató la pestaña, el peor parón y la peor latencia medidos, la versión del navegador. Sin texto ni identificadores. No caduca nunca. En sessionStorage, kodec.stt.tab guarda un id aleatorio de esa pestaña y muere con ella. Las claves antiguas (kodec.stt.v3, kodec.stt.intentando.v2) las borra el propio kodec.
  • Nada capturado en disco en el modo en el dispositivo: el transcrito se queda en memoria y el SDK lo libera al parar la captura. Eso es el dispositivo: Engine guarda el texto que el SDK le manda y lo sirve en /results (ver En Engine).

Los nombres, tal como los muestra el navegador en sus herramientas de desarrollo:

IndexedDB neuro-capture-recordings (diferido: la grabación)
localStorage kodec.stt.v4 (voz: hechos del aparato)
sessionStorage kodec.stt.tab (voz: id de la pestaña)
Cache Storage modelos de voz (unos 136 MB)
Cookies ninguna

En un dispositivo compartido, lo que queda en localStorage y en la caché pasa de una persona a la siguiente. Borrar los datos del sitio en el navegador lo elimina todo. Con keepPrepared los modelos también se quedan en la memoria de la página de una captura a la siguiente, hasta client.release() o la salida de la página; lo guardado son modelos, no lo capturado, pero el modelo de la cara puede arrastrar estado del último frame de una captura a la siguiente, así que en un dispositivo compartido llama a client.release() entre una persona y la siguiente, o deja la opción apagada.

De cada usuario final: el perfil que envías (external id, nombre, rol, audiencia, preferencias de narrativa, huso horario), cuándo se creó y cuándo tuvo actividad por última vez, qué key lo creó, si está bloqueado, cada frame recibido, la transcripción, los resultados, las interpretaciones y el baseline.

No hay caducidad automática hoy: Engine guarda los datos hasta que borras el usuario.

Quién lee el texto. /results devuelve, en speech, la pregunta que se mostró en cada step y lo que se dijo (solo en el Engine del entorno de pruebas; ver speech). Una key admin lo lee de todas las personas de su organización, una read_all de las personas que creó, y un token de captura solo lee su sesión. Se borra con la persona.

DELETE /users/{external_id} con { "confirm": "<external id>" } borra el usuario y todo lo anterior, en un solo paso: todo o nada, e irreversible. La respuesta cuenta lo que se borró; guárdala como registro.

Engine conserva un registro del propio borrado (el external id, la key que lo pidió y los recuentos), y sus logs de servidor mencionan el external id. Sobre lo que guarda el servicio de interpretación, pregunta a Neurologyca.

Una key read_all solo borra los usuarios que creó. Ver la referencia de la API (DeleteUser).

POST /users/block hace que toda ruta de actividad responda 403 para ese usuario (capturas, resultados, interpretación, microintervenciones) sin borrar nada. Puedes seguir listándolo, editándolo, borrándolo y desbloqueándolo con POST /users/unblock. Los dos llevan el usuario en la query (?externalId=…); sin filtro actúan sobre todos los usuarios al alcance de tu key. Dentro de DevLab, borrar y bloquear son solo del admin de la organización (ver Modelo de acceso).

La interpretación recibe los indicadores, la transcripción, tu consulta y las preferencias de narrativa del perfil del usuario, junto con tu organización y el id de la inscripción. No recibe el nombre ni el external id del usuario. La narrativa la escribe un modelo de lenguaje; no decide el resultado.

DevLab registra tu actividad como developer. En resumen (detalle en Qué registra DevLab):

  • Actividad (inicios de sesión, revelados de la key, acciones de gestión y los hitos de tu equipo): se conserva 12 meses. Después, los hitos se quedan pero ya no dicen quién los provocó.
  • Dirección IP: solo en el inicio de sesión, la activación, el cambio de contraseña y los revelados de la key.
  • Identificadores de usuarios finales a los que tu equipo llega a través de DevLab: se guardan 24 horas, solo para aplicar los límites por equipo.
  • Playground: si aceptas su consentimiento, DevLab registra su versión, el idioma y un hash del texto con tu actividad (12 meses; después lo vuelve a pedir). Cada ejecución crea una persona de prueba en la organización de tu equipo con un id aleatorio; DevLab la borra en Engine a las 24 horas, o cuando tú o el admin de tu organización pulsáis Borrar ahora, y después guarda la ejecución solo como recuento, sin ids. Para que puedas volver a una sesión de las últimas 24 horas, el servidor de DevLab guarda, por cada sesión, metadatos cerrados: cuándo se inscribió, la audiencia con la que se inscribió y la que aplicó Engine, la vía (SDK o API HTTP), si fue en vivo o en diferido y el estado de su trabajo en diferido, y cómo acabó (si llegó la interpretación, el número de steps, la duración y el estado del baseline). Solo valores de una lista cerrada y números, nunca texto ni el transcrito; se borran con la persona de prueba (a las 24 horas, con Borrar ahora o, si su borrado en Engine falla, cuando un reintento sale bien). Las llamadas que ves se quedan en tu pestaña; DevLab guarda sus metadatos (ruta, estado, tiempos) en memoria 30 minutos, nunca sus cuerpos. Para capturar con la cámara, tu navegador descarga el software de seguimiento facial de una CDN, como hace una integración con el SDK. Una exportación se genera en tu pestaña, con marcadores en lugar de ids y sin tokens ni frames.
  • Playground, grabaciones en diferido: donde el playground graba, el receptor propio de DevLab borra el vídeo al terminar el trabajo (con éxito o con fallo definitivo) y, como tope, a las 24 horas; una subida que nadie confirma se borra a las 72 horas.
  • Asistente: apagado salvo que tu DevLab lo encienda. Tus preguntas, los últimos turnos de la conversación, el idioma de la respuesta, la página desde la que preguntas y las páginas de la doc que lee para responder van a Google (API de Gemini, de pago, que no los usa para mejorar sus modelos). De una página de la doc va su texto; de una pantalla de DevLab, su nombre y, si «Dónde está cada cosa» la describe, esa descripción; puedes quitar la página antes de preguntar. Con cada pregunta, DevLab envía también tu rol (developer, admin de la organización o admin de Neurologyca), el estado de tu equipo (sin equipo, inactivo o activo) y si este DevLab ofrece invitaciones y procesado alojado: valores sin nombres ni identificadores, para que la respuesta se ajuste a tu situación. Las invitaciones y el procesado alojado son un ajuste de este DevLab, no un dato sobre ti. Antes de enviarlos, DevLab quita las API keys de Engine y de Google con su formato conocido, los tokens con forma de JWT, los emails y las direcciones internas de Engine; cualquier otro secreto que pegues se envía tal cual, así que no lo pegues. Google trata lo enviado según las condiciones de la API de Gemini; DevLab le pide que no guarde la conversación y no puede borrar lo que ya se envió. DevLab guarda que preguntaste, cuándo, desde qué página y en qué idioma, qué páginas de la doc citó la respuesta, si respondió desde la doc, qué destino propuso, si propuso uno, si se quitó algo, cómo acabó, el modelo y cuánto trabajo llevó (rondas, caracteres leídos, tiempos, tokens y un coste estimado) y tu valoración con su motivo (de una lista cerrada), nunca el texto, durante 12 meses. La conversación se queda en tu pestaña.
  • Novedades de DevLab por correo: cuando algo cambia en DevLab, un administrador de Neurologyca puede enviar un correo breve con la novedad (en inglés). Llega a las cuentas activas, a una lista adicional que mantiene un administrador y, de forma puntual, a las direcciones que teclea. Cada correo lleva un enlace de baja: abre una página donde confirmas con un botón, lo que detiene los correos, y sigues viendo las novedades dentro de DevLab. Los administradores de Neurologyca ven la lista de direcciones dadas de baja, con la fecha, y pueden quitar una de ella (por ejemplo, si esa persona pide volver a recibirlos). Por cada envío, DevLab guarda la dirección de cada destinatario (también las puntuales, que pueden no tener cuenta) y su estado (enviado, fallido u omitido); por cada correo, el token de baja como hash junto a la dirección a la que se envió; la lista de direcciones dadas de baja; y la lista adicional hasta que un administrador quita una dirección. Todo ello se conserva mientras exista la función, más que los 12 meses de la actividad: no hay purga automática. La actividad registra que hubo un envío y sus cifras, nunca las direcciones ni el texto del correo.
  • Credenciales del procesado en diferido: DevLab guarda cifradas la clave del procesador y el secreto de webhook de tu organización, y al servicio le envía el secreto (por TLS) y solo un hash de la clave. Cada revelado, cada generación de valores nuevos y cada descarga del zip con claves queda registrado con tu IP; activar o descartar también queda registrado. Nunca los valores.
  • Aceptación de los términos: una constancia de cada aceptación (correo, cuenta, equipo, organización, rol, calidad, versión, una huella de cada documento, idioma, instante, dirección IP y navegador), que se conserva durante la vida de la cuenta y 10 años después de cerrarla; la dirección IP y el navegador se vacían a los 12 meses. Ves las tuyas en Tu cuenta › Mis acuerdos.
  • Nunca cuerpos de peticiones, keys ni datos de tus usuarios finales.

La documentación no tiene analítica; la única cookie es tu sesión cuando inicias sesión.