Use any model privately.

WISPR is an OpenAI compatible API in front of two things: a curated catalogue of uncensored open models running on sealed hardware, and the frontier models, reached through sharding so they never see the whole request. One key, one base URL, one receipt per request.

What happens to a request

Your request arrives encrypted inside a Phala enclave running on Intel TDX. There, identifiers become typed placeholders, the task is split into shards, and Context Aware Split Routing (CASR) picks a model per shard. Shards that carry anything sensitive run on catalogue models on WISPR hardware. A shard that needs frontier quality goes to Claude, GPT or Gemini with the placeholders in place. The enclave rebuilds one answer, restores the identifiers, and signs a receipt naming every model.

Why people use it

Where to go next

Quickstart

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

1. Get a key

Create an account in the dashboard, by email or anonymously with a recovery phrase, then make a key under API keys. Give it a monthly budget and a per request cap. The key is shown once.

2. Fund the balance

Top up with any coin, by card, or with a deposit note if the funding must not be linkable to the account. 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_KEY" \
  -d '{ "model": "auto",
        "messages": [{ "role": "user", "content": "Review this contract and tell me where my position is weak." }] }'

from openai import OpenAI

client = OpenAI(base_url="https://api.wispr.xyz/v1", api_key="wispr_sk_...")
r = client.chat.completions.create(
    model="auto",
    messages=[{"role": "user", "content": "Review this contract and tell me where my position is weak."}],
)
print(r.choices[0].message.content)
print(r.model_extra["wispr"]["cost_usd"])

import OpenAI from "openai";

const client = new OpenAI({ baseURL: "https://api.wispr.xyz/v1", apiKey: "wispr_sk_..." });
const r = await client.chat.completions.create({
  model: "auto",
  messages: [{ role: "user", content: "Review this contract and tell me where my position is weak." }],
});
console.log(r.choices[0].message.content, r.wispr.cost_usd);

auto lets CASR pick per shard. Any id from the catalogue pins the main shard to that model; sensitive shards still go to catalogue models on WISPR hardware.

4. Read the receipt

The response is a normal chat completion plus a wispr object.

"wispr": {
  "masked": 4,
  "shards": [
    { "id": 1, "class": "identity",  "model": "dolphin-mistral-24b", "host": "wispr-enclave" },
    { "id": 2, "class": "financial", "model": "qwen3-32b",           "host": "wispr-enclave" },
    { "id": 3, "class": "reasoning", "model": "claude",              "host": "provider, shard only" }
  ],
  "tokens": { "in": 812, "out": 1040 },
  "cost_usd": 0.0147, "fee_usd": 0,
  "attestation": { "enclave": "wispr-casr", "measurement": "sha256:4f1c…a9e0", "quote": "…" },
  "signature": "ed25519:…"
}

Accounts and keys

Two ways in. Email and password, or anonymous with a generated username and a twelve word recovery phrase. Both hold a balance and keys. Neither holds a prompt.

Email

An email and a password. Reset by link if you forget. We store a hash of the email and a hash of the password, nothing else about you.

Anonymous

No email, no phone, no name. The dashboard generates a username like willow-tide-03c00e8fcb73 and a twelve word BIP39 phrase in your browser. The account key is derived from the phrase on your device. We receive a public key and the username. The phrase never leaves your machine, so nobody can recover the account for you, including us.

Keys

A key looks like wispr_sk_… and works in any OpenAI client. Each key carries a monthly budget and a per request cap, enforced inside the gateway. An agent in a loop stops at its cap instead of draining the balance. Keys are stored hashed and shown once.

npx wispr keys create --name "cursor laptop" --budget 25 --cap 0.50
npx wispr keys list
npx wispr keys revoke wispr_sk_7f2k…

What an account stores

Who sees what

There is no privacy mode to switch on because there is no other mode. Every request runs the same way.

The claim, precisely

The only machine that holds your whole request is an enclave whose code measurement is published, whose memory the operator cannot read, and whose attestation is attached to every reply. This protects you against us and against anyone who takes over our servers. It does not protect against a flaw in the TDX hardware itself. A privacy claim that does not name its limits is not worth reading, so we name them.

The privacy policy is the complete list of records we hold.

The catalogue

Curated uncensored and abliterated open models, picked because they do the work, run on WISPR hardware inside Phala enclaves. Every card on the catalogue shows what the model is good at, how often it refuses, speed and price. Figures are indicative until benchmarked on our deployments.

Terms on the cards

Fine tune: the model was trained further on data with refusals filtered out. Abliterated: the refusal direction was removed from the weights without retraining. Uncensored: the model has no content filter of its own. Refuses is measured by our harness on a fixed prompt set and shown as a bar: nothing legal, rarely, sometimes.

Where they run

On GPUs we rent inside Phala confidential VMs. The host cannot read the memory. Weights are pinned at bf16 or the precision stated on the card, never silently quantised. GET /v1/models returns the live list with precision, price and status.

Content policy

The models do not filter. The Terms do: the acceptable use section bans the illegal categories clearly and leaves creative and adult work alone. Our policy, not a vendor's.

Frontier models

Claude, GPT, Gemini and Grok are available through the same key. They are never sent a whole request. They receive a shard with typed placeholders, from a WISPR exit, under a WISPR account.

Pin one by id (claude, gpt, gemini, grok-4-fast) or leave auto and let CASR hand them the shard that needs their quality. Identity, financial, medical and secret shards never go to a frontier provider regardless of the id you pin. The receipt shows exactly which shard they received.

WISPR editions step 2

Our own uncensored models, built the way Dolphin built theirs: refusals removed from the model, no filter in the weights, legality in the Terms. On current bases, in every modality, with the refusal rate and quality score published against the original.

Why

Most uncensored shelves are one or two models from 2024 plus proxies. The sharding stack comes first. Then the editions give the catalogue a current, measured, sealed set that is ours and cannot be deprecated under us.

Method

Abliterate and heal for most editions: remove the refusal direction, then a short fine tune on refusal filtered public data to repair any quality loss. Full parameter fine tune for the two flagships. LoRA for image and video. Every edition is benchmarked against its base on a fixed prompt set, and both numbers go on the card.

Line up

Bases and licences

Mistral Small and Nemo, Qwen3, Qwen2.5 Coder and VL, Qwen-Image-Edit, Chroma and Wan 2.2 are Apache 2.0; DeepSeek R1 distill is MIT. Gemma and Llama 3.3 carry their vendors' use policies; we ship those editions anyway, as Venice and the community do, and say so here rather than pretend otherwise. Flux Kontext was dropped because its weights are non-commercial.

Order of work

1. Eval harness. Refusal rate and quality against the base on a few thousand prompts, rerun on every candidate.
2. One overnight run per edition. Abliterate, heal, benchmark, pick the winner.
3. Two flagships. Full fine tunes on Mistral 24B and Qwen3 32B.
4. Image and video LoRAs. In parallel.
5. Serve. Quantised builds on Phala, cards updated with the measured numbers.

Roughly eight weeks and a low five figure compute budget after the sharding stack ships. Progress is on the roadmap.

How a request flows

One request, end to end. Everything below happens inside a Phala enclave whose measurement is in your receipt.

1. Your client encrypts the request to the enclave key. The gateway in between carries ciphertext and a key id.
2. Pseudonymise. Names, amounts, wallets, emails, addresses, dates and secrets become typed placeholders such as [PERSON_1] and [AMOUNT_2]. The mapping stays in enclave memory.
3. Split. The task is cut into shards by class: identity, financial, medical, secrets, code, reasoning. A shard is useful alone and meaningless with the others missing.
4. Route with CASR. Context Aware Split Routing allocates a model per shard. Sensitive classes go to catalogue models on WISPR hardware. Reasoning can go to a frontier model with placeholders only, if allowed.
5. Catch refusals. A shard that comes back refused is resharded to a model that answers. The receipt records it.
6. Rebuild. Shard answers are merged, validated against the original task, and the identifiers are restored.
7. Sign. The receipt names every model, shard class, token count, cost, exit and the enclave measurement, signed with the enclave key.

Cost of splitting

Two to four model calls for one request, so a split request costs more tokens than one direct call, and tasks that need the whole context at once can read slightly worse. Each call is listed in the receipt at the model's own rate. X-Wispr-Shard: mask keeps one call and only replaces identifiers when that is enough.

Verify the enclave

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

Measurements for every released enclave build are published with the source commit. The SDKs pin the current one and refuse a different one with 424 attestation_mismatch.

Receipts

Every reply carries a receipt signed inside the enclave. It is the proof behind every claim on this site, and it lives in your client, not on our side.

Verify one

npx wispr receipt verify receipt.json      # signature, measurement, published build
curl -X POST https://api.wispr.xyz/v1/receipts/verify -d @receipt.json

The dashboard keeps receipts in your browser under Receipts and can export them as JSON. Turn that off in Settings and nothing is kept anywhere.

Refusals

A model that declines a legitimate shard does not get to end the request. The enclave detects the refusal and reshards to a model that answers.

Detection looks at the shard reply, not at your prompt: a refusal pattern, an empty answer, or a provider policy error. The shard is rerouted once to a catalogue model and the receipt records resharded_from. If the second model also declines, you get 451 refused naming both models, never a silently weaker answer.

Catalogue cards show the measured refusal rate per model. Usage in the dashboard shows how many of your requests hit a refusal and were rerouted.

Controls

Defaults are set per account in the dashboard and can be overridden per request with headers. The request body stays OpenAI shaped.

-H "X-Wispr-Shard: auto"
-H "X-Wispr-Frontier: deny"             # everything stays on WISPR hardware
-H "X-Wispr-Sensitive: identity,financial,medical"
-H "X-Wispr-Exit: eu-fra"
-H "X-Wispr-Budget: 0.25"

Tools

Anything that speaks the OpenAI API works. Set the base URL to https://api.wispr.xyz/v1 and the key to a WISPR key.

Requests from tools run through the enclave like any other. The tool receives the rebuilt answer; the receipt is in the response object for tools that expose it and in the dashboard for the rest.

SDKs and CLI

You do not need an SDK. The official OpenAI clients work. The WISPR packages add attestation checks, receipt verification and the account commands.

pip install wispr

from wispr import Wispr
w = Wispr(api_key="wispr_sk_...")            # pins the enclave measurement
r = w.chat("auto", "Summarise this agreement and flag the risks.")
print(r.text, r.receipt.cost_usd, r.receipt.verify())

npm i @wispr/sdk

import { Wispr } from "@wispr/sdk";
const w = new Wispr({ apiKey: "wispr_sk_..." });
const r = await w.chat("auto", "Summarise this agreement and flag the risks.");
console.log(r.text, r.receipt.costUsd, await r.receipt.verify());

npx wispr login                        # email, or username + phrase (never sent)
npx wispr keys create --name laptop --budget 25 --cap 0.5
npx wispr ask "Explain the interactions between these three medications."
npx wispr attest                       # enclave measurement vs published build
npx wispr receipt verify receipt.json
npx wispr topup 25 --coin usdc

Go, Rust and an MCP server are on the roadmap.

Security audits

Reviewing your own code and contracts for vulnerabilities is an intended use and a common reason people arrive here. The code shard stays on WISPR hardware by default.

Point your audit tool at the base URL and pick qwen2.5-coder-32b or auto. With auto, CASR keeps the code and any secrets on catalogue models and may send a pseudonymised reasoning shard to a frontier model. Set X-Wispr-Frontier: deny if even that should stay inside.

export OPENAI_BASE_URL=https://api.wispr.xyz/v1
export OPENAI_API_KEY=wispr_sk_...
# then run your usual tool: Cursor, Cline, a LangChain agent, a one off script
npx wispr ask --model qwen2.5-coder-32b --file Treasury.sol "List every path by which funds could leave this contract."

Payments

Four ways money comes in: any coin, card, a deposit note, or per request over x402. Usage is always billed at provider price from the balance. The balance never expires.

Any coin

BTC, ETH, SOL, XMR, USDT and most other coins on any chain through the top up link, converted on arrival. Direct transfers: USDC on Base to the account's deposit address, shown in Billing. Credited after finality, usually under a minute. Fee 6%.

Card

Visa, Mastercard, Apple Pay, Google Pay. The processor sees a card and an account id, never a prompt. Fee 8%, because card rails and chargeback risk cost close to half of it.

x402 per request

Agents without a balance pay per call. Send the request with no key; the gateway answers 402 Payment Required with a price; the agent pays USDC on Base and retries with the payment header. Fee 6% on the quoted price, overestimates refunded to the paying address.

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

Deposit notes

For funding that must not be linkable to the account. See Deposit notes.

Deposit notes beta

A deposit note funds an account with no link between the paying wallet and the account. Credits only ever land inside WISPR; a note cannot be redeemed to an address.

Timing is the only correlation, so the CLI waits a random delay by default. Denominations are small, there are no account to account transfers, and the pool refuses deposits from sanctioned addresses. This is prepaid credit with a privacy layer, not a mixer. Contract, circuit and verifier are published.

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

Pricing and fees

Every model is billed at provider price with enclave time included. No per token markup, no subscription, no minimum spend, no expiry. WISPR charges one fee when money comes in.

What sharding costs

Two to four model calls for one request, each at its model's own rate, each listed in the receipt. Catalogue models are priced per million tokens with the enclave included; there is no separate enclave line. X-Wispr-Shard: mask keeps one call when hiding identifiers is enough.

Compared

Competitor figures from their public pricing pages, checked 1 November 2026.

Staking

Stake $500 of $WISPR, valued at stake time, for 90 days, bound to one account. While the stake runs, every top up into that account is fee free, up to $1,200 per stake period, and the account gets priority routing and exits.

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

Unstake after the term; the tokens stay yours throughout. GET /v1/stake returns the contract, your account id as bytes32 and the requirement. After staking on chain, POST /v1/stake re-reads the contract and switches the fee to 0%.

API reference

All OpenAI endpoints under /v1 with identical request and response shapes, plus the Anthropic shape under /anthropic. Listed here are the routes WISPR adds.

Requests

Account

Money

Headers

See Controls for X-Wispr-Shard, X-Wispr-Frontier, X-Wispr-Sensitive, X-Wispr-Exit, X-Wispr-Budget, X-Wispr-Precision and X-PAYMENT.

Errors

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

Roadmap

Two steps, in order. Sharding and the infrastructure under it first. Our own models second. Everything else is an addition.

Changes land on the blog and the status page.