# Qué se recoge

> Cada tipo de dato que Sypnia recibe de tu app y de sus usuarios, cuáles son datos personales, qué se guarda en el navegador, y qué no recoge Sypnia nunca.

Aplica a: el motor de Sypnia (código abierto, en tu propia infraestructura) y Sypnia Cloud (servicio pago). Estado: al lanzar.  
Fuente: https://docs.sypnia.com/es/privacy/what-is-collected/

Esta página es para quien tiene que saber, o explicarles a otros, qué toma Sypnia de una app. La recolección ocurre en los SDK, que son los mismos para el motor de código abierto y para Sypnia Cloud. La diferencia es dónde viven después los datos: en tu propia infraestructura, o en la nuestra. Mira [Ubicación y retención de los datos](https://docs.sypnia.com/es/cloud/data-location-and-retention).

Tres reglas le dan forma a todo lo que sigue:

1. **Lo que una persona escribe no se recoge nunca.** Ni en los eventos, ni en las grabaciones.
2. **El enmascarado ocurre en el navegador**, antes de enviar nada.
3. **Sypnia recoge cómo se comportó la app**, no el contenido que tu app intercambió con su servidor: ni cuerpos de peticiones, ni cuerpos de respuestas.

## Desde el navegador

### Sobre la visita

| Dato                                                               | Detalle                                                                                                                                                                                             | ¿Dato personal?                                               |
| ------------------------------------------------------------------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------- |
| Id de sesión                                                       | Un id aleatorio para la visita.                                                                                                                                                                     | No por sí solo.                                               |
| Id de dispositivo                                                  | Un id aleatorio que el SDK guarda en el navegador, para distinguir dispositivos entre visitas.                                                                                                      | Distingue un navegador, no a una persona con nombre.          |
| Navegador, sistema operativo, tamaño de la pantalla, zona horaria  | Se envían una vez cuando empieza una sesión. El navegador y el sistema operativo se leen del user agent del navegador.                                                                              | No por sí solos.                                              |
| Tamaño del área visible, clase de dispositivo, idioma de la página | Se envían con cada evento.                                                                                                                                                                          | No.                                                           |
| La página de la que venía la persona                               | Su dirección y su ruta, sin la consulta.                                                                                                                                                            | Rara vez.                                                     |
| Páginas visitadas                                                  | Solo la ruta: sin dominio, sin consulta, sin hash. La ruta se guarda tal como es, así que `/orders/8841` conserva su id. Las rutas sin ids, que se usan para agrupar, reemplazan los ids por `:id`. | Puede serlo, si tus rutas contienen nombres o ids personales. |
| Tiempo en cada página y hasta dónde se bajó                        |                                                                                                                                                                                                     | No.                                                           |

### Sobre la persona, solo si tu app lo envía

Sypnia no sabe quién es nadie, salvo que tu app lo diga con `identify()`.

| Dato                     | Detalle                                                                     | ¿Dato personal? |
| ------------------------ | --------------------------------------------------------------------------- | --------------- |
| Id de la persona         | El id que elige tu app. Usa tu id interno de usuario.                       | Sí.             |
| Nombre y correo          | Opcionales. Se guardan solo si tu app los envía.                            | Sí.             |
| Id y nombre de la cuenta | Opcionales. El equipo o la empresa a la que pertenece la persona en tu app. | Puede serlo.    |

Los nombres y los correos viajan en un solo evento, que se envía cuando tu app llama a `identify()`. Todos los demás eventos llevan los dos ids y nada más sobre la persona.

Si tu app nunca llama a `identify()`, todas las sesiones siguen anónimas y todo funciona igual. Mira [Identificar personas](https://docs.sypnia.com/es/sdks/identifying-people).

Puedes eliminar a una persona en cualquier momento. Sale de todas las listas de inmediato, y todo lo guardado sobre ella, incluidos los archivos de eventos crudos, desaparece dentro de 24 horas. Mira [Eliminar datos](https://docs.sypnia.com/es/privacy/deleting-data).

### Sobre lo que hizo

| Dato                           | Detalle                                                                                                                                                                                                        | ¿Dato personal?                                                                                                                                                                                      |
| ------------------------------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Clics                          | El elemento, su etiqueta (el nombre accesible del control o su texto visible, hasta 80 caracteres), qué tipo de control es, en qué parte de la página está y la posición del clic. Nunca el valor de un campo. | La etiqueta puede serlo, cuando el texto del control es un nombre. Los elementos dentro de un área enmascarada no tienen etiqueta, y ningún elemento la tiene cuando todo el texto está enmascarado. |
| Clics de rabia y clics muertos | Lo mismo que un clic.                                                                                                                                                                                          | Lo mismo.                                                                                                                                                                                            |
| Fallas de formulario           | La etiqueta del campo que el navegador rechazó, y el motivo. Nunca lo que se escribió.                                                                                                                         | No.                                                                                                                                                                                                  |
| Eventos propios                | El nombre y las propiedades que envía tu código.                                                                                                                                                               | Lo que pongas en ellos. No pongas datos personales ahí.                                                                                                                                              |

### Sobre cómo se comportó la app

| Dato                      | Detalle                                                                                                                                                                                                                                                   | ¿Dato personal?                                                                            |
| ------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------ |
| Errores                   | El nombre, el mensaje (hasta 500 caracteres) y el stack (hasta 4.000). Los correos que haya en ellos se reemplazan por `[email]` antes de enviarlos.                                                                                                      | El mensaje puede serlo, si tu código pone otros datos personales en los mensajes de error. |
| Peticiones a tu API       | El método, la ruta, el estado, la duración y el id de la traza. En una llamada fallida, el código de error y los primeros 160 caracteres del mensaje de error que devolvió tu API, con los correos reemplazados por `[email]`. Puedes apagar ese detalle. | El mensaje de error puede serlo.                                                           |
| Mediciones de rendimiento | Los valores, y un selector del elemento que hay detrás. El selector nunca contiene texto.                                                                                                                                                                 | No.                                                                                        |

### Grabaciones y capturas de página

Una grabación guarda la estructura de la página y cada cambio que tuvo, el movimiento del ratón, los clics y los desplazamientos.

| En la página                                                                    | En la grabación                                                                                                             |
| ------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------- |
| El texto que muestra la página                                                  | **Se graba tal como se ve**, salvo que lo enmascares. Eso incluye nombres, montos y cualquier otra cosa que muestre tu app. |
| Lo que una persona escribe                                                      | Nunca. Cada carácter se reemplaza por un asterisco.                                                                         |
| El contenido de los campos de contraseña, de tarjeta y de código de un solo uso | Nunca, y esto no se puede cambiar.                                                                                          |
| Marcos, videos, canvas                                                          | No se graban.                                                                                                               |
| Imágenes                                                                        | No se copian: solo su dirección.                                                                                            |

Una captura de página, que se usa para dibujar los mapas de clics, es una copia de la estructura de una página con las mismas reglas.

Como el texto de la página se graba tal como se ve, las grabaciones son datos personales siempre que tus páginas muestren datos personales. [Enmascarado](https://docs.sypnia.com/es/privacy/masking) explica cómo ocultar áreas, o todo el texto.

## Desde tu servidor

| Dato                 | Detalle                                                                                                                                                                                                                                                                                                                                                  | ¿Dato personal?                                                     |
| -------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------- |
| Spans                | Por cada petición, llamada a la base de datos y llamada a otro servicio: el nombre, el tipo, los tiempos, el estado y un conjunto limitado de atributos, como la ruta, el código de estado o el nombre de una tabla.                                                                                                                                     | Rara vez.                                                           |
| Errores del servidor | El nombre, el mensaje y el stack, incluido lo que tu código escribe en `console.error` mientras atiende una petición. El mensaje de una llamada fallida a la base de datos o a un servicio se depura antes de salir de tu servidor: los correos, las URL, los UUID, los valores entre comillas, los tokens largos y toda serie de dígitos se reemplazan. | El mensaje de una excepción o de una línea de registro puede serlo. |
| Persona y cuenta     | Solo los ids. Una petición que viene de una sesión del navegador ya identificada recibe su persona de la sesión. El código de tu servidor los define solo para las peticiones sin sesión del navegador, como las llamadas de una app móvil.                                                                                                              | Sí.                                                                 |

Los SDK de servidor no recogen cuerpos de peticiones ni de respuestas, ni cookies, ni encabezados, ni variables de entorno. Los atributos cuyo nombre contiene `authorization`, `cookie`, `password`, `secret` o `token` se descartan en la ingesta, incluidos los que llegan por OpenTelemetry. Con OpenTelemetry, tú decides qué atributos envía tu exportador; mira [OpenTelemetry](https://docs.sypnia.com/es/sdks/opentelemetry).

## Desde las comprobaciones de disponibilidad

Nada sobre personas. Una comprobación guarda si tu dirección respondió, su código de estado y cuánto tardó.

## Qué se guarda en el navegador de la persona

El SDK del navegador guarda tres cosas pequeñas en el almacenamiento local del navegador, solo para tu sitio: el id de dispositivo, la sesión actual, y si esta sesión se está grabando. Si una persona pide que no se le registre, guarda una cuarta: la nota que lo dice. El id, el nombre y el correo de la persona nunca se guardan en el navegador. No pone cookies, no carga nada de otras empresas, y no puede seguir a una persona de tu sitio a otro.

## Qué no recoge Sypnia nunca

- Lo que una persona escribe, en ningún campo. No hay eventos de teclas.
- Contraseñas, números de tarjeta, códigos de seguridad y códigos de un solo uso.
- Cuerpos de peticiones y de respuestas, cookies y encabezados.
- La consulta y el hash de las direcciones de las páginas.
- Tokens de inicio de sesión en los enlaces: los parámetros `access_token`, `refresh_token`, `token` y `code` se quitan de las direcciones dentro de las grabaciones.
- El contenido de marcos, videos y canvas.
- El portapapeles, la cámara, el micrófono, los archivos del dispositivo.
- La ubicación de una persona. Sypnia no busca dónde está una dirección IP.
- Ids de publicidad, ni nada de otros sitios.

**Direcciones IP.** Como cualquier servidor, la ingesta ve la dirección de la que viene una petición. Se usa para limitar el abuso y no se guarda con los eventos, las sesiones ni las personas. En Sypnia Cloud aparece en los registros de peticiones de nuestros servidores, que se guardan 30 días.

## Qué lee el agente

El análisis del agente lee eventos, stacks, trazas y conteos. Nunca lee grabaciones ni lo que se escribió, y los campos enmascarados no se le envían. Quiénes son las personas tampoco se le envía al modelo: ni ids, ni nombres, ni correos, solo conteos. En Sypnia Cloud corre en un modelo al que se llega por OpenRouter, con los ajustes que les prohíben a los proveedores conservar los datos o entrenar con ellos; en el motor, en el proveedor que configures. La lista exacta está en [Modelos y qué se envía](https://docs.sypnia.com/es/agent/models-and-what-is-sent).

## Sypnia Cloud: datos sobre ti, el cliente **\[Nube]**

Aparte de los datos de tu app, Sypnia Cloud guarda lo que necesita para operar tu cuenta: tu nombre y tu correo, tu organización y sus miembros, tu plan y tus facturas, y un registro de los cambios hechos en tu organización. Los datos de la tarjeta van al proveedor de pagos y Sypnia no los guarda.

## Qué te toca a ti

Sypnia te da las herramientas; algunas decisiones solo las puedes tomar tú.

- **Cuéntales a tus usuarios.** Tu aviso de privacidad debería decir que las visitas se registran para encontrar y arreglar problemas.
- **Pregunta primero donde debas.** Si tus usuarios tienen que aceptar antes de que se les registre, inicia el SDK solo después de que acepten. Mira [Privacidad y enmascarado](https://docs.sypnia.com/es/sdks/privacy-and-masking).
- **Enmascara lo sensible.** Datos de salud, documentos, cualquier cosa que no querrías que un colega leyera por encima del hombro. Para una app que es sensible de principio a fin, enmascara todo el texto.
- **Deja los datos personales fuera de los mensajes de error, de los eventos propios y de las rutas.**
- **Identifica con un id**, y envía nombres y correos solo si quieres verlos en Sypnia.

## Motor y Cloud

|                                      | Motor de Sypnia (código abierto, en tu propia infraestructura)                    | Sypnia Cloud (servicio pago, con un plan gratis)           |
| ------------------------------------ | --------------------------------------------------------------------------------- | ---------------------------------------------------------- |
| Qué se recoge                        | Todo lo de esta página.                                                           | Lo mismo, más los datos de la cuenta de arriba.            |
| A dónde va                           | A tu propio bucket y tu propia base de datos. Sypnia, la empresa, no recibe nada. | A Sypnia Cloud, en Amazon Web Services, en Estados Unidos. |
| Quién decide cuánto tiempo se guarda | Tú.                                                                               | Tu plan, y puedes eliminar antes.                          |

## Ejemplo: un checkout, lo que guarda Sypnia

Del cliente que no pudo pagar, Sypnia guarda: un id de sesión y un id de dispositivo aleatorios; que usó un navegador de escritorio en español; que abrió `/checkout`, hizo clic cinco veces en el botón con la etiqueta «Pay $64.00» y salió a los 42 segundos; que `POST /api/checkout` respondió 400 en 412 ms; los spans de esa petición; y una grabación de la página del checkout en la que el resumen del pedido se puede leer y el campo de la tarjeta solo tiene asteriscos.

No guarda: el número de la tarjeta, la dirección del cliente salvo que la página la mostrara y no la enmascararas, el cuerpo de la petición de pago, ni el nombre del cliente, salvo que la tienda lo haya identificado.
