# Identificar personas

> Cómo identify() une sesiones y problemas a una persona y a una cuenta, qué se guarda, cómo funcionan las sesiones anónimas y cómo identificar peticiones en el servidor.

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/sdks/identifying-people/

Esta página es para quien conecta Sypnia con el inicio de sesión de una app. `identify()` es la misma llamada en `@sypnia/browser`, `@sypnia/next` y `@sypnia/node`, y funciona igual para el motor de código abierto y para Sypnia Cloud.

**Al final tendrás:** problemas que dicen a quién afectaron («3 personas», y cuáles tres), sesiones que puedes encontrar por persona, y la actividad de cada persona y de cada cuenta.

> **En palabras simples**
>
> Sin `identify()`, Sypnia sabe que un navegador tuvo un problema. Con él, Sypnia sabe que Ada tuvo un problema, porque tu app dijo «este navegador es Ada». Sypnia nunca averigua por su cuenta quién es alguien.

## La llamada

`src/auth.ts`

```ts
import { identify } from '@sypnia/browser';

// cuando alguien inicia sesión, y cuando la app carga con alguien que ya había iniciado
identify({
  person: { id: 'u_1042', name: 'Ada Park', email: 'ada@example.com' },
  account: { id: 'acc_77', name: 'Corner Café' },
});

// cuando cierra sesión
identify(null);
```

| Campo          | Tipo     | Obligatorio                 | Límite                | Significado                                                                                                                    |
| -------------- | -------- | --------------------------- | --------------------- | ------------------------------------------------------------------------------------------------------------------------------ |
| `person.id`    | `string` | sí                          | de 1 a 128 caracteres | El id de la persona **en tu app**. Sypnia lo trata como un texto opaco: un número como texto, un UUID, cualquier cosa estable. |
| `person.name`  | `string` | no                          | 120 caracteres        | Se muestra junto a la persona. Dato personal.                                                                                  |
| `person.email` | `string` | no                          | 254 caracteres        | Se muestra junto a la persona, y se puede buscar. Dato personal.                                                               |
| `account.id`   | `string` | no (sí, si pasas `account`) | de 1 a 128 caracteres | El id de la cuenta a la que pertenece la persona en tu app: un equipo, una empresa, un club, una tienda.                       |
| `account.name` | `string` | no                          | 120 caracteres        | Se muestra junto a la cuenta.                                                                                                  |

Usa el id que usa tu base de datos, no el correo: un correo cambia, y pondría datos personales en cada evento. Un id que no es texto se convierte en texto. Un `person.id` vacío o ausente hace que la llamada no haga nada, con un aviso.

## Qué pasa después de la llamada

1. El SDK envía un evento `identify` con la persona y la cuenta como las diste. Es el único evento que lleva un nombre o un correo.
2. Cada evento posterior de la sesión lleva solo los dos ids: `"person": {"id": "u_1042"}`, `"account": {"id": "acc_77"}`.
3. La sesión, incluido lo que pasó en ella **antes** de la llamada, pertenece a esa persona. Alguien que navega y luego inicia sesión tiene una sola sesión.
4. El SDK recuerda los ids solo mientras vive la página. No los guarda en el navegador: llama a `identify()` de nuevo en cada carga de página donde haya alguien con sesión iniciada.

Llamarla otra vez con la misma persona no cuesta nada: no se envía nada salvo que hayan cambiado el nombre, el correo o la cuenta.

## Sesiones y personas

| Situación                                       | Qué hace Sypnia                                                                            |
| ----------------------------------------------- | ------------------------------------------------------------------------------------------ |
| Nadie identificado                              | La sesión es anónima. Se lista, se cuenta y se puede ver su grabación como cualquier otra. |
| Anónima, luego `identify(A)`                    | La misma sesión, ahora de A.                                                               |
| `identify(A)`, luego `identify(null)`           | La sesión de A termina. La siguiente actividad empieza una sesión nueva, anónima.          |
| `identify(A)`, luego `identify(B)`              | La sesión de A termina. La primera actividad de B empieza una sesión nueva.                |
| La misma persona en un celular y en un portátil | Dos sesiones, una persona.                                                                 |

Cuando Sypnia dice «3 personas», cuenta las personas identificadas, más una por cada dispositivo cuyas sesiones nunca se identificaron.

## En el servidor

Las peticiones que vienen de una sesión de navegador identificada no necesitan nada: el SDK del navegador envía el id de la sesión con cada llamada a tu API, y Sypnia toma la persona de la sesión.

Identifica en el servidor solo lo que ninguna sesión de navegador identifica: llamadas de una app móvil, de un cliente de la API, de un webhook.

`src/auth-middleware.ts`

```ts
import { identify } from '@sypnia/node';

app.use((req, res, next) => {
  if (req.user) identify({ person: { id: req.user.id }, account: { id: req.user.accountId } });
  next();
});
```

En el servidor `identify()` aplica a la petición que se está atendiendo y a nada más. Los nombres y correos que pases aquí se guardan igual que desde el navegador.

Los backends que reportan por [OpenTelemetry](https://docs.sypnia.com/es/sdks/opentelemetry) no pueden identificar personas al lanzar: sus trazas toman la persona de la sesión.

## Datos personales: lo que decides tú

`person.id` y `account.id` son lo único que Sypnia necesita. Solo con ids, Sypnia no tiene ningún nombre ni correo, y tú buscas a las personas en tu propio sistema.

Si envías nombres y correos:

- Se guardan con la persona, se muestran en la app y en la Consola, los devuelve la [API](https://docs.sypnia.com/es/api/sessions-and-replays), y se pueden buscar.
- Figuran como datos personales en [Qué se recoge](https://docs.sypnia.com/es/privacy/what-is-collected).
- El agente usa conteos de personas, no sus nombres. Mira [Modelos y qué se envía](https://docs.sypnia.com/es/agent/models-and-what-is-sent).
- Puedes borrar a una persona y todo lo que está unido a ella. Mira [Borrar datos](https://docs.sypnia.com/es/privacy/deleting-data).

Enviar un nombre o correo nuevo para el mismo `person.id` reemplaza el anterior.

## Grabar siempre a alguien

Para grabar todas las sesiones de una persona o de una cuenta, por ejemplo un cliente que reporta un error que no logras reproducir, agrega al proyecto una regla de «grabar siempre». Es un ajuste del proyecto, no código, así que aplica desde la siguiente sesión de esa persona, sin desplegar. Mira [Muestreo y cuotas](https://docs.sypnia.com/es/sdks/sampling-and-quotas).

## Quién puede enviar una identidad

Al lanzar, la llave de ingesta es la única credencial para enviar, como en cualquier SDK de navegador. Es pública, así que Sypnia no puede probar que un evento que dice «soy u_1042» viene del navegador de u_1042: alguien que lea el código de tu página podría enviar eventos con cualquier id. No podría leer nada, y los límites por llave y los orígenes permitidos acotan lo que puede enviar. No uses los datos de personas de Sypnia como prueba de quién hizo algo.

Una identidad firmada, para apps que necesitan esa prueba, está **\[Planeado]**.

## Comprueba que funciona

1. Pon `debug: true`, inicia sesión en tu app y mira la consola: un evento `identify`, y luego eventos con `person: { id: … }`.
2. En menos de 10 minutos la sesión en Sypnia muestra el nombre de la persona, o su id si no enviaste nombre.

## Sigue con
