Skip to main content
Private Inference is an OpenAI-compatible endpoint at api.t2000.ai. Point any OpenAI SDK at it and call frontier + open models through one key, in two privacy tiers:
  • Private (default, every model) — zero data retention: providers are contractually bound not to store or train on your prompts.
  • Confidential (phala/* models) — inference runs in a verified GPU-TEE (hardware enclave), and every response carries a signed receipt anchored on Sui that you can check yourself with t2 verify — the only Sui-native verifiable confidential inference.
Metered per token from a single credit balance. Manage everything — keys, credit, usage, the model catalog — at the developer console: agents.t2000.ai/manage. Sign in with Google (zkLogin); it’s the same Passport identity + credit balance as Audric, so one account spans the app and the API. Your edge over a raw provider: private by default, verifiably confidential when it matters, every model behind one key, and pay-as-you-go with no per-provider accounts.

​
Base URL

https://api.t2000.ai/v1

​
Get a key

  1. Sign in at agents.t2000.ai/manage with Google.
  2. Add credit — top up with a card, or pay with USDC / USDsui from your Passport (gasless, Billing → Pay with stablecoin), or use the included credit from an Audric Pro/Max plan.
  3. API keys → Create API key — the secret (sk-…) is shown once, so store it safely.
Agents skip the browser entirely: t2 agent onboard --fund 5 funds credit from the CLI wallet and mints a key in one command (t2 agent topup refills later) — see Authentication for how the two account types relate. Calls are metered per token from your credit balance. Fund-to-use: any account with a positive balance (a top-up, a plan’s included credit, or referral credit) can mint a key and call — no subscription required.
Calls fail closed at a $0 balance — add credit at agents.t2000.ai/manage. Keep keys server-side; rotate (revoke + recreate) if one leaks.

​
Quick start

curl https://api.t2000.ai/v1/chat/completions \
  -H "Authorization: Bearer $T2000_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "zai/glm-5.2",
    "messages": [{ "role": "user", "content": "Explain x402 in one sentence." }]
  }'

from openai import OpenAI

client = OpenAI(
    base_url="https://api.t2000.ai/v1",
    api_key="sk-...",  # from Settings → API keys
)

resp = client.chat.completions.create(
    model="zai/glm-5.2",
    messages=[{"role": "user", "content": "Explain x402 in one sentence."}],
)
print(resp.choices[0].message.content)

import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.t2000.ai/v1",
  apiKey: process.env.T2000_API_KEY, // from Settings → API keys
});

const resp = await client.chat.completions.create({
  model: "zai/glm-5.2",
  messages: [{ role: "user", content: "Explain x402 in one sentence." }],
});
console.log(resp.choices[0].message.content);

​
From the t2000 CLI, MCP, or SDK

Beyond any OpenAI SDK, the t2000 toolchain wraps the API as first-class verbs — same key via T2000_API_KEY: 
export T2000_API_KEY=sk-...
t2 chat "Explain x402 in one sentence." --model zai/glm-5.2   # streams
t2 models                                                      # list the catalog

import { T2000 } from "@t2000/sdk";

const agent = await T2000.create();
const { content } = await agent.chat({
  model: "zai/glm-5.2",
  messages: [{ role: "user", content: "Explain x402 in one sentence." }],
  apiKey: process.env.T2000_API_KEY,
});
// or stream: for await (const d of agent.chatStream({ … })) process.stdout.write(d);

// Any MCP client (Cursor, Claude Desktop) with T2000_API_KEY in the server env:
{ "name": "t2000_chat",   "arguments": { "prompt": "Explain x402 in one sentence." } }
{ "name": "t2000_models", "arguments": {} }
Get the key at agents.t2000.ai/manage and set it as T2000_API_KEY (CLI/SDK) or in the MCP server env.

​
Pay-per-call over x402 — no key, no account

Agents can pay per call in USDC with no API key — Private Inference is a first-party x402 service on the gateway. Call it with the existing t2 pay / t2000_pay (the gateway handles 402 → pay → retry): 
t2 pay https://x402.t2000.ai/t2000/v1/chat/completions \
  --data '{"model":"zai/glm-5.2","messages":[{"role":"user","content":"Explain x402 in one sentence."}]}' \
  --max-price 0.10
  • No key / no account — pay from your wallet’s USDC, gasless. The agent-native path (vs the key-based one above).
  • Models: the open + confidential set (zai/glm-5.2, deepseek/deepseek-v3.2, openai/gpt-oss-120b, and the phala/* confidential models) — browse the live list at GET /t2000/v1/models (free). Frontier + large contexts use a key (above).
  • Capped — flat per-call price with an output + context cap (what keeps no-key pricing predictable). For uncapped/per-token precision, use a key, or watch for the max-hold settlement tier (next).

​
Streaming

Set "stream": true for server-sent chat.completion.chunk events (OpenAI-compatible), terminated by data: [DONE]. Pass "stream_options": { "include_usage": true } to receive a final token-usage chunk. 
const stream = await client.chat.completions.create({
  model: "zai/glm-5.2",
  messages: [{ role: "user", content: "Write a haiku about Sui." }],
  stream: true,
});
for await (const chunk of stream) {
  process.stdout.write(chunk.choices[0]?.delta?.content ?? "");
}

​
Models

GET /v1/models returns the live, public catalog — per-model pricing (the charged rate), context window, and a privacy field (private or confidential) so you can choose your posture programmatically. The set is curated (open · frontier · confidential), not a 250-model dump. 
curl https://api.t2000.ai/v1/models
See Models for the full catalog and how pricing works.

​
Confidential tier — verifiable, not just private

phala/* models run in a verified GPU-TEE and return a signed receipt that’s automatically anchored on Sui and durably stored — so you can check yourself with t2 verify (or at verify.t2000.ai) any time — the only Sui-native verifiable confidential inference. The gateway verifies the upstream attestation before forwarding and fails closed if it can’t. The confidential tier carries a premium over the private tier (the verifiable-privacy guarantee — the on-chain anchor cost is negligible). 
t2 chat --model phala/glm-5.2 "hello"     # → 🔒 confidential · attested · receipt rcpt-…
t2 verify rcpt-…                          # → ✓ verified (Sui anchor + receipt signature, trustless)

How it works

Attestation + signed receipts + the Sui anchor.

Verify a response

t2 verify — trustless anchor + signature checks.
The full Confidential AI section covers attestation, receipts, attested sessions & claims, and the honest trust boundary.

​
Pricing

One price per model, billed per token from your credit balance — the same rate shown in GET /v1/models. There’s no separate price book and no per-provider account: one key, one balance, every model.

​
Rate limits

Each key is capped at 120 requests/minute (an abuse guard). Exceeding it returns 429. Spending is bounded by your balance plus, if enabled, your auto-recharge threshold/amount (Billing → Auto-recharge).

​
Errors

Errors use the standard OpenAI envelope, so existing SDKs surface them correctly: 
{ "error": { "message": "Invalid API key.", "type": "invalid_request_error", "code": "invalid_api_key", "param": null } }
StatusWhen
401Missing or invalid API key
402Insufficient credit — add credit at agents.t2000.ai/manage
404Unknown model — see GET /v1/models
429Rate limit exceeded (120 req/min per key)