Tokenized inference · by cumLabs

cumAI

Models from every major lab through one OpenAI-compatible API. Paid keys come next, and then tokenized inference: AI paid for with any clank.trade token.

Gateway: live Playground: opens soon Paid keys: next Tokenized inference: roadmap

GatewayLive
PlaygroundOpens soon
Paid keys + first burnNext
Paid data APILater
Any clank.trade tokenLater
xCUMLater
Lock and earnLater

There is no xCUM token yet. When there is, its one real address will be posted on this page. Any token called xCUM today is not ours.

Search models

				Max output	Details
Loading the models…

Per million tokens, charged per call to the millionth of a dollar. Bars are on a log scale. Read from the live gateway as this page loaded. Paid keys arrive with deposits, next.

Introduction

cumAI is an OpenAI-compatible gateway to chat models from every major lab. If your code already talks to OpenAI, point it at the base URL and pick a model. Nothing else changes.

Every call is priced per token and charged to the millionth of a dollar, and every answer says what it cost.

Base URL

https://api.clankuwu.com/v1

Authentication Keys arrive with deposits

Send your key as a bearer token. Keys start with cum-live-. We keep only a SHA-256 hash of each key, so it can't be shown to you again: store it when you create it.

A missing, malformed, unknown or revoked key is refused with a 401.

Roadmap Each key will name the clank.trade token its spending powers. A key that names none counts for CUM.

Header

Authorization: Bearer cum-live-…

Quickstart

One call with curl. Swap the model for any id from Models.

Request

curl https://api.clankuwu.com/v1/chat/completions \
  -H "Authorization: Bearer $CUM_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model": "gpt-5-mini",
 "messages": [{"role": "user", "content": "Hello"}]}'

Streaming

Set "stream": true and the answer arrives as server-sent events, chunk by chunk, ending with [DONE].

If you close the stream early, you are charged for what was delivered, not for the whole answer.

Events

data: {"choices":[{"delta":{"content":"Hel"}}]}
data: {"choices":[{"delta":{"content":"lo"}}]}
data: [DONE]

OpenAI SDKs

The official Python and JavaScript SDKs work as they are. Change the base URL and the key, and keep the rest of your code.

from openai import OpenAI

client = OpenAI(
    base_url="https://api.clankuwu.com/v1",
    api_key=os.environ["CUM_KEY"],
)
reply = client.chat.completions.create(
    model="claude-sonnet-5",
    messages=[{"role": "user", "content": "Hello"}],
)

import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.clankuwu.com/v1",
  apiKey: process.env.CUM_KEY,
});
const reply = await client.chat.completions.create({
  model: "claude-sonnet-5",
  messages: [{ role: "user", content: "Hello" }],
});

Chat completions `POST /v1/chat/completions`

`model`string · required	Any id from Models.
`messages`array · required	The conversation, in OpenAI's shape.
`stream`boolean	Send the answer as events. See Streaming.
`max_tokens`integer	Or `max_completion_tokens`: send either one. We forward it as the one that model honours, never both. Where a model's entry says `"output_cap": "honoured"`, your cap holds (its own limit if you send none). Where it says `"held_at_model_limit"`, the model's own limit holds whatever you ask.
`tools`, `tool_choice`, `response_format`	Passed to the model. They count toward the input, and their text is moderated like the prompt.

Request body

{
  "model": "deepseek-v4-pro",
  "messages": [
    {"role": "system", "content": "Be brief."},
    {"role": "user", "content": "Hello"}
  ],
  "max_tokens": 400,
  "stream": true
}

List models `GET /v1/models`

Every model with its prices per million tokens and, where the maker publishes them, its context length and output limit. The same list as the Models tab. No key needed.

One entry

{
  "id": "claude-sonnet-5",
  "object": "model",
  "owned_by": "cumlabs",
  "pricing": {
    "input_usd_per_million": 1.9,
    "output_usd_per_million": 9.5
  },
  "context_length": 1000000,
  "max_output_tokens": 128000,
  "output_cap": "honoured"
}

Response headers

`x-cum-cost-usd`	What this call was charged, in dollars.
`x-cum-request-id`	The call's id. Quote it when you report a problem.
`x-cum-balance-usd`	On keyed calls: your balance after this call.
`x-cum-free-left-usd`	On free calls: what is left of today's allowance.
`retry-after`	On a 429: seconds to wait before trying again.

Errors

Errors come back in OpenAI's shape: {"error": {"type", "code", "message"}}. Switch on the code.

Status	Code	What happened
400	`bad_request`	The request is malformed: no model or messages, an image or audio part (only text is accepted), `n` other than 1, a `stream` that isn't true or false, a `max_tokens` that isn't a whole number, a body that isn't JSON, or a key in the URL.
400	`content_blocked`	The prompt broke the content policy and was not sent.
400	`looks_like_recovery_phrase`	The prompt looked like a wallet's recovery phrase, so it was not sent.
400	`upstream_rejected`	The model's provider refused the request as sent.
401	`missing_key` · `malformed_key` · `unknown_key` · `key_revoked`	No key, one that isn't a key's shape, a key we don't know, or one that was revoked.
402	`insufficient_balance`	The balance doesn't cover this call's worst case.
403	`refused`	This account can't make calls.
404	`unknown_model`	No model by that id. See List models.
409	`unpriced_model` · `model_not_capped`	Rare: that model has no price or no output limit yet, so it can't be called.
413	`body_too_large`	The request body is over 1 MiB.
429	`rate_limited`	Too many requests from one address, or this key already has 4 calls open. Wait for `retry-after`.
429	`key_cooling_down`	This key's prompts were refused too often today. It can call again later.
429	`upstream_rate_limited`	The provider is rate-limiting. Wait for `retry-after`.
502	`upstream_error`	The provider answered with an error.
503	`model_unavailable` · `upstream_unavailable`	The model or its provider is down right now.
503	`price_book_stale`	Prices are being refreshed. Try again shortly.
503	`moderation_unavailable`	Prompts can't be checked right now, so none are sent.
504	`upstream_timeout`	The provider took too long to answer.

Limits

Request body	1 MiB with a key. 64 KiB on the free tier.
Requests	120 a minute per client address, in bursts of up to 30, across every route. An IPv6 /64 counts as one address.
Calls open	At most 4 at once per key.
Free tier	One reply at a time per address, up to 8,000 tokens in and 1,024 out, from a daily allowance.
Output	Never past the model's own output limit.

Index endpoints Roadmap

The data behind cumOS (token checks, trades, holders, creator records) will be callable with the same key and paid from the same balance. Each endpoint will be priced from its measured cost, with keyed rate limits above the free ones.

Until then, the free data API is documented on cumOS, under Learn.