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

POST /sealCreate a seal: owner-token hash, per-file metadata, access flags (ttl, otp, nda, single_use, max_opens, geo).
POST /upload/initiate · /upload/confirmPresigned single-shot upload of one file’s ciphertext; the server checks its length.
POST /upload/multipart/init · parts · complete · abortMultipart path for large files.
GET /upload/status/{seal}/{sha256}Verification status of an uploaded file.
PATCH /seal/{id}/blobAttach the encrypted owner blob (optimistic CAS via ETag).
POST /seal/{id}/shareMint a share link (encrypted share blob; optional file subset).
POST /seal/{id}/appendAdd files to an existing seal (owner token).
POST /seal/{id}/revokeRevoke 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 /intakeThe 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/checkoutPayment page for a seal above 1 GB (owner token).
GET /clientsThe 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.