Call it from your own code.

1. Top up your balance — from $1, in whole dollars.
2. Issue a key on API keys, scoped to the model you want. It is shown once.
3. Call TokenFusion's endpoint with it:

Every key issued on the API keys page is a TokenFusion key (tf-…) and is used at this endpoint, for every model on your rate card. The API keys page shows this call in cURL, Python, JavaScript and Java, for the key you pick.

Pass your key as a Bearer token on every request. Every key is issued for one model, you hold one active key per model at a time (a key in its last week may be replaced early), and a key may carry an expiry; all of this is enforced on the server, so a key that has expired or that names a different model is refused before anything is charged. The console uses your keys too: it lists the models you hold a live key for and makes each call with that key, so a key's usage covers both its console and its API calls.

We store a hash of your key, never the key itself. If you lose it, revoke it and issue another — we cannot recover it.

A reasoning model returns its thinking beside the answer in message.reasoning_content (in a stream, delta.reasoning_content); those tokens are output and are charged as output. When the answer stops at max_tokens, finish_reason is "length": send the conversation back with the partial answer and ask the model to continue, or raise max_tokens.

The response carries the usual usage block, plus a tokenfusion object with what the call cost and your balance after it, both in US dollars as plain decimal strings: charged_usd (to six decimal places) and balance_usd. A team key's answers carry no tokenfusion object.

For a model marked Creates images on your rate card, with a key issued for it (the chat endpoint refuses such a model, and this one refuses a text model, with 400 invalid_request).

The answer is {"created", "data": [{"url"} or {"b64_json"}], "tokenfusion": {"charged_usd", "balance_usd"}} (a team key's answer has no tokenfusion). A url is a TokenFusion link that works without a key for 7 days, then expires — download what you want to keep. Before the call, n times the price per image is held (or, for a model priced on image tokens, the most those images can cost); you are charged per image delivered — or, for a model priced on image tokens, on the image tokens of the images delivered — never more than was held, and nothing when none could be delivered. Images you make count toward the storage your account keeps.

This endpoint is stateless. An image model is given one prompt and remembers nothing of your earlier calls, so each call stands alone: to change an image you have already made, send the whole description again with the change in it — a bare “make them taller” draws only that. The console works differently on purpose: a follow-up message there is treated as a change to the description your last image was made from, and the reply shows the exact prompt that was sent.

For a model marked Speech on your rate card, with a key issued for it. The answer is the audio itself.

Priced per 1,000 characters of input. Before the call the price of the whole text is held; you are charged for the speech delivered, never more than was held, and nothing when none was. The charge and your balance are in the X-TokenFusion-Charged-USD and X-TokenFusion-Balance-USD headers.

For a model marked Video. A video takes a while to make, so it is a job: start it, ask for it until its status is completed (every few seconds), then download it.

Each answer is a video object: {"id": "video_…", "object": "video", "model", "status" (queued, in_progress, completed or failed), "progress", "seconds", "size", "created_at", "completed_at", "error"} — and, once completed, "tokenfusion": {"charged_usd"}. Priced per second of video: when the job starts, its length at the price per second is held; when it completes you are charged for the video delivered, never more than was held. A job that fails, or does not finish within three hours, is charged nothing. The finished video is kept for 7 days — download what you want to keep. It counts toward the storage your account keeps.

Returns exactly the models this key can reach — a key scoped to one model lists that one only, so what you discover is what you can actually call. A key that names no model (issued before keys named one) reaches nothing: it is refused with 403 model_not_authorized, as the call endpoints refuse it. Each entry's tokenfusion object carries its price in US dollars per million tokens (price_usd_in_per_m, price_usd_out_per_m) and its serving region (region) — a team key's entries carry no price. A model that creates images, video or speech adds:

• Everything is in US dollars: your balance, the rates (published in dollars per million tokens) and every charge.
• A call starts only when at least $1.00 is available — your balance less what calls already in flight hold. Keep that much in your balance to make calls.
• Before a call runs, its worst case is held against your balance. The hold is released the moment the real token counts arrive.
• You are charged on the token counts reported for the call at the model's rate — or, where the model serving it reports its own charge for the call, on that charge, converted to dollars. If a call comes back with neither, it is charged on an estimate — the prompt plus the text actually returned — and your usage page marks it as estimated.
• A call that is refused costs nothing; a call that fails after the model started answering may still be charged for the part it served.
• Your balance can reach zero but cannot go negative.

• A member of a team creates team keys on the API keys page, for the models the team admin has chosen. The team pays for their calls; the member's own balance is kept, untouched, until they leave.
• A team key's answers carry no money: no tokenfusion object, no price in GET /v1/models, and refusals with no amounts — 402 insufficient_balance (the team's balance is too low) and 402 team_limit_reached (the member's monthly limit).
• max_tokens is never sized to the team's money: leave it out and the model's default output is asked for, so an answer that ends with finish_reason: "length" says nothing about the team's balance or limit.
• While in a team, the member's own keys are paused (403 key_paused); a key of a membership that has ended is revoked (403 key_revoked); a model the team admin takes off the team refuses its keys (403 model_not_enabled) until it is put back.

Every error is returned as {"error": {"message": …, "type": …}}. This table is checked against the running application by the test suite, so it cannot drift away from what the API actually does.