Overview
BlindCompute is an OpenAI-compatible gateway for inference that runs inside a hardware enclave (Intel TDX + NVIDIA H100 confidential computing). The operator can't see your prompt, your output, or the model weights, and every run is attested on-chain so you can prove the correct model ran — untampered.
Three things make it different from a normal inference API:
- Confidential — requests decrypt only inside the TEE.
- Verifiable — each response carries a receipt checkable against Automata DCAP on Base.
- Pay-per-call — settle in USDC over x402 — no API keys, gasless for the payer.
Base URL https://api.blindcompute.org/v1
Quickstart
Install the SDK and a wallet library, then make your first verified call. Your agent's account pays in testnet USDC.
npm install @blindcompute/sdk viemimport { BlindCompute } from '@blindcompute/sdk'
import { privateKeyToAccount } from 'viem/accounts'
// Your agent's wallet pays per call in USDC on Base — no API keys.
const bc = new BlindCompute({
baseURL: 'https://api.blindcompute.org/v1',
account: privateKeyToAccount(process.env.AGENT_PRIVATE_KEY as `0x${string}`),
})
const res = await bc.chat.completions.create({
model: 'llama-3.3-70b-instruct',
messages: [{ role: 'user', content: 'Explain TEE attestation in one line.' }],
})
console.log(res.choices[0].message.content)
// Prove it actually ran in an attested enclave:
console.log('verified:', await bc.verify(res)) // → trueAuth & payment
There are no API keys to provision or leak. Authorization is payment: an unpaid request gets an HTTP 402 with a price; your client signs a USDC authorization (EIP-3009 transferWithAuthorization) and retries. Settlement is on Base and gasless for the payer. The SDK does this round-trip automatically.
# An unpaid request returns 402 with the price + Base network context
curl -i https://api.blindcompute.org/v1/chat/completions \
-H 'content-type: application/json' \
-d '{ "model": "llama-3.3-70b-instruct",
"messages": [{ "role": "user", "content": "hi" }] }'
# HTTP/1.1 402 Payment Required
# → the SDK reads the price, signs USDC over x402, and replays the requestAlready using the OpenAI SDK? Keep it — point baseURL at BlindCompute and wrap fetch with the x402 payer.
import OpenAI from 'openai'
import { withPayment } from '@blindcompute/sdk'
const openai = new OpenAI({
baseURL: 'https://api.blindcompute.org/v1',
apiKey: 'x402', // payment is on-chain, not a key
fetch: withPayment(account), // attaches a USDC payment on 402
})Making requests
The request and response shapes mirror OpenAI's /chat/completions. Streaming is supported; the receipt is delivered with the final chunk.
const res = await bc.chat.completions.create({
model: 'llama-3.3-70b-instruct',
messages: [
{ role: 'system', content: 'You are a terse assistant.' },
{ role: 'user', content: 'What is operator-blind inference?' },
],
temperature: 0.2,
max_tokens: 256,
})
res.choices[0].message.content // the completion
res.receipt // attestation receipt (see §05)Verifying results
Verification is the whole point. bc.verify(res) confirms the enclave's signature over this output recovers to a signer whose TEE measurement is registered on-chain via Automata DCAP — proof a genuine, untampered enclave produced the result. It runs client-side; you never have to trust the gateway's word.
const report = await bc.verifyDetailed(res)
// {
// measurementRegistered: true, // node's TEE measurement is on-chain (Automata DCAP)
// signatureValid: true, // the enclave signed THIS output
// receiptAnchored: true, // an InferenceReceipts record exists on Base
// }
if (!report.signatureValid) throw new Error('unverified inference — do not trust')Receipts
Every completion carries a receipt binding the request, the node, its measurement, a commitment to the output, the USDC paid, and a timestamp. It's anchored on Base and independently checkable — portable, audit-grade proof a call happened as claimed.
{
"requestHash": "0x9f2c…",
"node": "0xA1b2…",
"measurement": "0x7d3e…",
"outputCommit": "0x44af…",
"paidUSDC": "0.0012",
"timestamp": 1718800000
}Models
The gateway routes across confidential backends (Phala, Atoma). Availability tracks what those providers serve in TEEs; query it at runtime rather than hard-coding.
const { data } = await bc.models.list()
// testnet, e.g.:
// llama-3.3-70b-instruct — general chat
// llama-3.1-8b-instruct — small + cheapErrors
Standard HTTP semantics. The one you'll meet first is 402 — and the SDK turns it into a payment, not an error.
API reference
Three endpoints. Everything routes through the OpenAI-compatible surface.
Live status /api/health
SDKs
TypeScript
Available · testnet
Python
Planned
Any OpenAI client
via x402 fetch wrapper
Read the theory, then ship.
The whitepaper covers the trust model and on-chain design behind these APIs.