/PRIVACYPrivacy Policy

Privacy Policy

This is an LLM API whose whole point is that the operator cannot read your prompts. So this page does two things: it lists the data we do process — mostly a meter and an invoice — and it explains why the content of your requests is not on the list, in terms you can check for yourself instead of taking our word for it.

Last updated
Version
privacy@2026-10-25
History
Every revision is a commit in this page’s repository.

/PP_01The short version

The short version

  • We never store your prompts or the model’s answers. Not in the database, not in logs, not in metrics, not in error reports. Inside the enclave they are not readable by us in the first place — and you can verify that before you send anything, which is the part a privacy policy normally cannot offer.
  • The console’s chat is the one exception: those conversations are stored, inside the enclave. Encrypted at rest, readable by you and not by us or your colleagues, deleted outright when you delete a thread — and they may be lost during infrastructure maintenance, because that storage is deliberately not durable. §5a is the whole of it.
  • What we do keep is a meter. Per request: the model, how many tokens went in and out, what it cost, how long it took, and which API key made it. That is the billing record and the Activity screen.
  • No cookie is set for analytics, on either surface, so there is no consent banner to click. This page uses a cookieless, aggregate tool; the console sends its events from our own servers, not from your browser.
  • There is nothing to pay for yet, and we never see your card. Paid top-ups are not enabled on the service today. When they are, payment happens on Stripe’s own page and we keep the amount and Stripe’s reference for it — never the card.
  • We do not sell or share data, and we run no advertising. There is nothing here for a Global Privacy Control signal to switch off, because there is no sale to object to.

/PP_02Who we are, and how to reach us

Who we are, and how to reach us

Confidential Router is a Super Protocol product. The controller for the processing described here is Super Protocol Corp., 65 Oceana Dr E, Apt 2F, Brooklyn, NY 11235, United States. That is the company that decides what is processed and why, and the one these rights are exercised against.

For anything about your data — access, export, correction, deletion, or an objection — write to privacy@superprotocol.com. A person reads it, and we answer within 30 days.

Security reports have their own address and their own policy: security@superprotocol.com.

The service is for developers and businesses, and accounts are for adults. We do not knowingly process the data of children; see the Terms of Service for eligibility.

/PP_03Three surfaces, and what runs where

Three surfaces, and what runs where

The product is three things on three hostnames, and they are deliberately not the same machine. It matters for this page, because what each one can see is different.

  • router.superprotocol.com — this page. Marketing content, served as static files from a commercial cloud host. No account, no session, no prompt ever touches it. It sets no cookie. Besides the cookieless analytics script in §6, the only thing on it that reaches a third party is the explainer video, and only if you press play — §6 says what that sends.
  • console.router.superprotocol.com — the console, where you sign in, create keys, see usage and buy credits. It runs inside the confidential cluster and holds the database described below.
  • api.router.superprotocol.com — the OpenAI-compatible endpoint your code calls. It runs inside the confidential cluster too, in enclave memory, and TLS terminates inside the enclave rather than at a proxy in front of it. That is the difference between “we promise not to look” and “the front door is inside the box”.

The split is not cosmetic. TLS terminates per hostname, so a single host could not serve marketing from a commercial cloud and prompts from inside an enclave — a proxy of ours in front of the API would read every request in plaintext and break the binding between the evidence and the certificate. Separating the hosts is what keeps the claim on this page true.

/PP_04What we process to run the service

What we process to run the service

The tables below are the ones the service actually writes. The schema is public — see the data model — so this list can be compared against it rather than believed.

Your account

Your email address, your name, and the avatar URL your sign-in provider gives us, plus the date the account was created. On the deployment that is running, a mailed code is the sign-in: every sign-in and every sign-up mails one to your address, so the address and the code are handed to our mail provider each time — Resend, in the sub-processor list below. Sign-in codes and email verification codes are single-use and expire within minutes.

There is no password. Password sign-in is switched off in the code on every deployment of this product, not per deployment: the routes that would set, check or reset one are not mounted at all, and the stored credentials earlier versions wrote were deleted when this deployment migrated. Signing in with GitHub, with Google, or by a one-time link is a different case — each one ships in the product and is not enabled on this deployment, and a deployment that switches one on is a deployment where we store the provider’s account id and the tokens that sign-in issued.

Signing in creates a session record: a session token, the IP address the sign-in came from, and your browser’s user-agent string. It is deleted when the session expires — 30 days, refreshed while you keep using it — or when you sign out. The session cookie is strictly necessary for signing in and carries no analytics. This page sets no cookie at all. One other cookie exists in the console’s code — the fifteen-minute invitation cookie described in §7 — but it is written only before a sign-in with GitHub or Google, and neither button is enabled on the deployment running today, so nothing sets it there. There is no third-party cookie and no analytics cookie on either surface.

Your API keys

A key is shown to you once, at creation, and then only ever stored as a SHA-256 hash plus its first twelve characters for display. We cannot recover a key, which is also why we cannot mail you a copy of one. Each key keeps its name, the models it is allowed to call, its spending limit, when it was last used and whether it was revoked. Revoking is a timestamp, not a deletion, so past usage stays attributable to the key that made it.

The meter, one row per request

Per request we record: the model and endpoint that served it, the number of prompt and completion tokens, the cost and the prices those were computed with, whether it was streamed, whether it succeeded, the error or finish reason, the latency, the time to the first token, the tokens per second, a request id, which key was used, a salted one-way hash of the client IP address, and the time. We also record which published attestation evidence was current when the request was served, so you can show afterwards what was running.

There is no column in that table that can hold message text — and a unit test walks the table’s definition and fails the build if anyone adds one. The salted hash of the IP exists so that abuse can be investigated; the address itself is never written down, and the hash is only comparable by someone who already holds the deployment’s secret.

Credits and workspace

Every account gets a personal workspace: a name, a balance, and — once you have paid for something — the customer reference Stripe gave us and your automatic top-up settings if you switched them on. The credits ledger is append-only: grants, purchases, per-request usage and refunds are rows, a correction is another row, and nothing is ever edited or deleted.

Your settings, and the evidence you archive

Console preferences: whether to archive attestation evidence and for how long (90 days by default), whether to be notified when a deployment’s measurement changes, and whether to receive email receipts. Archived evidence is a fact about our deployment, not about you.

/PP_05What we never hold: your prompts

What we never hold: your prompts

Prompt text, completions, attachments and the inputs you send for embeddings are never stored — not in the database, not in logs, not in metrics, not in error reports. The router forwards request bodies upstream and counts tokens; it does not buffer them, inspect them or write them anywhere. A log sanitiser drops the fields a body arrives in before any line is written.

The reason to believe that is not this paragraph. It is that the deployment runs in CPU and GPU enclaves, where memory is encrypted and the operator — us — is outside the boundary, and that the deployment publishes signed evidence of exactly which code and configuration are running. Our open-source Gatekeeper checks that evidence against the TLS certificate of the connection it is about to use, on your machine, before your first prompt leaves it. If the running code changed, the evidence changes with it and a Gatekeeper pinned to what you reviewed refuses to send anything.

What we can still see, honestly stated: the metadata in the meter above, and — while a request is being served — its content in enclave memory, because that is what inference is. What we cannot do is read that memory from outside, keep it, or change the code that handles it without the evidence saying so. The threat model sets out each of these claims with the mechanism that enforces it and the residual risk that remains.

/PP_05aThe chat in the console

The chat in the console

The console has a chat screen, so you can ask a confidential model something without installing anything. It is the one place in the product where a conversation has a history — so it is also the one exception to §5, and it needs its own paragraph rather than being covered by one.

Where the conversation is kept

On the deployment, in two tables of its own — chat_threads and chat_messages — and nowhere else. That storage is inside the same enclave that serves the model: it is encrypted at rest by a key generated in the TEE and never written down, so the machine’s operator sees ciphertext and we cannot read your conversations from outside. A conversation belongs to you and not to your workspace: another member of the same workspace cannot open it. Deleting a thread is immediate and complete — the thread row goes and its messages go with it — no archive, no copy to ask us for.

What we cannot promise: that it survives

Your conversations may be lost during infrastructure maintenance. The enclave’s state disk is ephemeral by design — that is what makes the encryption key unrecoverable from outside, and it is the same property that means the disk does not outlive the machine. We take no backup of your chat history and cannot restore one, and there is no retention period to quote you because nothing here is kept on a schedule. If a conversation matters to you, keep your own copy. We would rather say this plainly than let “stored inside the attested boundary” be read as a promise it is not.

What this does not change

§5 still holds everywhere else. The message itself travels to the model over the same /v1/chat/completions path an API client uses, with a short-lived key issued to your workspace, and it is metered and billed the same way — the metering record holds the model, the token counts, the cost and the latency, and no content. Chat content is never written to a log, never sent to an analytics tool, and never included in an attestation export; tests in the open repository assert each of those. The chat is not a privileged route with different rules: it is the ordinary API, called from a page, with a transcript you asked us to hold.

Why the screen says “verified by this page” and not “verified”

Before it will send anything, the chat fetches the endpoint’s signed attestation evidence and checks it in your browser — the signature, the certificate chain, how fresh it is, and whether the certificate the deployment publishes is the one the evidence signs. That check is real, and it is also self-reported: the page doing it was served by the deployment it is checking, and it cannot tell you whether Super Protocol vouches for the machine behind the endpoint. So the badge says so, and offers two stronger things — our browser extension, whose code the deployment did not serve, and Gatekeeper on your own machine, which sees the live TLS certificate and checks the enclave measurement against Super Protocol’s signed registry. Gatekeeper can refuse an endpoint this page accepted. The threat model is the long form of why those three are not the same claim.

/PP_06Analytics, and the one third party we embed

Analytics, and the one third party we embed

We measure how the launch is going with two tools, both chosen because neither needs a cookie. The full list of events either one may receive is published as a machine-readable taxonomy, and the reasoning is in a public decision record.

This page: Plausible

Plausible Analytics (Plausible Insights OÜ, Estonia; data stored in Germany) receives the page URL and referrer, your browser, operating system and device type as categories, an approximate location derived from your IP address — the address itself is never stored — and a daily-rotating hash that lets a returning visitor be counted once without an identifier that follows anyone. Query parameters are not forwarded: the campaign tag travels as a named property, and an invitation code is never part of anything Plausible receives. That is a statement about Plausible, not about the code: this page does check it with our own API, and the sign-up link carries it to the console. §7 is that whole path.

Plausible sets no cookie, stores nothing on your device, and reads nothing from it: no cross-site identifier, no fingerprinting, no session recording, no advertising. It does record, in aggregate, how long a page was open and how far down it was read — as a percentage, not as a recording of anything. Retention: aggregate counts for as long as the site runs; the daily hash lives for its day.

This page does keep one thing in your browser, and it is not analytics: the invitation code from your link. The console keeps a copy of its own, on its own host, and on one sign-in path a short-lived cookie as well. §7 says what each of them is for and when it goes away.

The console: PostHog, from our servers only

The console loads no third-party analytics script, so your browser never talks to PostHog at all. Our own server sends the events after the fact they describe has already happened: that an account signed up, redeemed an invitation, created a key, sent its first request, requested a model, opened the feedback form. They are keyed by the account’s internal id — not your email, not your name — and carry no IP address; autocapture, session recording, heatmaps and surveys are switched off at the project. Two events are posted by the browser to our own server first, which validates them against the published list before forwarding.

PostHog Inc. is a US company; this project is on its EU Cloud, stored in Frankfurt. Retention: 12 months.

The explainer video: embedded, and inert until you press it

This page carries an explainer video, and it is the only embedded third-party element anywhere on this site. What ships with the page is a picture and a link. Nothing is requested from Google, YouTube or i.ytimg.com while you read the page, scroll past the video or hover over it — no iframe, no script, not even a poster frame. It is inert until you press it.

Pressing play loads YouTube’s www.youtube-nocookie.com player into the page. From that moment Google receives your IP address and, as the referrer, the address of this site without its query string — so the invitation code your link carried is not handed to it. That host is YouTube’s own cookie-free playback mode rather than something we built: what we did is check it, and on 24 October 2026 a full playback set no cookie at all. What the player does keep on your device while it plays is its own playback bookkeeping, stored under YouTube’s domain and not readable from this page. What you watch from then on is between you and YouTube, under Google’s privacy policy — including anything it changes about that mode. §9 lists Google as a live sub-processor for this purpose, separately from the sign-in row that is switched off.

Opening the same link in a new tab — ⌘ or Ctrl-click — takes you to YouTube and loads nothing here. Either way it is your press that starts it, which is why the video ships this way rather than as an embed every visitor pays for whether they watch or not.

Legal basis, and why there is no banner

The processing runs on legitimate interest (GDPR Art. 6(1)(f)): understanding how a product we are launching is used, in aggregate, with no profiling, no advertising, no automated decisions about anyone, and nothing sold or shared. You can object at the address in §2 and we will exclude you.

The cookie-banner obligation in the EU comes from ePrivacy Art. 5(3), which is about storing or reading information on your device. Neither tool does either: Plausible stores nothing, and the console has no third-party script in it to store anything. We do store something, and it is not a tool: the invitation code, in the two places §7 names. Art. 5(3) exempts storage strictly necessary for a service you asked for, and carrying a code you were mailed through to the account it pays for is that — it is never read for anything else, which is the condition the exemption depends on. The determination holds only while the configuration above holds — a browser SDK with persistence, session recording, an advertising pixel or an embedded third-party widget would each put a banner back on the table, which is why changing any of them is a recorded decision rather than a commit.

The video above is the one embedded third-party element we have, so it is named here rather than left to that list. It loads nothing and stores nothing until you press it: while you are reading there is no access to your device to consent to, and the press is itself the explicit request that loads the player. That is the determination this page publishes, and it is why the video is a facade rather than an iframe.

The price we pay for that, stated plainly: a visitor to this page and an account that appears later are not linked. The funnel is joined on the campaign tag from the invitation, not on you.

/PP_07Invitations, grants and feedback

Invitations, grants and feedback

The invitation code

A launch invitation is a link containing a code. This page reads it, takes it straight out of the address bar so a screenshot or a shared link cannot carry it, and keeps a copy in your browser’s local storage under cr_invite_v1 so it survives a detour or a later visit without the link — you never have to type it. Stored with it: the campaign the code belongs to, and when the router last confirmed the code — the first time, that is when you opened the link. Nothing else, and no identifier for you. The code itself is never sent to an analytics tool; only the campaign it belongs to is. It is sent to our own API — api.router.superprotocol.com — once a visit, to ask whether it can still be redeemed, and that answer is what this page tells you about your invitation.

The console is a different host — console.router.superprotocol.com — so it cannot read anything this page stored, which is why the code also travels in the sign-up link. It keeps a copy of its own there, under cr_invite, as the bare code and nothing beside it, so that a reload of the sign-up screen or a trip to the sign-in screen and back does not lose it. Where a deployment offers sign-in with GitHub or Google, the console also sets a first-party cookie of the same name, expiring after fifteen minutes and scoped to the domain the console and the API share — router.superprotocol.com on this deployment: the provider sends your browser back to a URL it built, and a cookie is the only thing of ours that survives that one hop. Those buttons are not enabled on the deployment running today, so that cookie is not set on it. It is described anyway, because it is in the code — finding a cookie in devtools is the wrong way to learn that there is one.

Neither copy has a fixed expiry and nothing sweeps either on a timer; each is dropped when it has done its job, which is not the same moment on the two hosts. The console drops its copy as soon as it knows whether the invitation credited your account, granted or refused — so a sign-up you start and abandon leaves the code there until you come back and finish one. This page drops its copy the first time it asks and is told the code can no longer be used; until that answer comes back it keeps it, which is the same property that lets a code you have not spent still be waiting for you on a later visit. Clearing site data for either host removes it at once.

When the code is redeemed we record which code it was, the account that used it, the ledger row that credited it, and salted one-way hashes of the IP address and user-agent string of the redeeming request. The hashes exist for one reason: a hundred redemptions from one fingerprint is the pattern a launch needs to be able to see. Neither the address nor the user-agent string is stored.

Feedback for the second grant

If you are offered a second grant in exchange for feedback, the form is hosted by Typeform, and Typeform’s own privacy terms apply to what you type into it. It carries a short-lived signed token that identifies your account to us when the answers arrive; that token is never stored. We keep the answers and the submission id in our own database — a question worth asking should not lose its answers when we stop paying for a form tool — together with the grant it earned.

/PP_08Payments

Payments

No payment has been taken on this service yet. Paid top-ups are not enabled on the deployment that is running — every balance on it is a grant, as the Terms §7 says — so nothing described in this section has happened to anyone, and Stripe holds nothing of yours. It is described anyway, because the terms you accept should already say what happens when it is switched on rather than arriving with the first invoice.

When it is switched on, payments go through Stripe and you enter your card on Stripe’s own checkout page: card numbers never reach our servers, and we could not store one if we wanted to. What we would keep is the customer reference Stripe gives us, the identifier of each checkout or charge, the amount, and — if you switch on automatic top-up — the threshold and amount you chose, so the saved card can be charged when your balance runs low. Your email address is passed to Stripe so it can create a customer and send a receipt.

Stripe processes payment data as its own controller for fraud prevention and regulatory purposes. Its privacy policy covers that part; ours covers the reference we store against your workspace.

/PP_09Sub-processors

Sub-processors

These are the third parties that see anything at all. Each row is what they do and where they hold it; a row that says “only if” means the processing does not happen unless you take that step, and a row marked not in use yet is an integration that ships with the product and is switched off on the deployment that is running — nothing of yours reaches it today. We would rather list what is coming and say it is off than quietly add a row on the day a flag flips. Where one of these hands your data on to somebody else to do its job, that onward recipient is named inside the row rather than given one of its own — the row is who we chose and answer for, and the onward step comes with it.

Named sub-processors. A row marked “not in use yet” is shipped but switched off: nothing reaches it today.
WhoWhat they do for usWhere
Plausible Insights OÜLanding-page analyticsCookieless and aggregate. No identifier is stored on your device and none is sent to us.Germany
Microsoft AzureHosting for this static landing pageMarketing content only. This page has no account, no session and no prompt on it.East US, United States
Google LLC — YouTubeThe explainer video on the landing pageLoads only when you press play. Nothing is requested from Google while you read the page. On the press, the player is fetched from www.youtube-nocookie.com and Google receives your IP address and, as the referrer, the address of this site without its query string — so an invitation code is never handed to it. That host is YouTube’s own cookie-free playback mode; a full playback set no cookie when we checked it on 24 October 2026. What it does keep on your device while it plays is its own playback bookkeeping, under its own domain, which we cannot read.United States
PostHog Inc. — EU CloudProduct analytics for the consoleUS-incorporated, EU-hosted; events reach it from our servers, never from your browser.Frankfurt, Germany
Resend, Inc.Mails the one-time sign-in codes and the welcome emailEvery sign-in and every sign-up is a code mailed to you, so Resend is handed your email address and the whole message that goes to it: the sign-in code, and — in the welcome mail — your name and the credit your account started with. Neither message carries a prompt or an API key. Mail leaves the deployment through Resend’s SMTP relay as noreply@router.superprotocol.com; a reply goes to community@superprotocol.com. Resend does not carry the mail itself: it hands it to Amazon SES in Tokyo, Japan, so your address and your one-time code leave the United States on the way to you.United States; the message is relayed on through Amazon SES in Tokyo, Japan
Stripe, Inc. and Stripe Payments Europe, Ltd.Card payments and receiptsNot in use yetOnly when paid top-ups are enabled, which they are not today — see the Terms, §7. Nothing has been charged and no card has been entered. When they are, card details are entered on Stripe’s own checkout page and never reach our servers.United States, Ireland
Typeform S.L.The feedback form behind the second credit grantNot in use yetOnly when the feedback grant is offered, which it is not today — the form is not configured. When it is, only opening the form involves Typeform, and what you type there is also stored in our own database.Spain
GitHub, Inc. and Google LLCOptional sign-in with GitHub or GoogleNot in use yetOnly when those sign-in buttons are enabled, which they are not on the production deployment. When they are, and only if you choose one, they tell us your email, name and avatar URL; we tell them nothing about your usage. Google appears twice in this table on purpose: this row is sign-in and is switched off; the live Google row higher up is the explainer video, which is a different purpose.United States

We will change this list when the system changes, and the change will be visible in this page’s history.

/PP_10Where the data is, and transfers

Where the data is, and transfers

The console, the API and the database run inside the confidential cluster, which is hosted in the United States. This landing page is static files on a commercial cloud host — Microsoft Azure, East US — and holds nothing about you.

The cluster’s operational logs stay on the confidential nodes that write them, with one exception we describe below: nothing ships them off the node, no monitoring workspace collects them, and none of the sub-processors in §9 receives them. They record request metadata — including the time, the path, the status, the request identifier, the client IP address and the browser user-agent string, and, for an administrative action, the administrator’s email address.

The gateway in front of the cluster keeps two logs of its own. One records connections: client IP address, timestamp, bytes transferred and how long the connection lasted, and nothing about what was asked for. The other records requests: the method, the address asked for — including anything after the “?” in it — the status, the page you arrived from and your browser’s user-agent string. That second one does not record who asked: the address it sees is the gateway’s own, so a request line and a client IP sit in different files and only a timestamp relates them.

One case is worth naming rather than leaving to a closed list. When a model endpoint answers with an error, what reaches the log is a description of the failure and not the endpoint’s reply: the status it returned, its own name for the error and the request field it blames when it names one, and how many characters its response body ran to — never the text of that body. That body is where a failing endpoint can quote back part of the request that provoked it, which is why it is counted and described instead of written down. Nothing of your prompts or the model’s answers is written to an operational log.

The exception is a record of failures, and it is the one thing here that leaves the node. When a request to the cluster ends in a server error, the gateway keeps a short sample of it: the host, the method, the address asked for — this time without anything after the “?” — the status, which internal node answered and how long it took. The samples go to the cluster’s own store rather than to the node’s disk, and we read them back through our own authenticated interface, scoped to the deployment they came from. They are held for 48 hours, and only the newest 1,000 of them. They carry no client address, no account, no credential and nothing of what was asked for beyond the address itself. They exist so that an outage can be explained after it is over.

The logs themselves are kept for no fixed period: nothing deletes a line by age, and a node restart erases the log. The container logs are capped by size: the node keeps the most recent slice of each one and the oldest lines fall off as new ones arrive, so how long one of those lines lives depends on how busy the service has been rather than on a calendar. Neither of the gateway’s two logs is rotated at all, so a line in either lives until the node restarts whatever the traffic does. That restart is what ends them — the state disk a node keeps its logs on is re-encrypted under a fresh key it generates itself and never stores, so a reboot or a redeployment leaves nothing of them behind. The failure samples are the exception in both directions: they are not on that disk, and they expire on a clock of their own, 48 hours after the failure they describe. We would rather give you that than a number nothing in the system enforces.

So: all three surfaces are hosted in the United States, and Super Protocol Corp. is a US company. If you are in the EU, the EEA or the UK, your data is processed in the United States — we would rather say that than describe a European deployment we do not run. Some of it runs elsewhere, and we would rather name those than let “the United States” stand for everything: Plausible keeps this page’s statistics in Germany, PostHog’s project is on its EU Cloud in Frankfurt, and the sign-in mail leaves the United States — see the next paragraph.

The sign-in mail does not stay in the United States. Resend relays it, and Resend does not carry it itself: it hands the message to Amazon SES in Tokyo, Japan. So when you ask for a sign-in code, your email address and that code travel through Japan on the way to your inbox. Nothing else of yours goes with them — no prompt, no key, nothing about your usage — and we hold no copy of the message beyond what §11 says we keep.

Where personal data reaches a US sub-processor — Microsoft Azure for this page, Resend for the sign-in codes and Google for the explainer video if you press play, today; and Stripe or GitHub/Google sign-in if and when those rows stop being dormant — the transfer rests on the European Commission’s Standard Contractual Clauses in that provider’s data processing agreement, together with its own transfer framework certification where it holds one. The onward step to Amazon SES is covered by the same chain: it is Resend’s own sub-processor, under the data processing agreement we have with Resend.

/PP_11How long we keep things

How long we keep things

What we keep, for how long, and what for.
WhatHow longWhat for
Account record — email, name, avatar URLWhile the account existsIt is the account.
Sign-in credentials — the provider account id and the tokens from GitHub or Google, and never a passwordWhile the account exists — and nothing at all on this deployment, where neither button is enabledLetting you back in. There is no password to keep: password sign-in is off in the code on every deployment of this product, and the credentials earlier versions wrote were deleted when this deployment migrated.
Sign-in codes and email verification tokensMinutes — single use, and expired the moment they are usedThey are the sign-in. A code is mailed on every sign-in and every sign-up, through Resend.
Session records — session token, IP address and browser user-agent stringUntil the session expires (30 days, refreshed while in use) or you sign outKeeping you signed in, and letting you see where you are signed in.
API keys — a SHA-256 hash and the first 12 characters, never the keyWhile the key exists; a revoked key keeps its rowAuthenticating requests, and keeping past usage attributable after a revocation.
Per-request metering — model, tokens in and out, cost, latency, status, which key, and a salted hash of the client IPFor the life of the accountIt is the billing record and the Activity screen. It contains no prompt or completion text.
Credits ledger — grants, purchases, usage, refundsIndefinitely, including after an account is deleted, with the account identifiers removedAccounting. The ledger is append-only: a correction is a new row, never an edit.
Invitation redemption — the code, its campaign, and salted hashes of the IP and user-agentFor the life of the campaign recordOne grant per account, and reviewing a campaign for abuse.
The invitation code kept in your own browser — under cr_invite_v1 on the landing page, under cr_invite in the console, plus the console’s fifteen-minute sign-in cookie of that nameNo fixed period: the console’s copy goes once the grant is answered, the landing page’s once the code can no longer be redeemed; clearing site data removes either at onceSo an invitation you were mailed reaches the account it pays for without you typing it. Apart from the session cookie, it is the only thing either surface puts in your browser; §7 is the long form.
Feedback form answers and the submission idUntil we have no further use for them; deleted on requestThey are what the second grant buys, once it is offered. The signed token the form carried is never stored.
Console chat conversations — the questions you type there and the model’s answersInside the enclave until you delete the thread — and no longer than the deployment’s own state survivesThey are the transcript, and you asked us to keep it. This is the one place request content is stored; the metering record still holds none. The state disk is ephemeral by design, so maintenance can take a conversation with it — we take no backup and cannot restore one.
Attestation evidence archived for your accountThe raw bundle for as long as your Preferences say (90 days by default); the digests are keptSo you can show what a deployment published on the day it served you.
Plausible statistics for this pageAggregate counts, for as long as the site runs; the daily visitor hash lives one dayKnowing whether the campaign worked. Nothing in it identifies a visitor.
PostHog product events, keyed by an account id12 monthsWhether an account that took $100 of credits ever sent a token.
Operational logs — request metadata, including time, path, status, the request identifier, the client IP address and the browser user-agent string, the administrator’s email address on an administrative action, and, when a model endpoint fails, a description of that failure: its status, its own name for the error, the request field it blames and the length of its response body, never the body itselfKept for no fixed period: nothing deletes a line by age, and a node restart erases the log. A container’s log is capped by size, so its oldest lines fall off as new ones arriveRunning the service: an error, a rate limit, an abusive caller. They stay on the node that wrote them, reach no third party, and are never used to build a profile of anyone.
Gateway connection log — client IP address, timestamp, bytes transferred and how long the connection lastedKept for no fixed period: nothing deletes a line by age, and a node restart erases the log. This one is not rotated at all, so it grows until that restartSeeing that a connection reached the cluster. It records no request path, no account and no content.
Gateway request log — the method, the address asked for including anything after the “?”, the status, the page you arrived from and your browser’s user-agent stringKept for no fixed period: nothing deletes a line by age, and a node restart erases the log. This one is not rotated either, so it grows until that restartSeeing what the cluster was asked for when something goes wrong with it. It records no client address — the gateway sees its own — and no account, so a line here and a line in the connection log are related only by their timestamps.
Server-error samples — the host, the method, the address asked for without anything after the “?”, the status, which internal node answered and how long it took48 hours, and only the newest 1,000 of them. The one record here that is not kept on the node that wrote it, so it outlives the restart that ends the restExplaining an outage after it is over. No client address, no account, no credential and nothing of what was asked for beyond the address itself.

Two rows deserve their reason said out loud. The meter is kept for the life of the account because it is what your invoice is computed from, and it contains no content. The ledger is never deleted at all, even after an account is — with the account identifiers removed — because an accounting record that can be erased is not one.

/PP_12Your rights, and how to use them

Your rights, and how to use them

If the GDPR or a comparable law applies to you, you can ask for access to your data, a copy of it, correction of it, deletion of it, restriction of processing, or object to processing that rests on legitimate interest. One address does all of it: privacy@superprotocol.com. We answer within 30 days, and you can complain to your local data protection authority if our answer is unsatisfactory.

  • Access and export. Your account, keys, usage and ledger are all visible in the console today. Ask and we will send the same thing as a file.
  • Deletion. There is no self-service “delete my account” button yet — we would rather say so than imply a process that does not exist. Write to us and we delete the account, its personal workspace, its keys and its preferences, and remove the account identifiers from the metering rows and the ledger, which are kept for accounting. The same request deletes your events from PostHog.
  • Objecting to analytics. Tell us and we exclude you. Note what we cannot do: Plausible holds no identifier that could be used to look you up, so there is nothing there to delete or export — the honest answer to an access request against it is that it contains no data about any individual.
  • Prompts. There is no request to make. We do not have them.

/PP_13How this is protected

How this is protected

  • Inference runs in CPU and GPU enclaves with encrypted memory; TLS terminates inside the enclave, not at a proxy in front of it.
  • API keys are stored as SHA-256 hashes, and a sign-in code only as a digest. There is no password to store: password sign-in is off in the code on every deployment, and the credentials earlier versions wrote were deleted when this deployment migrated.
  • IP addresses and user-agent strings that we compare but must not keep are stored as salted one-way hashes, salted with a deployment secret.
  • Structured logs pass through a redactor that removes keys, tokens, cookies and secrets, and a sanitiser that removes request and response content.
  • The credits ledger is append-only, and every write is idempotent, so a retried payment cannot double-charge.
  • The deployment publishes signed attestation evidence, and anyone can check it without asking us.

No system is perfectly secure. If you find a hole, please tell us at security@superprotocol.com before you tell anyone else.

/PP_14Changes to this policy

Changes to this policy

When the system changes, this page changes with it. The date at the top is when the current version took effect, and every revision is a commit in this page’s repository, so a change is reviewable rather than announced. If a change materially affects how we process your data, we will tell account holders by email before it takes effect.