Getting started

Overview

Prism402 is an OpenAI-compatible inference router. Calls are metered by the token and paid in USDC on Arc.

Base URL

https://prism402.com/v1

Everything under /v1 follows the OpenAI wire format: POST /v1/chat/completions, POST /v1/embeddings and GET /v1/models. Existing OpenAI SDKs work by changing the base URL.

Two ways to pay

• Prepaid key. Deposit USDC once, get a prism_sk_ key, send it as a Bearer token. Each call is charged its exact token cost. Best for apps and anything using an OpenAI SDK.
• Pay per call (x402). No key and no account. The first request returns 402 Payment Required with a price; your client signs it and resends. Best for autonomous agents holding their own wallet.

Authentication

Authorization: Bearer prism_sk_...

There are no accounts, emails or passwords. The key is the account, and the wallet that funded it is its owner. Refunds always go back to that wallet.

Where the models run

Every model in the catalog is served on Cloudflare's GPU network (Workers AI). Prism402 adds the payment rail, metering, cache and the public ledger. Prompts are not logged: the ledger keeps model, token counts, charge and time. The only content kept is the response cache (temperature-0 calls, scoped to your key or wallet, deleted after 24 hours).

What's here

• Quickstart: first call in a minute
• Models: the catalog and its fields
• Trench Scan: token risk scans for agents
• Prepaid keys: mint, top up, inspect, close
• Pay per call: the 402 flow, end to end
• Caching and refunds: half-price repeats, and change back
• Errors: codes you should handle

Getting started

Quickstart

Mint a key, swap one URL, make a call.

1. Get a key

Open the dashboard, connect a wallet holding USDC on Arc, choose a deposit and sign. The key is shown once, so store it. Prefer a terminal? See Prepaid keys.

2. Chat completions

from openai import OpenAI

client = OpenAI(base_url="https://prism402.com/v1", api_key="prism_sk_...")
reply = client.chat.completions.create(
    model="gpt-oss-120b",
    messages=[{"role": "user", "content": "What is Arc?"}],
)
print(reply.choices[0].message.content)

import OpenAI from "openai";

const client = new OpenAI({ baseURL: "https://prism402.com/v1", apiKey: process.env.PRISM_KEY });
const reply = await client.chat.completions.create({
  model: "kimi-k2.6",
  messages: [{ role: "user", content: "What is Arc?" }],
});

curl https://prism402.com/v1/chat/completions \
  -H "Authorization: Bearer $PRISM_KEY" \
  -H "content-type: application/json" \
  -d '{"model":"llama-3.3-70b-instruct","messages":[{"role":"user","content":"hi"}]}'

Streaming works the usual way: pass stream: true. Add stream_options: {"include_usage": true} for the token counts in the final chunk; that chunk also carries a prism object with the exact charge.

3. See what it cost

Every non-streaming response carries the exact charge:

X-Prism-Charge-USDC: 0.000213
X-Prism-Cache: MISS

Your balance and the last calls are on the dashboard or at GET /v1/keys/me.

API

Models

The catalog is public. Agents can discover models and prices before they spend anything.

curl https://prism402.com/models

{
  "data": [
    {
      "id": "gpt-oss-120b",
      "provider": "OpenAI",
      "type": "chat",
      "modality": "text",
      "context_length": 128000,
      "min_output_tokens": 512,
      "input_usdc_per_mtok": 0.438,
      "output_usdc_per_mtok": 0.938,
      "released_at": "2025-08-05"
    }
  ]
}

GET /v1/models returns the same entries in the OpenAI list shape, so SDK model pickers work.

Fields

• type: chat or embeddings, which decides the endpoint.
• input_usdc_per_mtok / output_usdc_per_mtok: the posted price per 1M tokens. This is what you are charged.
• context_length: the window. It also bounds the pay-per-call ceiling.
• min_output_tokens: reasoning models think before they answer. A max_tokens below this is rejected up front instead of billed for an empty reply.
• modality: text+vision models accept image_url parts.

Embeddings

curl https://prism402.com/v1/embeddings \
  -H "Authorization: Bearer $PRISM_KEY" \
  -H "content-type: application/json" \
  -d '{"model":"bge-m3","input":["first text","second text"]}'

Embedding models don't report token counts upstream, so they are counted as ceil(bytes / 4) per input and billed at the posted input rate.

Browse the live list with prices on the Models page.

API

Trench Scan

A risk read of one token on Arc: contract facts from the chain, pool data from DexScreener, a 0-100 score from published rules and a short model-written summary. Free on the web; $0.002 per call for agents.

curl https://prism402.com/v1/scan \
  -H "Authorization: Bearer $PRISM_KEY" \
  -H "content-type: application/json" \
  -d '{"address":"0x..."}'

With no key, the answer is a 402 for 2000 atomic USDC; pay it like any other x402 call.

What it reads

Tokens deployed as EIP-1167 clones (how launchpads usually deploy) are followed to their implementation, so the function table checked is the real one. Grades: 80+ Clean surface, 60+ Caution, 40+ High risk, below that Danger.

A clean surface is not proof of safety. It means none of these switches were found. Holder distribution and deployer history are not checked yet.

Agent scans read DexScreener from our servers; when it rate-limits us, market is null and the market_unavailable flag says so.

API

Prepaid keys

A key is minted by an x402 deposit and spends down per call. No login, no account.

Endpoints

• POST /v1/keys with {"amount_usd": 5}: x402 deposit, returns a new key
• POST /v1/keys/topup: x402 deposit plus Bearer, adds balance
• GET /v1/keys/me: balance, totals and recent usage
• DELETE /v1/keys/me: revoke the key and book what's left as a refund

Deposits are 1 to 1,000 USDC. The dashboard manages the same keys from the wallet that funded them: sign one free message and every key it owns is listed, with top up and close per key.

Mint from the dashboard

The dashboard runs the whole deposit in your browser wallet: it asks the server for terms, you sign one USDC authorization for exactly the amount you chose, and the key appears. It's kept in your browser only.

Mint from a terminal

import { privateKeyToAccount } from "viem/accounts";
import { x402Client, wrapFetchWithPayment } from "@x402/fetch";
import { ExactEvmScheme } from "@x402/evm/exact/client";

const account = privateKeyToAccount(process.env.AGENT_KEY);
const USDC = "0x3600000000000000000000000000000000000000";
const client = x402Client.fromConfig({
  schemes: [{ network: "eip155:5042", client: new ExactEvmScheme(account) }],
  spendControls: { allowedAssets: [{ network: "eip155:5042", asset: USDC, maxAmountPerPayment: "20000000" }] },
});
const pay = wrapFetchWithPayment(fetch, client);

const res = await pay("https://prism402.com/v1/keys", {
  method: "POST",
  headers: { "content-type": "application/json" },
  body: JSON.stringify({ amount_usd: 5 }),
});
console.log(await res.json()); // { key: "prism_sk_...", balance_usdc: "5.000000", ... }

The full key is returned exactly once. Prism402 stores only its SHA-256 and cannot show it again.

Close a key

DELETE /v1/keys/me revokes the key immediately and books the remaining balance as a refund to the wallet that funded it.

API

Errors

API errors are OpenAI-shaped. Payment errors are x402-shaped. Both are JSON.

{ "error": { "message": "...", "type": "invalid_request_error", "code": "model_not_found" } }

Payment errors

A rejected payment returns 402 with a code and an empty accepts:

{ "x402Version": 2, "error": "client amount=1200 does not match required 1310", "code": "terms_mismatch", "accepts": [] }

• bad_payload: the header is not a valid x402 v2 payload
• terms_mismatch: what you signed is not what was quoted (amount, asset, network or recipient)
• verify_invalid: the facilitator rejected the signature or the balance
• payment_replayed: this authorization was already used. Sign a new one.
• settle_failed: nothing moved. Safe to retry.
• settle_unconfirmed: settlement couldn't be confirmed. Check the transaction before retrying.

If a paid call fails before an answer is produced, the payment is never settled: your USDC doesn't move.

Agents and payments

Pay per call (x402)

No key, no account. The request itself carries the payment.

1. Ask

Send a normal request with no Authorization header. Set max_tokens: it bounds the amount you'll be asked to sign.

curl -i https://prism402.com/v1/chat/completions \
  -H "content-type: application/json" \
  -d '{"model":"gpt-oss-20b","max_tokens":600,"messages":[{"role":"user","content":"hi"}]}'

2. Get the price

The answer is 402 Payment Required. The challenge is in the body and, base64-encoded, in the PAYMENT-REQUIRED header.

{
  "x402Version": 2,
  "resource": { "url": "https://prism402.com/v1/chat/completions", "mimeType": "application/json" },
  "accepts": [{
    "scheme": "exact",
    "network": "eip155:5042",
    "asset": "0x3600000000000000000000000000000000000000",
    "amount": "314",
    "payTo": "0x...treasury",
    "maxTimeoutSeconds": 120,
    "extra": { "name": "USDC", "version": "2" }
  }]
}

amount is atomic USDC (6 decimals). It's a ceiling: your full input (counted generously) plus max_tokens of output at the posted rate.

3. Sign and resend

Sign an EIP-3009 transferWithAuthorization for exactly that amount to payTo, wrap it in an x402 payload, base64 it, and resend the same request with a PAYMENT-SIGNATURE header. The Arcus facilitator verifies it and, once your answer is ready, settles it and pays the gas. You never send a transaction yourself.

4. Get the answer, and the change

The response carries PAYMENT-RESPONSE (the settlement transaction) and X-Prism-Charge-USDC (what the call really cost). The difference between the ceiling and the real charge is booked to your wallet and paid back in batches.

Keep max_tokens close to what you expect: a tight ceiling means less USDC in flight per call. For many calls, a prepaid key is charged exact cost with nothing to refund.

Discovery

Agent directories can read /.well-known/x402: endpoints, models, prices, the settlement asset and the facilitator.

Agents and payments

Caching and refunds

Repeats cost half. Unused budget comes back.

Response cache

A byte-identical request can be answered from cache without touching a model. A hit is billed at 50% of the normal token charge and returns X-Prism-Cache: HIT.

• Deterministic by default. Only requests with temperature: 0 are cached automatically.
• Opt in or out per request with the X-Prism-Cache header: on caches at any temperature, off bypasses.
• Tenant scoped. Your cache is keyed to your key or paying wallet. A hit never crosses tenants.
• Non-streaming only, kept for 24 hours.
• Fails open. Any cache problem just sends the request upstream.

Refunds

USDC is owed back to a wallet in three cases:

• Change. A pay-per-call ceiling minus the real charge.
• Failed deposit. A deposit settled but couldn't be credited.
• Key closed. The remaining balance of a revoked key.

Refunds are booked per wallet the moment they're owed (you can see the total on the dashboard) and sent from the treasury in batches. Very small amounts wait until they add up. A paid call that fails before answering is never settled at all.

Empty replies are free

If a model returns no usable text, the charge is waived.

Agents and payments

$PRISM discount

Hold $PRISM in the wallet that owns your key, or that signs your pay-per-call, and every call is billed lower. The threshold and rate are shown on the $PRISM page.

• Checked at call time with balanceOf on Arc, cached for ten minutes per wallet.
• Applies to chat, embeddings and cache hits. Responses carry X-Prism-Discount-Pct.
• On pay-per-call, the ceiling you sign is the undiscounted one; the discount comes back as part of your change.
• If Arc can't be read, the call goes through at the normal rate rather than failing.

The router never requires the token. Inference is always payable in USDC, and holding $PRISM doesn't entitle anyone to revenue.