# Security practices

> How Sypnia protects the data it holds, in the product itself and in how Sypnia Cloud is run, who can read what, what we do not have yet, and how to report a security problem.

Applies to: the Sypnia engine (open source, self-hosted) and Sypnia Cloud (paid service). Status: at launch.  
Source: https://docs.sypnia.com/privacy/security-practices/

For agents: Sypnia's security practices, without compliance claims: protections built into the SDKs and the engine (write-only ingest keys, hashed API tokens with scopes, per-project isolation, masking in the browser, ingest limits, private bucket with signed links, signed webhooks, outbound call rules, what the agent sends), how Sypnia Cloud is run (encryption, staff access rules, backups, sub-processors, incident notice), what does not exist yet, and how to report a vulnerability to support@sypnia.com.

This page is for whoever reviews Sypnia before saying yes, and for whoever needs to know who can read their data. It has three parts: what is built into the product and is therefore true for the open-source engine **\[Engine]** and for Sypnia Cloud **\[Cloud]** alike; how we run Sypnia Cloud; and what is yours when you run the engine yourself.

> **Note: Practices, not certificates**
>
> This page describes what Sypnia does. It does not claim that Sypnia is certified, audited or compliant with any law or standard, such as GDPR, SOC 2, ISO 27001 or HIPAA, and Sypnia holds no such certificate. Whether these practices meet your obligations is for you to decide.

## Built into the product **\[Engine]** **\[Cloud]**

These are properties of the SDKs and the engine. They hold wherever the engine runs.

### Less data to protect

The safest data is the data that was never sent.

- **What a person types never leaves the browser.** Masking happens in the SDK, before anything is sent. Password, card and one-time-code fields cannot be unmasked. See [Masking](https://docs.sypnia.com/privacy/masking).
- **No request or response bodies, no cookies, no headers.** No event has a field for them.
- **Secrets are dropped at the door.** Span attributes whose name contains `authorization`, `cookie`, `password`, `secret` or `token` are removed at ingest. Sign-in tokens are removed from addresses inside recordings.
- **IP addresses are not stored with events.** Ingest uses the caller's address for the rate limit, in memory. There is no geolocation.

The whole list is in [What is collected](https://docs.sypnia.com/privacy/what-is-collected).

### Credentials

| Credential               | What limits it                                                                                                                                                                                                                                                                  |
| ------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Ingest key, `spk_…`      | Public by design, so it is built to be harmless: it can only send. It reads nothing, changes nothing and reaches no other project. An API token used on an ingest endpoint is refused, so a secret cannot end up in a browser by mistake.                                       |
| API token, `sps_…`       | Shown once. Only its SHA-256 hash is stored, so Sypnia cannot show it again and a copy of the database does not contain tokens. It belongs to one project and carries scopes: `read`, `replay`, `admin`. It can have an end date. A revoked token is refused within one minute. |
| Root token **\[Engine]** | Lives only in the engine's configuration, never in a table. Sypnia Cloud has none.                                                                                                                                                                                              |

Secrets in the engine's configuration, such as the storage keys, the AI key and webhook secrets, are never printed, logged or returned by the API.

### One project cannot see another

Every stored object's key starts with its project's id, and every table has the project as the first part of its key. There is no shared table of events and no query that can be written without a project. An API token reaches the one project it belongs to. The design is in [How the engine is built](https://docs.sypnia.com/architecture).

### Ingest is built for hostile input

Anyone can send to a public address, so ingest trusts nothing:

- Every event is checked against the [event schema](https://docs.sypnia.com/reference/event-schema). What fails is dropped and counted; what is too long is cut.
- Sizes are capped before and after decompression, so a small body that expands to gigabytes is stopped at the limit.
- Each key has a rate limit per caller address, and each project can list the origins allowed to send from a browser.
- Quotas stop a project from storing more than you decided. Nothing is dropped silently: the answer says what was refused and why.

### Stored files stay private

The bucket is never public. When a browser must read a replay, or your CI must upload a source map, the engine hands out a link signed for that one object, which works for 15 minutes by default. Reading replay content needs a token with the `replay` scope.

### What the engine calls

- **Webhooks** are signed with HMAC-SHA256 and a timestamp, so your receiver can check where a delivery comes from and refuse an old one. By default they go only to HTTPS addresses on the public internet.
- **Uptime checks** refuse private and loopback addresses by default, so a check cannot be used to probe a network from the inside.
- **The agent** sends a problem's context to a model: the failure, the stack with source lines, the trace, the release, the counts. It never sends replay recordings or typed input, and masked fields are not in what it reads. On the engine it is off until you set a provider; `SYPNIA_AI_SEND_SOURCE=false` keeps source code out. See [Models and what is sent](https://docs.sypnia.com/agent/models-and-what-is-sent).

### Coding agents

The MCP server reads, with one exception: it can mark a problem resolved, which is recorded and can be undone, and can be switched off. Text that came from your app, such as an error message, reaches your coding agent in named fields, with the instruction that it is data and must never be followed. See [MCP security](https://docs.sypnia.com/mcp/security).

Pull requests **\[Cloud]** are opened on a branch Sypnia creates. Sypnia never merges, never pushes to your default branch and never force-pushes over someone else's commits. See [Pull requests](https://docs.sypnia.com/agent/pull-requests).

### Open code

The engine, the Console, the SDKs, the MCP package and the skills are open source. You can read what runs in your users' browsers and what the engine does with it, and so can anyone you ask to review it. The browser SDK sets no cookies and loads nothing from other companies. See [Licensing](https://docs.sypnia.com/licensing).

## How Sypnia Cloud is run **\[Cloud]**

Sypnia Cloud is the same engine, deployed by us on Amazon Web Services in `us-east-1`, with a private part around it: accounts, billing, the app and the GitHub App. Sypnia is run by a small team; this is what that team does.

### Encryption

- **In transit:** every address of Sypnia Cloud is HTTPS only, and connections between its parts are encrypted.
- **At rest:** the bucket and the database are encrypted with keys managed by AWS.
- **Passwords** are stored as salted hashes, never as text. You can also sign in with GitHub and use GitHub's own two-step sign-in.

### Who at Sypnia can read your data

- Access to production is limited to the people who operate the service. Each has their own sign-in, with two steps.
- Staff look at a customer's project for three reasons only: you asked for help and the answer needs it, we are investigating a failure or an incident, or we are investigating abuse of the service. We look at what that needs and no more.
- A replay shows what your users saw. Staff open one only when you point at that session, or when an incident cannot be understood without it.
- Your data is not sold, not used for advertising and not used to train models.

### Where it goes

The companies that touch your data, and what each receives, are listed in [Data location and retention](https://docs.sypnia.com/cloud/data-location-and-retention#who-else-touches-your-data): Amazon Web Services, OpenRouter and the model provider behind it, and GitHub and Stripe when you use them. Card numbers go to Stripe and never reach Sypnia.

### Backups and recovery

The database is backed up every day and each backup is kept 7 days. Stored files rely on the durability of Amazon S3, which keeps several copies of every object. Backups are restored only to recover from a failure of ours, never to bring back something you deleted.

### Our own secrets and code

- Keys and passwords of the service are kept in a secret store, not in the code repository.
- The dependencies of the engine and the SDKs are checked for known vulnerabilities, and fixes are released as new versions listed in the [changelog](https://docs.sypnia.com/reference/changelog).

### If something goes wrong

If we learn that someone read or changed data they should not have, we tell the owners of the affected organizations by e-mail as soon as we know what was affected: what happened, which data, what we did and what you should do. There is no public status page at launch.

## What we do not have yet

These docs only promise what is true. At launch Sypnia Cloud does not have:

- A certification or an independent audit report.
- Single sign-on. It is [planned](https://docs.sypnia.com/reference/planned).
- Two-step sign-in of its own. Sign in with GitHub to use GitHub's.
- A choice of region. Everything is in the United States. To keep data elsewhere, [self-host](https://docs.sypnia.com/self-hosting).
- Encryption keys that you manage.
- A paid bug bounty.
- A public status page, or a service level agreement.

## When you run the engine yourself **\[Engine]**

Everything in the first part of this page still holds. Everything in the second part becomes yours: where the data lives, who can read it, encryption, backups and upgrades. Sypnia, the company, has no access to a self-hosted engine and receives nothing from it: no telemetry, no licence check, no usage report.

The [security checklist](https://docs.sypnia.com/self-hosting/security-checklist) is the list to go through before real traffic.

## Report a security problem

If you find a way to read or change data that is not yours, or to make Sypnia do something these pages say it cannot, tell us before anyone else. This holds for Sypnia Cloud, for the engine and for the SDKs.

- Write to `support@sypnia.com` with «Security» in the subject. Do not open a public report in the repository.
- Say what you did, what happened, and how to repeat it. Do not include other people's data; a description is enough.
- Do not send secrets. If a token was exposed, revoke it first.

What we do: a person reads every report, tells you whether we could reproduce it, and tells you when it is fixed. Fixes in the engine and the SDKs are marked in the [changelog](https://docs.sypnia.com/reference/changelog). We ask you to give us time to fix a problem before you publish it. We do not promise a response time, and we pay no rewards at launch.

## Engine and Cloud

|                                        | Sypnia engine (open source, self-hosted)                            | Sypnia Cloud (paid service, with a free tier)                             |
| -------------------------------------- | ------------------------------------------------------------------- | ------------------------------------------------------------------------- |
| Protections in the SDKs and the engine | All of them.                                                        | The same.                                                                 |
| Who operates it                        | You.                                                                | Sypnia.                                                                   |
| Who can read the data                  | Whoever holds a token, and whoever administers your infrastructure. | The members of your organization, and Sypnia staff under the rules above. |
| Encryption at rest, backups, upgrades  | Yours to set up. See the security checklist.                        | Done by us.                                                               |
| The model the agent uses               | The provider you configure, or none.                                | A model reached through OpenRouter.                                       |

## Related
