What is collected
Every kind of data Sypnia receives from your app and its users, which of it is personal data, where it is kept in the browser, and what Sypnia never collects.
On this page
- From the browser
- About the visit
- About the person, only if your app sends it
- About what they did
- About how the app behaved
- Replay recordings and page snapshots
- From your server
- From uptime checks
- What is kept in the person’s browser
- What Sypnia never collects
- What the agent reads
- Sypnia Cloud: data about you, the customer
- What is yours to do
- Engine and Cloud
- Example: one checkout, what Sypnia holds
This page is for whoever must know, or explain to others, what Sypnia takes from an app. Collection happens in the SDKs, which are the same for the open-source engine and Sypnia Cloud. The difference is where the data then lives: on your own infrastructure, or on ours. See Data location and retention.
Three rules shape everything below:
- What a person types is never collected. Not in events, not in replays.
- Masking happens in the browser, before anything is sent.
- Sypnia collects how the app behaved, not the content your app exchanged with its server: no request bodies, no response bodies.
From the browser
About the visit
| Data | Detail | Personal data? |
|---|---|---|
| Session id | A random id for the visit. | Not on its own. |
| Device id | A random id the SDK keeps in the browser, to tell devices apart across visits. | It singles out a browser, not a named person. |
| Browser, operating system, screen size, time zone | Sent once when a session starts. The browser and the operating system are read from the browser’s user agent. | Not on their own. |
| Viewport size, device class, the page’s language | Sent with each event. | No. |
| The page the person came from | Its address and path, without the query. | Rarely. |
| Pages visited | The path only: no domain, no query, no hash. The path is stored as it is, so /orders/8841 keeps its id. Routes, used for grouping, replace ids with :id. | It can be, if your paths contain names or personal ids. |
| Time on each page and scroll depth | No. |
About the person, only if your app sends it
Sypnia does not know who anyone is unless your app says so with identify().
| Data | Detail | Personal data? |
|---|---|---|
| Person id | The id your app chooses. Use your internal user id. | Yes. |
| Name and e-mail | Optional. Stored only if your app sends them. | Yes. |
| Account id and name | Optional. The team or company the person belongs to in your app. | It can be. |
Names and e-mails travel in one event, sent when your app calls identify(). Every other event carries the two ids and nothing else about the person.
If your app never calls identify(), every session stays anonymous and still works. See Identifying people.
You can delete one person at any time. They leave every list at once, and everything stored about them, the raw event files included, is gone within 24 hours. See Deleting data.
About what they did
| Data | Detail | Personal data? |
|---|---|---|
| Clicks | The element, its label (the control’s accessible name or visible text, up to 80 characters), what kind of control it is, where on the page it sits, and the position of the click. Never the value of a field. | The label can be, when the control’s text is a name. Elements inside a masked area have no label, and no element has one when all text is masked. |
| Rage clicks and dead clicks | The same as a click. | The same. |
| Form failures | The label of the field the browser refused, and the reason. Never what was typed. | No. |
| Custom events | The name and the properties your code sends. | Whatever you put in them. Do not put personal data there. |
About how the app behaved
| Data | Detail | Personal data? |
|---|---|---|
| Errors | Name, message (up to 500 characters) and stack (up to 4,000). E-mail addresses in them are replaced by [email] before they are sent. | The message can be, if your code puts other personal data in error messages. |
| Requests to your API | Method, route, status, duration, trace id. For a failed call, the error code and the first 160 characters of the error message your API returned, with e-mail addresses replaced by [email]. You can switch that detail off. | The error message can be. |
| Performance measurements | Values, and a selector for the element behind them. The selector never contains text. | No. |
Replay recordings and page snapshots
A recording holds the structure of the page and every change to it, the mouse’s movement, clicks and scrolls.
| On the page | In the recording |
|---|---|
| Text shown on the page | Recorded as shown, unless you mask it. This includes names, amounts and anything else your app displays. |
| What a person types | Never. Each character is replaced by an asterisk. |
| The content of password, card and one-time-code fields | Never, and this cannot be changed. |
| Frames, videos, canvas | Not recorded. |
| Images | Not copied: only their address. |
A page snapshot, used to draw click maps, is one copy of a page’s structure with the same rules.
Because page text is recorded as shown, replays are personal data whenever your pages show personal data. Masking explains how to hide areas, or all text.
From your server
| Data | Detail | Personal data? |
|---|---|---|
| Spans | For each request, database call and call to another service: name, kind, timing, status and a limited set of attributes, such as the route, the status code or the name of a table. | Rarely. |
| Server errors | Name, message and stack, including what your code writes to console.error while it handles a request. The message of a failed database or service call is redacted before it leaves your server: e-mail addresses, URLs, UUIDs, quoted values, long tokens and every run of digits are replaced. | The message of an exception or of a log line can be. |
| Person and account | The ids only. A request that comes from an identified browser session gets its person from the session. Your server code sets them only for requests with no browser session, such as calls from a mobile app. | Yes. |
The server SDKs do not collect request or response bodies, cookies, headers or environment variables. Attributes whose name contains authorization, cookie, password, secret or token are dropped at ingest, including those sent through OpenTelemetry. With OpenTelemetry, you decide which attributes your exporter sends; see OpenTelemetry.
From uptime checks
Nothing about people. A check stores whether your address answered, its status code and how long it took.
What is kept in the person’s browser
The browser SDK keeps three small things in the browser’s local storage, for your site only: the device id, the current session, and whether this session is being recorded. If a person opts out, it keeps a fourth: the note that says so. The person’s id, name and e-mail are never stored in the browser. It sets no cookies, loads nothing from other companies, and cannot follow a person from your site to another.
What Sypnia never collects
- What a person types, in any field. There are no keystroke events.
- Passwords, card numbers, security codes and one-time codes.
- Request and response bodies, cookies and headers.
- The query and the hash of page addresses.
- Sign-in tokens in links: the parameters
access_token,refresh_token,tokenandcodeare removed from addresses inside recordings. - The content of frames, videos and canvases.
- The clipboard, the camera, the microphone, files on the device.
- A person’s location. Sypnia does not look up where an IP address is.
- Advertising ids, or anything from other sites.
IP addresses. Like any server, ingest sees the address a request comes from. It is used to limit abuse and is not stored with events, sessions or people. On Sypnia Cloud it appears in our servers’ request logs, which are kept for 30 days.
What the agent reads
The agent’s analysis reads events, stacks, traces and counts. It never reads replay recordings or typed input, and masked fields are not sent to it. Who the people are is not sent to the model either: no ids, names or e-mails, only counts. On Sypnia Cloud it runs on a model reached through OpenRouter, with the settings that forbid providers from keeping the data or training on it; on the engine, on the provider you configure. The exact list is in Models and what is sent.
Sypnia Cloud: data about you, the customer Cloud
Apart from your app’s data, Sypnia Cloud keeps what it needs to run your account: your name and e-mail address, your organization and its members, your plan and invoices, and a record of changes made in your organization. Card details go to the payment provider and are not stored by Sypnia.
What is yours to do
Sypnia gives you the tools; some decisions only you can make.
- Tell your users. Your privacy notice should say that visits are recorded to find and fix problems.
- Ask first where you must. If your users must agree before they are recorded, start the SDK only after they agree. See Privacy and masking.
- Mask what is sensitive. Health data, documents, anything you would not want a colleague to read over a shoulder. For an app that is sensitive throughout, mask all text.
- Keep personal data out of error messages, custom events and paths.
- Identify with an id, and send names and e-mails only if you want to see them in Sypnia.
Engine and Cloud
| Sypnia engineOpen source, self-hosted | Sypnia CloudPaid service, with a free tier | |
|---|---|---|
| What is collected | Everything on this page. | The same, plus the account data above. |
| Where it goes | Your own bucket and database. Sypnia, the company, receives nothing. | Sypnia Cloud, on Amazon Web Services in the United States. |
| Who decides how long it is kept | You. | Your plan, and you can delete sooner. |
Example: one checkout, what Sypnia holds
For the customer who could not pay, Sypnia holds: a random session id and device id; that they used a desktop browser in Spanish; that they opened /checkout, clicked the button labelled «Pay $64.00» five times, and left after 42 seconds; that POST /api/checkout answered 400 in 412 ms; the spans of that request; and a recording of the checkout page in which the order summary is readable and the card field holds only asterisks.
It does not hold: the card number, the customer’s address unless the page displayed it and you did not mask it, the body of the payment request, or the customer’s name, unless the shop identified them.