Getting started

Overview

Prism402 is an onchain AI inference router: one API endpoint that routes calls to dozens of AI models, billed per token in USDG on Robinhood Chain — no signup, no subscription.

• One endpoint, every model.
• Pay per token, not per plan.
• Agents can pay for themselves — no human signup (x402).
• Trench Scan — instant risk check on any Robinhood Chain token.
• Repeat calls cost half (cache).
• Hold $PRISM, pay less.

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 USDG 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 USDG on Robinhood Chain, 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 Robinhood Chain?"}],
)
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 Robinhood Chain?" }],
});

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-USD: 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_usd_per_mtok": 0.438,
      "output_usd_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_usd_per_mtok / output_usd_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 Robinhood Chain: contract facts from the chain, pool data from DexScreener (GeckoTerminal when DexScreener has no pool), 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 units (USDG on Robinhood Chain or USDC on Base, your pick); 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 spread is read on web scans only, for tokens younger than about 11 days: your browser replays the token's Transfer logs from Robinhood Chain and leaves out contracts (pools, launchpad curves, lockers). Deployer history isn't checked yet.

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

Bots

Trench Watch

Follow a Robinhood Chain token after you buy. Trench Watch reads it again about every 5 minutes and messages you when something changed since the last reading. Free: 1 token per Telegram chat or X account, 10 when it's linked to a wallet holding 1,000,000+ $PRISM.

What raises an alert

Holders-first Launch Radar

A Telegram chat linked to a wallet holding 1,000,000+ $PRISM can send /radar on to @prism402scan_bot. Every token that clears Launch Radar (trending on Robinhood Chain, under 3 days old, $10K+ liquidity, new to the radar) then arrives in that chat the moment it is scanned, before the public channel digest. The balance is re-read before each message; below 1M, messages stop until it's back. /radar off stops it.

Holder slots

Sign in at prism402.com/watch with the wallet that holds your $PRISM and you get a one-time code (30 minutes). Open the Telegram link it gives you, or post @prism402 link CODE on 𝕏. The balance is read again whenever you add a token; drop below 1M and new watches fall back to 1 slot.

Alerts are facts read from the chain at the time shown, not predictions. A token can still go wrong without tripping any of these, and launchpad curves without a pool contract aren't covered by the liquidity rule. Not financial advice.

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 USDG. 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 USDG 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 USDG = "0x5fc5360D0400a0Fd4f2af552ADD042D716F1d168";
const client = x402Client.fromConfig({
  schemes: [{ network: "eip155:4663", client: new ExactEvmScheme(account) }],
  spendControls: { allowedAssets: [{ network: "eip155:4663", asset: USDG, 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_usd: "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 USDG 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:4663",
    "asset": "0x5fc5360D0400a0Fd4f2af552ADD042D716F1d168",
    "amount": "314",
    "payTo": "0x...treasury",
    "maxTimeoutSeconds": 120,
    "extra": { "name": "Global Dollar", "version": "1" }
  }, {
    "scheme": "exact",
    "network": "eip155:8453",
    "asset": "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
    "amount": "314",
    "payTo": "0x...treasury",
    "maxTimeoutSeconds": 120,
    "extra": { "name": "USD Coin", "version": "2" }
  }]
}

Two ways to pay, same price: USDG on Robinhood Chain (eip155:4663) or USDC on Base (eip155:8453). Sign for the one you hold and say which in accepted.network. amount is atomic (6 decimals on both). 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 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-USD (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 USDG in flight per call. For many calls, a prepaid key is charged exact cost with nothing to refund.

Discovery

Agent directories can read /openapi.json (the OpenAPI contract with prices and request schemas) or /.well-known/x402: endpoints, models, prices, the settlement assets and the facilitator.

Prism402 is listed on x402scan, the x402 explorer and marketplace.

Contact

Questions, a stuck payment or a refund: hello@prism402.com.

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

USDG 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 Robinhood Chain, 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 Robinhood Chain can't be read, the call goes through at the normal rate rather than failing.

Free holder messages

In the playground, a wallet that holds the minimum $PRISM can sign in and send 25 free messages a day to any chat model (up to 2,048 output tokens each). Sign-in is a free signature, not a transaction. The count resets daily (UTC) and is shown next to the holder option.

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

Agents and payments

MCP server and npm

The prism402 package is both a TypeScript client and an MCP server, so any MCP-capable agent (Claude, Cursor and others) can call every model and Trench Scan as tools.

claude mcp add prism402 -e PRISM402_API_KEY=prism_sk_... -- npx -y prism402

{
  "mcpServers": {
    "prism402": {
      "command": "npx",
      "args": ["-y", "prism402"],
      "env": { "PRISM402_API_KEY": "prism_sk_..." }
    }
  }
}

Tools

Paying

• PRISM402_API_KEY: a prepaid prism_sk_ key from the dashboard.
• PRISM402_PRIVATE_KEY: a wallet holding USDG on Robinhood Chain. Each call signs an x402 payment for exactly the quoted amount; the facilitator pays the gas. Use a dedicated wallet with a small balance.
• PRISM402_MAX_USD: the most it will sign for one call (default 0.25). PRISM402_NETWORK: robinhood (USDG, default) or base (USDC).

As a library

import { Prism402 } from "prism402";

const prism = new Prism402({ apiKey: process.env.PRISM_KEY });
const { response, receipt } = await prism.scan("0x...");
console.log(response.score, response.grade, receipt.chargeUsd);