Docs

Deleting data

How to delete one person, one session, a release's source maps, a project or a whole organization from Sypnia, what each deletion removes, how fast, and what stays.

Applies to EngineCloud At launch

View as Markdown
On this page
  1. What you can delete
  2. Delete one person
  3. Stop sending them first, if they must not come back
  4. Delete
  5. Check
  6. Delete one session
  7. Delete a release’s source maps
  8. Delete a project
  9. A single problem
  10. Delete an organization or your account
  11. How fast, exactly
  12. What deleting does not reach
  13. Engine and Cloud
  14. Example: the shop is asked to forget a customer
  15. Related

This page is for whoever must remove something from Sypnia: because a person asked to be forgotten, because a recording caught what it should not, or because a project is over. It applies to the open-source engine Engine and to Sypnia Cloud Cloud. The calls are the same; who may make them differs, and each section says so.

You do not have to delete anything for data to go away. Everything has an age limit, and Sypnia deletes it when it passes that age: see Data location and retention for Sypnia Cloud and Retention for a self-hosted engine. This page is about deleting sooner.

What you can delete

WhatHowWho mayDone
One person and everything tied to themDELETE /v1/people/{person_id}An API token with admin. On Sypnia Cloud, also an owner or an admin, in the app.Lists at once, files within 24 hours
One session, with its events, replay and page snapshotsDELETE /v1/sessions/{session}The sameThe same
A release’s source mapsDELETE /v1/releases/{version}/sourcemapsAn API token with adminAt once
A project and all of its dataEngine: sypnia project delete, with the root token. Sypnia Cloud: in the app, by an owner.See the sectionIngest stops at once, files within 24 hours
An organization, or your account CloudIn the appAn owner; you, for your own accountSee the section

In the examples, https://api.sypnia.com is Sypnia Cloud. On a self-hosted engine use your own base URL, with the same paths.

Delete one person

Use this to answer a request to be forgotten. A person is whoever your app named with identify(); their id is the one your app chose.

  1. Stop sending them first, if they must not come back

    New events with the same id create the person again. If the person also withdrew their agreement to be recorded, make sure your app no longer starts the SDK for them, or no longer calls identify() with their id. See Privacy and masking.

  2. Delete

    Terminal
    curl -X DELETE "https://api.sypnia.com/v1/people/u_0977" \
      -H "Authorization: Bearer $SYPNIA_ADMIN_TOKEN"
    You should see

    202 Accepted, with how many sessions will go and the latest moment by which every stored file is gone:

    JSON
    { "person_id": "u_0977", "sessions": 3, "status": "deleting", "done_by": "2026-03-13T10:40:00Z" }
  3. Check

    Terminal
    curl -i "https://api.sypnia.com/v1/people/u_0977" \
      -H "Authorization: Bearer $SYPNIA_ADMIN_TOKEN"
    You should see
    404, at once. Their sessions are no longer in any list or search.

What it removes:

  • The person’s record: their id, and the name and e-mail your app sent, if any.
  • Every session of theirs: the timeline, the replay, the page snapshots.
  • Their events inside the stored files. The raw event files and the daily Parquet files that held them are written again without them.
  • Their place in the list of people each problem hit. The problem keeps its count.
  • A problem’s stored example, when it came from one of their sessions. It is replaced by another occurrence, or left empty when there is none.

What it keeps, because it holds nothing about the person: totals. A problem still says it hit 3 people, a page still has its performance numbers, and the month’s usage counters do not change.

Someone your app never identified has no person record. Delete their visits one by one, as sessions.

Delete one session

Use this when a recording caught something it should not have, or for a visit by someone your app never identified.

Terminal
curl -X DELETE "https://api.sypnia.com/v1/sessions/c4e1a8f3d7b24c69a0e5d3b1f9c7a5e3" \
  -H "Authorization: Bearer $SYPNIA_ADMIN_TOKEN"
You should see
204, with no body. The session leaves lists at once; its files are removed within 24 hours.

It removes the session, its events, its replay and its page snapshots. Counts on problems and performance numbers stay as they are.

There is no call that deletes only the replay and keeps the timeline. If a screen shows what it should not, mask it first, so that new sessions are clean, then delete the sessions that were recorded before.

Delete a release’s source maps

Source maps contain your source code. Delete them when a release is retired and you do not want its code kept, without waiting the 90 days after the release was last seen.

Terminal
curl -X DELETE "https://api.sypnia.com/v1/releases/4f2a91c/sourcemaps" \
  -H "Authorization: Bearer $SYPNIA_ADMIN_TOKEN"
You should see
204. Stacks that were already translated stay readable. New failures in that release show the built file names.

Delete a project

It deletes the project, its keys and tokens, and all of its data: problems, sessions, replays, numbers, source maps. It cannot be undone.

Engine On a self-hosted engine, with the root token:

Terminal
sypnia project delete playground
You should see
The command asks you to type the slug again, then deletes. Ingest for the project’s keys stops at once: apps that still send are refused. Stored files are removed within 24 hours.

With Docker Compose, run it inside the container: docker compose exec sypnia sypnia project delete playground.

The same through the API is DELETE /v1/projects/{project_ref}?confirm=<slug>, with the root token. See the API reference.

Cloud On Sypnia Cloud a project is deleted in the app, in the project’s settings, by an owner of the organization. The API answers 403 cloud_managed.

A single problem

A problem is kept for as long as its project exists, so that Sypnia can say «came back» months later. It holds the sentence, the analysis, the status, the counts for each day and one example of the failure: no session, no replay.

  • To stop hearing about it: ignore it. An ignored problem never alerts and never reopens.
  • To remove what it holds about a person: delete that person, as above.
  • Cloud To delete the problem itself: an owner or an admin can delete it in the app. If the same failure happens again, it is a new problem.
  • Engine The engine’s API has no call to delete one problem at launch. Its record goes when the project is deleted.

Delete an organization or your account Cloud

An organization. An owner deletes it in the organization’s settings. This deletes every project in it and all their data, as above, ends the plan, and removes the members’ access. The members’ own accounts are not deleted.

Your account. You delete it in your account’s settings. You leave every organization and your sign-in details are deleted. You cannot delete your account while you are the last owner of an organization: give the ownership to someone else, or delete the organization first.

What Sypnia Cloud keeps after either:

KeptFor how longWhy
Invoices and payment recordsAs long as accounting rules requireWe must be able to show what was billed.
Database backups that still contain the dataAt most 7 daysBackups are not edited. They expire. They are not restored except to recover from a failure of ours.
Request logs of our servers, with IP addresses30 daysTo investigate abuse and failures.

How fast, exactly

MomentWhat is true
The call answersThe person, session or project is gone from every list, search, API answer and MCP tool.
Within 24 hoursEvery stored file is deleted or written again without the data. For a person, done_by in the answer is that moment.
Sypnia Cloud, within 7 more daysThe last database backup that contained it has expired.

On a self-hosted engine the worker does the second step. If it is not running, nothing is removed from the bucket until it runs again.

What deleting does not reach

Sypnia can delete what Sypnia holds. It cannot reach copies that already left:

  • Alerts already delivered. An e-mail in someone’s inbox, or the body your webhook receiver stored.
  • What the agent sent to the AI provider. It stays with that provider for as long as that provider keeps requests. Replays and typed input are never sent. See Models and what is sent.
  • What your coding agent read through MCP, and whatever it wrote into a conversation or a file.
  • Pull requests Cloud that Sypnia opened in your repository.
  • Your own copies: exports you made through the API, the daily Parquet files you copied elsewhere.
  • On a self-hosted engine: your database backups, and old versions of objects if you turned on versioning in the bucket. Both are yours to expire. See Storage layout.

Engine and Cloud

The Sypnia engine and Sypnia Cloud compared
Sypnia engineOpen source, self-hostedSypnia CloudPaid service, with a free tier
Who may deleteWhoever holds an API token with the admin scope. A project: whoever holds the root token.Owners and admins, in the app, and API tokens with admin. A project or the organization: owners only.
Who does the deletingYour worker, in your bucket and your database.We do.
BackupsYours. Deleted data stays in them until you expire them.Database backups expire after 7 days.
ProofLook in your own bucket and database.The API answers 404 at once. We do not issue a certificate of deletion.

Example: the shop is asked to forget a customer

A customer of the shop writes to ask that their data be removed. The shop identifies people by its own user id, so support finds the id in the shop’s admin: u_0977.

  1. The shop deletes the customer’s account in its own system, so the app no longer identifies them.
  2. Someone with an admin token runs DELETE /v1/people/u_0977. The answer says 3 sessions, done by tomorrow at 10:40.
  3. At once, searching Sypnia for u_0977 finds nothing. The problem that customer hit last month still says «3 people»; it no longer says who the third was.
  4. The shop answers the customer.

Sections

Start hereWhat Sypnia is, how it works, what is open source and what is the paid cloud, and the two ways to get your first problem in plain words.ConceptsThe ten ideas Sypnia is made of, each defined precisely, from a project and its keys to problems, traces and alerts.SDKsHow your app sends data to Sypnia. One SDK for the browser, one for Node, one for Next.js, and the OpenTelemetry intake for every other backend.The agentHow Sypnia analyses a problem, what it writes, what it sends to a model and what it never does.MCP and skillsConnect your coding agent to Sypnia so it can ask what is failing in production, read what it needs to fix it, and set Sypnia up for you.API referenceThe Sypnia HTTP API: one API for the open-source engine and for Sypnia Cloud, with every endpoint, parameter, response and error.CLI referenceThe sypnia command: how to install it, the variables it reads, what its exit codes mean, and where each command is documented.Self-hostingWhat you run when you host the Sypnia engine yourself, what you need, what it costs, and what you do not get compared with Sypnia Cloud.How the engine is builtThe whole Sypnia engine on one page, from a click in your app to the sentence your coding agent reads, with the design rules and the code that holds them.Sypnia CloudHow the paid service works, from organizations and roles to plans, limits, billing, where your data lives, the GitHub App and support.Privacy and securityWhat Sypnia collects from your app and its users, what it never collects, how masking works, how to delete data, and how the service is protected.LicensingWhich licence covers each part of Sypnia, what you may do with it, how the name may be used, and the terms of a contribution.GuidesStep-by-step recipes for the common ways to use Sypnia, from apps made with AI builders and Next.js on Vercel to Supabase, source maps in CI, alert e-mails from your own engine, and moving from Sentry.ReferenceThe pages you look things up in, from the event schema and the glossary to what is planned, the changelog and the common questions.
↑↓ to move↵ to openEsc to close