HTTP API
The send surface every client speaks, at https://api.seal.net. No account, no API key: capability comes from tokens you generate client-side.
The supported way to integrate is the SDK. It implements everything below, including the E2EE format, correctly. This page documents the surface for platforms we do not ship a client for.
Model
SEAL is zero-knowledge: you encrypt before upload (AES-256-GCM, AEON v4: every segment bound to its file’s header and its place), the backend stores ciphertext and checks only its length, the recipient checks the content against the header digest registered with the file, and the decryption key travels only in the URL fragment of the links you construct, or, for a link sealed to an address, wrapped to that address on the server. Ownership is capability-based: you generate an owner_token client-side and register only its SHA-256 hash.
Send flow
1. Generate owner_token client-side → owner_token_hash (SHA-256 hex).
2. Per file: generate a 256-bit key and a 24-byte AEON v4 header;
sha256_hex = SHA-256 of the header; encrypt name/mime metadata with the key.
3. POST /seal (owner_token_hash + files_meta + access flags)
4. PATCH /seal/{id}/blob — owner blob (owner_token, file_keys, message?)
encrypted under a fresh linkKey, before any byte
5. Per file:
POST /upload/initiate → presigned PUT (or multipart for large files)
PUT <presigned url> → upload the ciphertext to storage
POST /upload/confirm → backend checks the ciphertext length
6. POST /seal/{id}/share — share blob (file_keys, message?) encrypted
under a separate shareLinkKey
7. Links:
owner https://seal.net/s/{id}#{linkKey}
share https://seal.net/s/{id}/{shareCode}#{shareLinkKey}Public send endpoints
| Endpoint | Purpose |
|---|---|
| POST /seal | Create a seal: owner-token hash, per-file metadata, access flags (ttl, otp, nda, single_use, max_opens, geo). |
| POST /upload/initiate · /upload/confirm | Presigned single-shot upload of one file’s ciphertext; the server checks its length. |
| POST /upload/multipart/init · parts · complete · abort | Multipart path for large files. |
| GET /upload/status/{seal}/{sha256} | Verification status of an uploaded file. |
| PATCH /seal/{id}/blob | Attach the encrypted owner blob (optimistic CAS via ETag). |
| POST /seal/{id}/share | Mint a share link (encrypted share blob; optional file subset). |
| POST /seal/{id}/append | Add files to an existing seal (owner token). |
| POST /seal/{id}/revoke | Revoke the seal (owner token). |
| POST /intake · GET /intake/{id} | Ask a person for a file or a secret: the request carries your bundle and the answer is sealed to it. The read waits up to 25 seconds. |
| PUT /intake/bundles · GET /intake/bundles/{address} · POST /intake/proof · GET /intake · DELETE /intake | The bundle and the inbox of an address: put and read the bundle; under a signature of the server’s challenge with the address’s key, the links addressed to it and removing one; the one-time move of an inbox’s rows from its earlier address. The read waits up to 25 seconds. |
| POST /billing/checkout | Payment page for a seal above 1 GB (owner token). |
| GET /clients | The clients contract: each SEAL client’s minimum and latest version and the command that updates it. seal update reads it; it answers without a version check. |
These endpoints answer CORS for any origin (send is public by design, authenticated by the owner token header, never cookies). Reading a seal (metadata, share blob, download) answers only seal.net in a browser; servers and agents read it through the same API, as the SDK and the CLI do.
OpenAPI: https://api.seal.net/openapi.json
Errors & limits
Errors come as { detail, code, retry_after? }, with stable machine-readable codes (rate_limit.exceeded, validation.bad_request, geo.restricted, …). Send endpoints are rate-limited per IP. A seal holds 1 GB for free; a larger one is created with tier, and its upload answers 402 payment.required until the payment page is paid.