BASIS

An OpenAI-compatible API that records what it served

Point your existing OpenAI client at one base URL. Basis routes every request through a gateway, streams tokens back, and writes a verifiable receipt for the work. Gateway-served jobs are metered today; the contributor GPUs that earn $BASIS come online with the worker mesh.

Inference Live

Live — inference is routed to the contributor worker mesh; completed, verified worker jobs accrue $BASIS rewards, and requests fall back to a hosted upstream when no eligible worker is available. On-chain reward settlement is pending the $BASIS token and the reward distributor.

Runtime
Live
Real completions
served now
Model tiers
per model
Auth
open · low anon caps

Gateway-served jobs are metered, not paid; contributor-worker rewards route through the worker mesh. The live runtime is published at /api/launch-status.

Initializing console…

client → gateway → compute → stream → receipt → settlement

  1. 01
    ClientQuery

    Your app or agent calls /v1/chat/completions with an OpenAI-shaped request and your sk-basis- key.

  2. 02
    GatewayRoute

    The OpenAI-compatible gateway authenticates the key and resolves the backend. Today it serves through a hosted upstream; worker routing turns on when a verified worker is online.

  3. 03
    ComputeServe

    A model serves the request — the hosted upstream now, or a contributor GPU once worker routing is on and an eligible worker is online.

  4. 04
    StreamStream

    Tokens stream back through the gateway to the caller; the server counts output tokens as it relays them, and that count is authoritative.

  5. 05
    ReceiptVerify

    Every served job produces a hash-stable receipt: model, token counts, charge, and worker reward over canonical JSON.

  6. 06
    SettlementSettle

    Reservations finalize into a credit debit and a worker reward; rewards batch and settle on Base.

Same client, one base URL

The surface mirrors the conventions your stack already speaks — /v1/chat/completions and /v1/models — so existing OpenAI clients point at Basis with a base-URL change and a sk-basis- key. Streaming uses standard server-sent events. What is different is underneath: accounting is deterministic, receipts are hash-stable, and a worker-routed job rewards the contributor GPU that served it.

curl — a streaming chat completion

shell
curl https://basis.watch/api/v1/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer sk-basis-..." \
  -d '{
    "model": "basis-default",
    "messages": [{ "role": "user", "content": "Summarize this transaction." }],
    "stream": true
  }'

OpenAI SDK — set baseURL, keep your code

typescript
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://basis.watch/api/v1",
  apiKey: process.env.BASIS_API_KEY, // sk-basis-...
});

const stream = await client.chat.completions.create({
  model: "basis-default",
  messages: [{ role: "user", content: "Summarize this transaction." }],
  stream: true,
});

for await (const chunk of stream) {
  process.stdout.write(chunk.choices[0]?.delta?.content ?? "");
}

List the catalog

shell
curl -s https://basis.watch/api/v1/models

Pay, reserve, receipt

The public API is a free, metered demo today — it does not require $BASIS credits. The accounting model it runs on is the real one: usage is metered deterministically per token in integer base units, floor division, no floating point in the money path. The payment router can quote ETH, WETH, or USDC into $BASIS at request time — quotes only, with your wallet signing every swap; paid $BASIS credits come online behind their own gate.

Reserve

At reservation the price is locked into a hashed snapshot. A new pricing epoch applies only to new quotes — accepted jobs are never repriced.

Meter

The server counts output tokens as it streams them. That count — not a worker's self-report — drives the charge and the reward.

Receipt

The reservation finalizes into a credit debit and a worker reward, recorded in a receipt anyone can recompute from the same inputs.

Why receipts matter

Every served job produces an inference receipt: a SHA-256 hash over the canonical JSON of the job's immutable economic core — model, token counts, multipliers, charged and reward amounts. The hash excludes mutable envelope fields (status, signature, settlement pointers) so it stays stable across the receipt's lifecycle.

Because the hash is deterministic, anyone can recompute it from the same inputs and confirm the accounting was not altered after the fact. Receipts are the audit trail that makes both billing and reward routing checkable rather than asserted.

Model catalog

The multiplier scales pricing and rewards relative to 1x. Each tier in the catalog is served through the live OpenAI-compatible runtime.

Model idContext windowMultiplierStatus
basis-small16,3840.5xlive
basis-default32,7681xlive
basis-large131,0723xlive

Start building

Create an API key, point your OpenAI client at the Basis base URL, and send your first request. Workers join the same network to serve the jobs and earn $BASIS.

$BASIS is the network's inference and reward asset, live on Base after launching through Bankr. For how GPU workers join and earn, see /workers. For settlement batches on Base, see /settlement.

Inference — OpenAI-compatible API on Base · Basis