Data and retention
Isolation
Section titled “Isolation”Every table that holds an environment’s data (users, identities, second factors, sessions, tokens, clients, APIs, roles, audit events) carries the environment’s id, and row-level security is forced on each of them: a query sees only the rows of the environment its transaction is for, and none at all when it names none. The database holds the service itself to that rule, not only its code.
The two environments of a group share nothing either: a user of development is not a user of production, and keys, sessions and settings are separate.
The audit log
Section titled “The audit log”Every login, failed attempt, sign-up, change to a user, and change of settings is recorded with when it happened, who did it, who it was done to, the address and user agent, and the event’s details. Rows can be added and read, and old ones removed by the retention below; the one change the database lets the service make is the one a deletion makes, which clears where an event came from (and, for an invitation, the address it went to) and nothing else. Changes made by people in the dashboard name the developer; those made with an API key name the key.
Read it in Audit log, or with GET /v1/environments/:id/audit. The events your servers can also be told of, as they happen, are the webhook events.
Retention
Section titled “Retention”| Free | Pro and Scale | |
|---|---|---|
| Audit log | 30 days | A year |
| Daily activity (the Analytics page) | 30 days | 190 days |
On Free, an hourly job deletes the older audit events and daily activity of each environment; nothing younger than 30 days can be deleted, whatever is asked. A workspace that moves to a paid plan keeps everything from then on. The answers of the audit log and analytics say how many days the plan keeps (retention_days, null for a year).
Short-lived rows (sessions, refresh tokens, codes, session tickets, login attempts) are removed by the database once they expire. Monthly active user counts are kept for billing.
Users and their data
Section titled “Users and their data”- The management API creates no users and changes nobody’s address or password: users make and change their own accounts.
- A user can delete their own account through the account API, from your app’s settings page (see Account settings).
- You can delete a user with the management API or on the Users page.
Deleting an account
Section titled “Deleting an account”A deletion is immediate: there is no period in which it can be undone, and nothing is put aside to restore it. It is the same whichever way the account goes: the user deletes it, it is deleted on Users or with the management API, or it goes with its environment when a group or a workspace is deleted. Your app’s backend that keeps something for each user hears of a deletion from the user.deleted webhook; Seek, which keeps something for each Seek and LinkPay account, also asks every hour which of the accounts it knows are gone, in case a delivery was lost.
What goes
Section titled “What goes”In the transaction that deletes the account, at once:
- the user, their identities, password, authenticator app, recovery codes and passkeys, their sessions, refresh tokens, codes and login attempts, their consents, their place in each app and their roles;
- in the audit log, the address, user agent, device, browser and operating system of every event the user did or that was done to them;
- in the webhook log, the
userobject (address, name, picture) of every delivery about them, sent or still to be sent; one still to be sent goes out withuser: null; - every email to their address in the environment’s queue, sent or not, except the one that confirms the deletion.
Your endpoints are sent user.deleted with user: null. What your app keeps about the user is yours to delete when it arrives. A user who deleted their own account gets one last email, which says so, what it means, and whom to write to with a question about their data: the address SeekAuth’s emails can be answered at, or, where there is none, your app.
What stays
Section titled “What stays”| What | For how long | Why |
|---|---|---|
| The audit events about the user, with the bare user id, the time, the app, the country, the login method and the event’s details, but no address or user agent | As long as the log is kept: a year from when each event happened (forgetting where it came from does not start the year again), or 30 days on Free | The security record of the environment |
The webhook deliveries about the user, without the user object: event, time, ids, how the delivery went |
30 days | Your endpoints’ delivery log |
| The row of the confirmation email: the address and that it was sent, without its content | 30 days | The mail queue keeps what it sent that long |
| The user’s id in the monthly and daily activity counts | 800 days and 190 days | Billing by monthly active users, and the Analytics page |
| Rate-limit counters | Until their window ends, a day at most | Limits against guessing and flooding |
The audit log is append-only except for the one exception a deletion needs, which the database holds the service to. It may reach only the rows the transaction names: those of the user being deleted, those of an environment that was deleted, those of a deleted developer’s changes, and, in the platform’s log, the invitation events sent to a deleted developer’s address. And a trigger refuses every change but two: the address, user agent, device, browser and operating system set to nothing, once; or the address taken out of an invitation event’s details. The event, its time, the app, who did it and to whom, the country and the login method never change, so no event can be made to look old enough for the retention to delete it.
When an environment is deleted with its group or its workspace, every event of its log loses where it came from too: not in the deleting transaction, which would have to hold the whole log, but right after, in batches of 500, from a queue the deletion fills in its transaction (an hourly job finishes what a stopped server did not). Each batch goes on from the last event the one before it looked at, which the queue keeps, so the log is read once however long it is. A deleted environment takes no new events, so the log is done once the queue is.
Developer accounts
Section titled “Developer accounts”A developer deletes their own account on the dashboard’s Account page (the account menu, then Account), with their address typed to confirm, and a new login when the last one is more than 10 minutes old. It cannot be done while they are the only owner of a workspace: the page lists those workspaces, and the account API answers 409 sole_owner. Another owner counts only while their own account exists. With the account they leave every workspace:
- their memberships go, and the API keys they made are deleted;
- the invitations they sent and that nobody answered yet are deleted, as are the invitations to their own address;
- the LinkPay subscriptions they pay for stop renewing first: those paid through a checkout they opened (the checkout names them, and the subscription carries that, whoever else opened one for the same plan), or for an older one the address LinkPay reports. If LinkPay does not answer nothing is deleted (
502 upstream_error, try again). One whose first payment is still being made cannot be changed yet: it is stopped by the reconciliation as soon as it can be, within ten minutes of LinkPay saying so. One LinkPay no longer has is nothing to stop. The workspace keeps its plan until the paid period ends, and their address is cleared from it for good; - in the platform’s audit log, where they came from goes from their own events, and their address from the invitation events sent to them;
- in the audit logs of the environments of the workspaces they belong to when the account is deleted, the changes they made there (which name them in their details) lose where they were made from, right after the deletion and in batches, as a deleted environment’s log does. The events stay, naming the developer by id, as the workspace’s security record.
Nothing records where a developer made changes but those events themselves, and the audit log is read one environment at a time. So the changes they made in a workspace they had already left before deleting their account keep the address and user agent they were made from, in that workspace’s audit log, until the event is a year old (30 days on Free), when it is deleted. To have those forgotten too, delete the account while still a member, or ask by email as below.
Accounts of Seek and LinkPay
Section titled “Accounts of Seek and LinkPay”Seek and LinkPay share one account, which lives in their own environment. When it is deleted, the workspace that was made for it (the one Seek sets its stores’ logins up in) is deleted too, right after and in the background, as any workspace deletion is. When that workspace has another owner it is not deleted: it only stops being that account’s. The developer account that was made from the person’s Seek account (the one Seek has made quietly when a seller turns on customer accounts, or a first “Continue with Seek” on the dashboard) goes with it, once it belongs to no workspace: deleted as any developer account is, with its address, its link to the Seek account and the emails queued to it. A developer account that still belongs to a workspace, or that the person had before they used Seek, stays, without its link to the deleted Seek account; they can delete it from the dashboard.
Workspaces
Section titled “Workspaces”An owner deletes a workspace on its Settings page, with its name typed to confirm and a login from the last 10 minutes. Every app group goes with it, with its apps, both environments and every user in them, as do its members, invitations and API keys, and its groups’ login addresses are never given to anyone again. Before anything is deleted, LinkPay is asked for the workspace’s subscriptions, a payment it has not told of yet among them, and every one that could renew stops renewing; if LinkPay does not answer, nothing is deleted. A subscription that a checkout still open at the time becomes later, or one whose first payment was still being made (which cannot be changed until it is), is stopped by the reconciliation as soon as LinkPay reports it, within ten minutes. See Delete a workspace.
People without an account
Section titled “People without an account”Someone whose data SeekAuth holds without an account they can sign in to (an address that was invited to a workspace, say) asks for it to be deleted by email, at the address SeekAuth’s emails can be answered at, and is answered by hand within a month. The users of your app ask you: you can delete them on Users.
What SeekAuth writes to your users
Section titled “What SeekAuth writes to your users”Only what they asked for, or what protects their account, in the name of the app they logged in to:
- Codes: a login or sign-up code, a code to confirm an address, a password reset code. Each expires in 10 minutes.
- Security notices: a login from a new device (one the account’s sessions have not used, or one the login did not name), a changed password or email address (to the old address), a second factor or passkey added or removed, a recovery code used, a login method linked or removed, an attempt to sign up with an address that already has an account, a session ended because a refresh token was reused.
Nothing else: no newsletters, no welcome emails to your users. They are your users to write to.