Introduction

WISPR is an OpenAI compatible gateway with four extra things: a sharder, an exit network, a secrets vault and a compute market. If your code talks to OpenAI, it talks to WISPR after changing one line.

What is WISPR?

A request goes in through the same /v1 routes you already use. Instead of landing on one provider, it can be redacted, split into fragments inside an attested enclave, sent out through exits that are not the gateway, answered by several models and merged back. The provider sees a fragment from an exit IP. We see ciphertext and shard metadata. You see one normal response plus a receipt of what happened.

Why use it?

• No account. A session is a hash and a password. No email, no phone, no KYC, nothing to subpoena.
• Frontier models, fragment at a time. Use the strongest model on the market without its provider seeing your task.
• Provider price. No per token markup. One fee at top up, zero while you stake $WISPR.
• Verifiable. The enclave that does the split publishes a measurement you can check with wispr attest.
• Agents welcome. Per request payment over x402, secrets through Vault, compute from the same balance.

How it works

1. Your client encrypts the request to the enclave key. The gateway in between cannot read it.
2. The enclave redacts and splits. Identity, money and the analysis itself become separate shards.
3. Each shard leaves from a different exit. Sensitive shards go to private inference, the rest to a frontier model.
4. The enclave merges and validates. You get one response, the per call cost and the attestation quote.

Get started

Quickstart

Base URL https://api.wispr.xyz/v1. Every OpenAI endpoint is mirrored: chat completions, responses, embeddings, images, audio, video. Privacy is switched on with headers, so nothing about your request body changes.

1. Get a session

A session is a secret file plus a password you choose. The password is never stored and never sent.

# creates a session file and asks for a password
npx wispr session new
# or in the dashboard: Sessions, New, download the file

2. Fund it

Top up with any crypto (settled in USDC on Base), with a deposit note if you want the funding unlinkable, or by card. Agents can skip the balance and pay per request over x402.

3. Send a request

curl https://api.wispr.xyz/v1/chat/completions \
  -H "Authorization: Bearer $WISPR_SESSION" \
  -H "X-Wispr-Relay: on" \
  -H "X-Wispr-Shield: private-split" \
  -d '{ "model": "auto",
        "messages": [{ "role": "user", "content": "Review this contract and my position." }] }'

from openai import OpenAI
import wispr

client = OpenAI(base_url="https://api.wispr.xyz/v1", api_key=wispr.auth("wispr-session.txt", password))
r = client.chat.completions.create(
    model="auto",
    messages=[{"role": "user", "content": "Review this contract and my position."}],
    extra_headers={"X-Wispr-Relay": "on", "X-Wispr-Shield": "private-split"},
)
print(r.choices[0].message.content, r.wispr.cost_usd)

import OpenAI from "openai";
import { auth } from "@wispr/sdk";

const client = new OpenAI({ baseURL: "https://api.wispr.xyz/v1", apiKey: await auth("wispr-session.txt", password) });
const r = await client.chat.completions.create(
  { model: "auto", messages: [{ role: "user", content: "Review this contract and my position." }] },
  { headers: { "X-Wispr-Relay": "on", "X-Wispr-Shield": "private-split" } }
);
console.log(r.choices[0].message.content, r.wispr.cost_usd);

4. Read the receipt

The response is a normal chat completion plus a wispr object: which shards were made, which provider served each one, the exit it used, what it cost at provider price, and the attestation of the enclave that did the split and the merge.

"wispr": {
  "level": "protected",
  "shards": [
    { "id": "a", "class": "identity",  "provider": "private-inference",     "exit": "eu-fra", "cost_usd": 0.0021 },
    { "id": "b", "class": "financial", "provider": "venice/qwen3-235b"   , "exit": "eu-fra", "cost_usd": 0.0038 },
    { "id": "c", "class": "analysis",  "provider": "openai/gpt-5.2",        "exit": "us-iad", "cost_usd": 0.0088 }
  ],
  "provider_calls": 3, "cost_usd": 0.0147, "fee_usd": 0,
  "attestation": { "enclave": "shield", "measurement": "sha256:4f1c…a9e0", "quote": "…" }
}

Sessions live

A session is the only identity WISPR has for you. There is no account, email or wallet behind it. It is made of two halves: a secret saved in a file and a password you remember. Either half alone is useless.

How a session is built

The signature covers the timestamp, a nonce, the method, the path and the body hash, so a captured header cannot be replayed or reused for a different request. The 60 second window is enforced by the gateway. SDK helpers (wispr.auth(session, password)) do this for you. With raw curl, set WISPR_SESSION to the output of npx wispr session token, which is valid for a minute.

Rotate

POST /v1/sessions/rotate proves the old key and moves the balance to a fresh session_id. Your past requests and the new ones are no longer connected on our side.

npx wispr session rotate        # new id, same balance, old id dead
npx wispr session me            # balance, level, fee rate, spend by day

Compatibility keys

If you do not care about any of this, wispr_sk_... keys work like any API key. They are stored as a hash and shown once. They tie every request to one key, which is the weaker mode and says so in the dashboard.

Privacy levels

Set per request with X-Wispr-Level, or per agent at deploy time. Higher levels switch on more of the stack and cost more compute.

What each party can see

Shield live

Shield turns one request into fragments that are useful alone and meaningless together, routes each one, then rebuilds a single answer. Header: X-Wispr-Shield.

Modes

Control the split

-H "X-Wispr-Shield: private-split"
-H "X-Wispr-Shield-Sensitive: identity,financial"     # classes that must go private
-H "X-Wispr-Shield-Private: venice/llama-4-maverick"     # model for the private shard
-H "X-Wispr-Shield-Frontier: openai/gpt-5.2"           # model for the rest

Each shard carries a WISPR exit IP and a per shard session, never the parent session. The reconstructor validates the merge against the original task and will re run a shard that contradicts the others. Benchmarks against direct calls will be published per routing policy in the dashboard.

Where the split happens

The analyzer and the reconstructor run inside an Intel TDX enclave hosted on Phala. The gateway outside the enclave sees only ciphertext and shard metadata. Your client encrypts the request to the enclave's key, which is bound to a published code measurement, so a modified enclave would carry a different measurement and your SDK would refuse it.

wispr attest shield                    # checks the quote against the published build
curl https://api.wispr.xyz/v1/attest   # raw quote, verify with any TDX tool

Measurements for every released enclave build are published at wispr.xyz/measurements with the source commit. The SDK pins the current one and refuses a different one with 424 attestation_mismatch. A local mode, where the SDK runs the planner on your machine and the enclave is not needed, is planned for the Python and Node SDKs.

What it costs

Split and private-split make two to four provider calls for one request, so the token cost is higher than one direct call, and the reply can be worse on tasks that need the whole context at once. There is no markup on those calls; the response lists each one with its provider price.

Relay live

Relay sends the request from a WISPR owned exit instead of the gateway. Headers that identify a client are stripped and bodies are never written to disk on an exit.

Turn it on

-H "X-Wispr-Relay: on"          # nearest exit
-H "X-Wispr-Relay: eu-fra"      # pick a region

Stripped on the way out: user agent, forwarded for, cookies and any header that names a client. Exits rotate daily, or on demand with POST /v1/relay/rotate.

Regions

Vault live

A virtual .env for agents. Secrets are stored once, and agents receive short lived grants instead of the secret. Wallet signers never leave the Vault: the agent asks for a signature, the Vault checks the grant limits and signs.

Store, grant, revoke

wispr vault set DEPLOY_KEY ghp_...
wispr vault grant DEPLOY_KEY --to agent-01 --ttl 24h
wispr vault signer add WALLET_SIGNER --chain base --limit 500usdc/day
wispr vault grant WALLET_SIGNER --to agent-01 --ttl 24h --scope "swap,transfer<=100usdc"
wispr vault revoke DEPLOY_KEY --from agent-01

Inside the agent, process.env.DEPLOY_KEY resolves through the grant. After revoke the agent's next read fails. Nothing to rotate, because the agent never had the key.

What a compromised agent can do

Spend its allowance and nothing more. Grants carry a TTL, a scope and a limit, and signing happens inside the enclave. The agent gets a result, never the key.

Compute beta

CPU boxes for always on agents (WISPR Box) and GPUs by the hour from Akash, Vast.ai and WISPR racks. Billed per minute from the session balance at provider price, with a hard stop.

Boxes

wispr deploy --level protected --box small --stop-at 5.00
wispr agent run "Research new positions and report every morning. Keep holdings private."
wispr logs agent-01 --follow

A workspace box wakes when you open it and sleeps after ten minutes idle. Your files live on an encrypted volume that is written through from the box, so nothing stays on the machine after sleep. One box per session; a second device attaches to the same box.

GPUs

wispr gpu create --type h100 --hours 2 --image vllm
wispr gpu list
wispr gpu stop gpu-7f2

At Confidential level the box is a TDX confidential VM. wispr attest agent-01 returns the quote and the measured image hash so you can verify it against the published build.

Payments and networks

Three ways money gets into a session: crypto (any coin, any chain, settled in USDC on Base), card, or per request over x402. Usage is always billed at provider price from the balance.

Crypto: any coin in, USDC on Base inside

Inside WISPR every balance is USDC on Base, the one asset every provider we pay accepts without a bridge. Send USDC on Base straight to your session deposit address, or any other coin on any chain: relay.link converts it on the way in and shows the bridge fee before you send. Or or use a deposit note when the paying wallet must not be linkable to the session.

Card

Card top ups go through a processor and carry the highest fee. They are tied to a session, not an account, and the processor sees a card, not a prompt. If the funding link matters to you, use a deposit note instead.

x402 per request

Agents without a balance can pay per call. Send the request with no session; the gateway answers 402 Payment Required with a price; the agent pays in USDC on Base and retries with the payment header. No account, no top up.

HTTP/1.1 402 Payment Required
X-Payment-Required: {"scheme":"exact","network":"eip155:8453","asset":"USDC","amount":"0.0153","payTo":"0x..."}

The quoted amount is the estimated provider cost plus the x402 fee. Any overestimate is refunded to the paying address. x402 payments are visible on chain, so use a deposit note instead when the payer must not be linkable to the session.

Deposit notes beta

A deposit note funds a session without a link between the paying wallet and the session. The design borrows the deposit side of Tornado Cash and deliberately drops the withdraw side: credits only ever land inside WISPR, they cannot be sent to an address.

Flow

What WISPR learns: a 50 USDC note was redeemed into session S. Not which deposit, not which wallet. What the chain shows: a wallet deposited 50 USDC into the pool. Timing is the only correlation, so the CLI waits a random delay by default.

wispr deposit 50 --from 0xYourWallet          # writes the note to wispr-notes.txt
wispr redeem wispr-usdc-50-base-0x...            # into the current session, after a random delay

What it is not

Pricing and fees

Every model, box and GPU is billed at provider price. There is no multiplier and no per request markup. WISPR charges one fee when money comes in.

Fees at top up

wispr stake 500 --days 90 --from 0xYourWallet   # stakes $500 of $WISPR, bound to this session
wispr session me                                # shows balance, stake, fee rate, spend by day

What privacy costs

Privacy is paid for in provider calls, not in fees. redact is one call. split and private-split are two to four calls, one of which lands on private inference at that provider's price. Confidential level adds the enclave box at 0.011 USD/h. Every response carries the per call breakdown, so the premium is visible, never hidden in a rate.

x402

Per request payment adds 6% to the estimated provider cost of that request. Overestimates are refunded to the paying address. Details and the header format are in Payments and networks.

Compared

Competitor figures from their public pricing pages, checked 29 October 2026.

API reference

All OpenAI endpoints under /v1 with identical request and response shapes. Listed here are the routes and headers WISPR adds.

Sessions

Requests

Vault

Compute

Headers

Errors

Every error is typed. The body carries { error: { code, message } } and the codes below never change meaning.