End-to-end encryption for SDK Task and Library traffic

Duale AI uses application-layer end-to-end encryption for Python SDK Task and event traffic and for its client-facing Library API operations. The SDK encrypts the logical HTTP request before it crosses the network. The receiving Platform service decrypts it, checks the caller’s authority, and encrypts its response. HTTPS protects the connection as well. This page explains where that protection begins and ends so you can assess it for your integration.

Which exchanges use it

The encrypted Library API calls include creating an upload session and recording a completed document. The file parts themselves use separate, time-limited signed HTTPS upload URLs. Dashboard Library API calls use HTTPS with a JWT and DPoP proof. The /v1/raw/** Task and agent lifecycle routes use that policy for Dashboard access. These RAW routes do not use this end-to-end encryption. Internal service and media calls, telemetry, and downstream model, provider, Web, and Tool traffic are also outside this HPKE boundary. Data protection maps those paths and the separate protection for stored data.

How a protected exchange works

The SDK uses /v1/hpke/** routes on each service. The Dashboard uses /v1/raw/** for Library API calls. The Task and agent lifecycle APIs provide the same RAW prefix for Dashboard access. The API Gateway keeps its existing /http-bridge and /libraries service prefixes in front of those routes.

The client gets the service’s public encryption key over HTTPS. It combines that key with a pre-shared secret to protect an HTTP request, including its method, logical URL, headers, and body. The outer network request carries an encrypted envelope to that service’s native HPKE endpoint. The service authenticates and decrypts the envelope, checks its freshness, and then dispatches the request. It resolves the active API token used as the shared secret and checks the caller’s permission for the requested Tenant and resource. Authentication does not bypass those permission checks.

This exchange does not keep a cross-request replay record or reject a duplicate envelope within the accepted time window. A client must not treat encryption as business-operation idempotency: if a mutating call loses its response, check the operation’s result before sending a new call.

The service encrypts the logical response, including its status, headers, and body. A finite response is accepted only after its complete protected record is authenticated. A live Task event stream authenticates each complete event or heartbeat block before the client receives that block. This lets the client receive checked events as they arrive.

The Python SDK uses its complete API token as the pre-shared secret. Its public secret identifier is the SHA-512 digest of that same complete token. The Task transport and Library services use this identity for their authorization checks.

What remains visible

An observer can link Python SDK exchanges that use the same API-token-derived identifier across the Task and Library endpoints. Encryption does not hide the fact that a client contacts Duale AI, the amount or timing of traffic, or an outer failure. It does not make the Platform a zero-knowledge service: the receiving service decrypts business data to process it, and later authorized processing can send data to configured destinations.

The public key is obtained over HTTPS rather than pinned in the SDK. A party that controls that HTTPS key response can affect which key the SDK trusts; this design does not claim protection against an active edge that changes it.

For the supported client workflow, start with Install the SDK or Manage a Library. For Library storage, access, and deletion, read Security and data handling.