Console
Billing

Pricing & billing

What a request costs and how you are billed.

You pay the provider's per-token price, published per model in USD per million tokens. RouterPlus adds no per-token markup and no fee line.

Every billed response has usage.cost: the amount debited from your balance. You can recompute it from the response.

One provider is our own: RouterPlus, which runs its decision models on its own GPUs. These models cost $0 for input and output (see Decision models).

In the console, open Billing > Credits to buy credits and see your balance.

Where prices live

The catalog is public and needs no key:

bash
curl -s https://app.routerplus.com/api/models.json \
  | jq '.models[] | select(.id == "claude-sonnet-4-5").pricing_usd_per_million'
json
{
  "prompt": "3",
  "cached_prompt": "0.30",
  "cache_write": "3.75",
  "completion": "15"
}

Prices are decimal strings with up to six fractional digits, in USD per million tokens. They convert without loss to the ledger's unit, so billing uses no floating-point rounding.

SKUWhat it billsExample (claude-sonnet-4-5)
promptNon-cached input tokens$3 / M
cached_promptPrompt-cache reads$0.30 / M
cache_writePrompt-cache writes$3.75 / M
completionOutput tokens, including reasoning unless a distinct rate is declared$15 / M
internal_reasoningThe reasoning part of output, when a provider declares a distinct rate(none)
Note

A model that declares no cache or reasoning SKU bills those tokens at its base rate. cached_prompt and cache_write default to the prompt price. internal_reasoning defaults to the completion price. A missing price never means $0.

Image models

Image models bill in one of two ways. The tables of every image model, with its parameters, price and ceiling, are on POST /v1/images/generations.

  • The GPT Image models bill in tokens (below).
  • Every other image model, served by Replicate, Krea or Recraft, is billed at the cost reported for the render: the provider's published price per image, with no margin. See Models billed at the provider's reported cost.

The GPT Image models bill on the same two SKUs as chat, in USD per million tokens: prompt for the text you send, completion for the image that comes out. OpenAI reports image output in tokens, and the size and quality you ask for set the count. The per-image ceiling is the most output tokens one image can bill. It is max_output_tokens on the model page and in /api/models.json.

Model idText in /1MImage out /1MPer-image ceiling
gpt-image-2$5$308,232 tokens
gpt-image-2.5-flare$5$308,232 tokens
gpt-image-2.5-sunburst$5$308,232 tokens
gpt-image-1.5 (until 2026-12-01)$5$326,500 tokens
gpt-image-1-mini (until 2026-12-01)$2$86,500 tokens

OpenAI shut down gpt-image-1 on 2026-10-23, and shuts down gpt-image-1-mini and gpt-image-1.5 on 2026-12-01 (OpenAI's deprecations); they leave the catalog on those dates. Use gpt-image-2 or a gpt-image-2.5 model.

Every output token bills at the image rate. This includes the text output tokens that gpt-image-1.5 counts in its output_tokens. See POST /v1/images/generations.

Krea 3 (krea/krea-3) is billed at Krea's own published price per image, with no markup. The gateway works out the price from the request and the images, because Krea does not report a cost:

Krea 3Price
1K image$0.03
2K image$0.06
high thinkingadds $0.02
Each reference up to 1,048,576 pixelsadds $0.02
Each larger reference, or a reference sent as a URLadds $0.07

The most one Krea 3 image can cost is $0.64, and that is the amount held while it renders. The details are in Krea image models.

Models billed at the provider's reported cost

The image models served by Replicate, Krea, Recraft and MachGen, and the video models, are priced per image, per output megapixel, per second of video or per video, not in tokens. For these models the charge is the cost reported for the request, at the provider's published price, with no margin:

ProviderWhere the reported cost comes from
RecraftRecraft's own figure for the request: its credits, $0.001 each
ReplicateReplicate reports no cost, so it is worked out from Replicate's published price for what was rendered
KreaKrea reports no cost, so the gateway works out Krea's published price from the request and the images it measured
MachGenMachGen's published price for what was asked (per image, or per second of video at the length, resolution and sound asked for), less the model's own credit-back: what MachGen bills the marketplace
  • The models page and /api/models.json show each model's listed prices (price_card), and its row says "billing": "reported_cost".
  • The reservation is a ceiling: n × the per-image ceiling for an image model, seconds × the per-second ceiling for a video model. The models page shows it as Per image ≤ or Per second ≤.
  • A render that succeeds but reports no cost is charged the ceiling, marked estimated.
  • A reported cost above the ceiling is still charged in full: the ceiling limits what is held, not what is billed.
  • A failed render reports no cost and is charged nothing.

In the ledger these rows count cost units: one unit is one micro-dollar, priced at $0 per million in and $1 per million out. So output_tokens on such a row is the charge in micro-dollars, and the ceiling (max_output_tokens) and the per-million prices in /api/models.json ("0" and "1") are in the same units. The response you read carries usage.cost in USD. Its input_tokens and output_tokens are the provider's own counts, 0 when it reports none, and are not billed.

For example, seedream-5-lite on Replicate costs $0.035 an image, and its ceiling is 35,000 units. A request for one image holds $0.035 and settles 35,000 units: $0.035.

Each model's price and ceiling: Models served by Replicate, Krea image models and Recraft models and MachGen models on the image API page, and POST /v1/videos for the video models.

Decision models

Decision models answer typed questions on POST /v1/decisions. They are priced in USD per million tokens, like every other model. The one exception is Parallel Decisions, which is priced per call (below).

Model idInput /1MCached /1MOutput /1MWhat the token counts are
typesafe/jev-1.13$0.042–$0The provider's input count
bespokelabs/nimble-v4$0.04–$0The provider's input count
bespokelabs/nimble-v4-max$0.09–$0The provider's input count
cloudflare/clef$0.24–$0The provider's input count
cloudflare/clef-flash$0.09–$0The provider's input count
routerplus/decider-2b$0$0$0The provider's input count; an answer from its cache bills $0
routerplus/kev-4b$0$0$0The provider's input count; an answer from its cache bills $0
perplexity/pplx-decider-v1-27b$0.04–$0The provider's input count, which holds the state once per question
perplexity/pplx-decider-v1.3$0.02–$0The provider's input count, which holds the state once per group of questions that fit the context (one group for most calls)
openai/gpt-6-luna-decisions$0.10–$0The provider's input count: the state once, and about 150 tokens for each question
levanto/sage-1.2$0.05–$0The provider's input count, which holds the state once per question
scaledown/classify-1$0.05–$0The provider's input count, summed over its questions (each one is a call)
fastino/gliner-2.5-decide$0.03–$0Fastino's prompt_tokens
parallel/decisions–––$0.001 per call, 1 to 100 questions: not priced per token

Parallel Decisions is priced per call: $0.001 for each call of 1 to 100 questions, Parallel's own price with no markup, whatever the state, the number of questions or the answers (a call whose answers are all refusals costs $0.001 too). The gateway holds $0.001 for the call and charges the same; a refusal before the call (a 400), Parallel's own refusal, a failed call and a 200 that is not an answer cost nothing. Its usage.input_tokens is Parallel's own count, for information, and is not billed; usage.cost is the call's price. The decisions discount comes off it like any other decision model's. The Parallel launch offer makes it free for paid organizations, within the offer's limits, until RouterPlus ends the offer. Its row in /api/models.json says "billing": "reported_cost" with a price_card of one line, {"unit": "request", "cost_usd": "0.001", "billable": "request", "variant": "1-100 questions"}. Its pricing_usd_per_million there ("prompt": "0", "completion": "1") is in cost units, one unit a micro-dollar, not a price per token: read price_card, as for the image listings billed at the cost the provider reports. See Parallel Decisions.

Output is free on every decision model. Each model is billed on its provider's input count at the provider's price, with no markup, unless its section below says otherwise.

Bespoke Nimble

  • $0.04 per million input tokens for Nimble v4, $0.09 for Nimble v4 Max.
  • Bespoke counts the state and the questions once per call.
  • A three-question call of 178 input tokens costs $0.000007 on Nimble v4 and $0.000016 on Nimble v4 Max.
  • bespokelabs/nimble-latest is in no list. It bills at $0.04 per million input tokens, Bespoke's price for nimble-latest, whichever model Bespoke picks for it.

Clef and Clef-flash

  • $0.24 and $0.09 per million input tokens. Cloudflare reports output_tokens: 0.
  • Cloudflare bills Workers AI in neurons, at $0.011 per 1,000 neurons. Its price page lists Clef at 21,818 neurons ($0.24) and Clef-flash at 8,182 neurons ($0.09) per million input tokens.
  • A call of 400 input tokens costs $0.000096 on Clef and $0.000036 on Clef-flash.

Decider 2B and Kev 4B

Decider 2B and Kev 4B are RouterPlus's own models, on RouterPlus's own GPUs. RouterPlus charges nothing for them.

  • Input, cached input and output are free. usage.cost is 0 on every call.
  • RouterPlus still reports its input count, which is at most the model's context. A long input that Decider 2B (25,600 tokens) cuts counts only the tokens the model read.
  • A free call is still metered, counted against your limits and its pool, and recorded in GET /v1/generation. It still needs an organization with credit.
  • RouterPlus answers an identical request from its cache for 600 s.

Perplexity Decider v1 27B

  • $0.04 per million input tokens.
  • Perplexity runs one prompt for each question, and each prompt holds the whole state.
  • Five questions about a state of 1,843 tokens bill 9,215 input tokens, $0.000368.
  • One call with many questions still saves round trips.

Perplexity Decider v1.3

  • $0.02 per million input tokens.
  • Perplexity answers all the questions in one pass and bills the state once.
  • Twenty questions about a state of about 930 tokens bill 1,476 input tokens, $0.0000295.
  • When the state and the questions are above 262,144 tokens together, Perplexity splits the questions into groups and bills the state once for each group.

GPT-6 Luna Decisions

  • $0.10 per million input tokens. OpenAI reports output_tokens: 0.
  • It bills at its list price: no discount applies to it today.
  • OpenAI bills the state once per call. It runs a prompt for each question, so each question adds about 150 input tokens. One yes/no about a two-character state billed 156 tokens, and five billed 760.
  • A three-question call (a choice, a score and a yes/no about a short complaint) billed 396 input tokens, $0.000039.
  • One call with many questions saves round trips and the state's tokens. The questions' tokens stay the same.
  • A question that OpenAI declines (its answer is {"type": "refusal"}) is billed too.
  • The listing's context is 272,000 tokens. Up to there, OpenAI's listed price holds. OpenAI bills input above it at twice the rate.

GLiNER-2.5-Decide

  • $0.03 per million input tokens.
  • usage.input_tokens is Fastino's prompt_tokens. usage.output_tokens is its completion_tokens.
  • A call of 1,000 input tokens costs $0.00003.

Sage

  • $0.05 per million input tokens.
  • Sage reads and bills the state once per question, like Perplexity Decider.

The decisions discount

A discount can apply to decision models: a percent off the charge of every decision model, or of some of them, each at its own percent. It applies to every key, the Playground's included. It does not change the list price, and it can change or end. Parallel Decisions at 100 % is the Parallel launch offer, which has its own terms.

A discounted model's page and directory row show the percent beside the struck list price ("Free" at 100 %). Its row in /api/models.json has discount_percent. Every discounted response says what applied:

WhereWhat it shows
usage.costWhat you paid, after the discount
usage.cost_before_discountThe charge at the list price
usage.discount_percent and the x-tm-discount-percent headerThe percent taken off
cost_usd in GET /v1/generationWhat you paid, after the discount
inference_cost_usd in GET /v1/generationThe cost at the list price
  • The discounted charge is the list charge × (100 − percent) / 100, rounded down to the micro-dollar.
  • With no discount, the three discount fields are absent and usage.cost is the list charge.
  • A discount needs an organization with credit. With a balance of $0, a discounted request gets 429 insufficient_quota, as any request does, even at 100 %.

A discount can cover a model whose list price is already $0 (Decider 2B and Kev 4B today). Then the discount has nothing to take off: usage.cost and usage.cost_before_discount are both 0. The gateway still reports usage.discount_percent and the header, as on every model the discount covers, and /api/models.json still carries discount_percent on its row, so one reader works for all fourteen models. The model's page, the directory and the Playground show no "N % off" beside a $0 price, because the model is free, not discounted.

The math: integer micro-USD

All money math is in integer micro-USD (millionths of a dollar). A published price of "2.50" becomes 2500000 micro-USD per million tokens. Two rounding rules apply:

  • Reserve rounds up (ceiling), so the hold is conservative.
  • Settlement rounds down (floor).

The settlement formula:

non_cached_input = max(0, input_tokens − cached_tokens − cache_write_tokens)
reasoning        = clamp(reasoning_tokens, 0, output_tokens)
plain_output     = output_tokens − reasoning

cost_micro = floor((
    non_cached_input   × prompt_per_M
  + cached_tokens      × cached_prompt_per_M
  + cache_write_tokens × cache_write_per_M
  + plain_output       × completion_per_M
  + reasoning          × reasoning_per_M
) / 1,000,000)

Each *_per_M is the integer micro-USD price. usage.cost is this number divided by 10⁶.

Reserve, then settle

Every billed request has four steps:

  1. 01
    Reserve. Before RouterPlus contacts a provider, the gateway holds an estimate of the highest cost.
    • Input (chat surfaces): one token per byte of the request body, plus 65,536 tokens for each image or document part. An image sent inline counts the 65,536 only, not its base64 bytes.
    • Output: all of your max_tokens (or max_completion_tokens, or max_output_tokens on POST /v1/responses).
    • No output limit: the hold covers at most 32,768 output tokens, and the model gets its own maximum. On the chat surfaces, the gateway writes that maximum into the request, lowered when needed so that the input and output fit the model's context window (see POST /v1/chat/completions). On /v1/responses the gateway adds none, and OpenAI applies the same maximum.
    • Rate: each side is priced at the model's highest rate for that side (cache writes and reasoning, when they cost more than plain input or output). The sum rounds up to micro-USD.
    • Web search: a request with a web search tool also holds the search fee for the tool's max_uses searches (at most 20), or for 5 when it sets none (see Web search).
    • Images: on /v1/images/generations, the output is reserved at n × the model's per-image ceiling (not max_tokens), and the input at the prompt bytes ÷ 4.
  2. 02
    Dispatch. The request goes to a provider. Prices are pinned at this moment (see Price changes).
  3. 03
    Settle. When the attempt finishes, RouterPlus prices the provider-reported token counts with the formula above and rounds down. You pay that amount, also when it is more than the hold (a long answer to a request without a limit).
  4. 04
    Release. RouterPlus releases the hold in full.

When usage is not reported

An attempt can end before the provider reports usage: you cancelled it, or the provider failed after your answer started. You then pay for the input and for the output already streamed to you. RouterPlus does not charge the hold.

  • Input: the provider's own count when it sent one. Claude sends it when its answer starts, with its cache reads and writes, each at its own price. Otherwise, the request's likely input (its size at four bytes a token, with 1,600 tokens for each image or document part) at the plain input price.
  • Output: what was streamed to you before the end (text, tool-call arguments and any reasoning you received), at four characters a token. If you cancel before the first token, or the call does not stream, the output part is $0.

A model that hides its thinking (the Claude 5 models, by default) streams nothing while it thinks. A cancel during that time costs the input only. Such a charge has the provenance estimated.

You pay the reserved maximum in two cases:

  • The gateway stopped mid-request and cannot observe the outcome (unknown_after_crash in GET /v1/usage & /v1/generation), because the provider may have billed the call.
  • An attempt completes and the provider reports no usage. This is rare.

Refusals before dispatch

CauseRefusal
Balance too low. Your balance must cover every reservation your org has in flight, this one included.429 with error_type: insufficient_quota (the OpenAI shape SDKs handle; native type billing_error on the Anthropic surface)
Monthly spend cap hit. Caps are org-wide and per key, per UTC calendar month. The strictest wins.The same 429 insufficient_quota, with the reset time in the message and in the x-tm-cap-reset header
A rate limit hit. The key's RPM, a shared limit of the organization, or the provider's pool.429 with error_type: rate_limit and retry-after

Errors & remediation gives the fix for each.

Failed images cost nothing

A failed attempt, a response over the 32 MiB cap, and a 200 with no decodable image all settle at zero. RouterPlus never returns or bills a partial image.

If you hang up mid-render, the render still finishes upstream. That attempt settles the provider-reported usage: never the reservation, and never $0.

Parallel Task runs: one price per completed run

Parallel Task runs (/v1/parallel/tasks/runs) are billed per run at Parallel's list price for the processor, with no markup: lite $0.005, base $0.01, core $0.025, core2x $0.05, pro $0.1 ($5, $10, $25, $50 and $100 per 1,000 runs). The create holds the run's price; the run is charged that price when Parallel completes it and $0 when it fails, is cancelled or needs an action. A run with no end after 2 hours is charged $0 if Parallel still reports it active. A run Parallel cannot be reached for at that point, and a run whose gateway restarted while it ran, is charged the hold. We keep asking Parallel about it. The charge stands only if Parallel reports the run completed. It is credited back if Parallel reports it failed, cancelled or still active after 2 hours, or gives no answer for 24 hours. The run's cost is always what was charged. Each run is one attempt in GET /v1/usage & /v1/generation: provider parallel, model parallel:task:<processor>, the price as server_tool_fee_usd.

Parallel FindAll: a fixed fee plus a fee per match

Parallel FindAll runs (/v1/parallel/findall/runs) are billed at Parallel's list price, with no markup: a fixed fee per run plus a fee per match, preview $0.1 + $0, base $0.25 + $0.03, core $2 + $0.15, pro $10 + $1, plus each enrichment's processor price per enriched match (lite $0.005, base $0.01, core $0.025). The create holds the run's max_cost, fixed + match_limit × (per match + enrichments), at most $25 a run; when the run ends it is charged fixed + matches × per match + the enriched matches, whether it completed, was cancelled or failed, and the rest of the hold is released; when the end cannot be read, the formula uses the last counts read. A run Parallel refuses at create is not charged. A run we lose sight of (RouterPlus restarted while it ran, or Parallel never answered a status read for it) is charged its hold until Parallel reports its end; then the difference is credited back. If its end is still unread 24 hours after its time limit, only what Parallel is known to bill stays charged: $0.1 for a preview, nothing for the other generators. Entity Search costs $0.005 a search, $0 when it fails. Each run or search is one attempt in GET /v1/usage & /v1/generation: provider parallel, model parallel:findall:<generator> or parallel:entity_search. The attempt's cost_usd is what the attempt was charged. For a run charged by the formula, and for a search, server_tool_fee_usd shows the same amount. For a run charged its hold (a run we lost sight of), cost_usd is the hold, and server_tool_fee_usd is 0 or null. A credit-back does not change the attempt: it shows as an adjustment in Billing. The run's cost is always the net amount.

Parallel Monitors: one price per execution

Parallel Monitors (/v1/parallel/monitors) are billed per execution at Parallel's list price for the processor, with no markup: lite $0.003, base $0.01 ($3 and $10 per 1,000 executions). Every execution is billed, whether it found something or not; a failed execution is not. A 1h lite monitor runs 720 times in 30 days: $2.16. Creating a monitor, or changing its frequency or processor, needs credit for 24 hours of its executions (held for a moment, then released). Each execution is charged once, as its own attempt in GET /v1/usage & /v1/generation (provider parallel, model parallel:monitor:<processor>, the price as server_tool_fee_usd), when RouterPlus reads it, at least once an hour. An execution that cannot be charged is not charged, and the monitor is stopped: a monitor never takes a balance below zero.

The cost on the wire: usage.cost

Every billed response has usage.cost (USD, a JSON number):

  • Non-streaming: in the response body's usage, on both surfaces.
  • Streaming, OpenAI surface: in the final usage chunk, before [DONE].
  • Streaming, Anthropic surface: in the message_delta usage at stream end.
bash
curl -s https://api.routerplus.com/v1/chat/completions \
  -H "Authorization: Bearer $TM_API_KEY" -H "content-type: application/json" \
  -d '{"model":"claude-sonnet-4-5","max_tokens":350,"messages":[{"role":"user","content":"hello"}]}' \
  | jq .usage
json
{
  "prompt_tokens": 1200,
  "completion_tokens": 350,
  "total_tokens": 1550,
  "prompt_tokens_details": { "cached_tokens": 800, "cache_write_tokens": 0 },
  "cost": 0.00669
}
python
import os
from openai import OpenAI

client = OpenAI(base_url="https://api.routerplus.com/v1", api_key=os.environ["TM_API_KEY"])
r = client.chat.completions.create(
    model="claude-sonnet-4-5", max_tokens=350,
    messages=[{"role": "user", "content": "hello"}],
)
print(r.usage.model_dump()["cost"])  # the ledger debit, in USD
python
import os
import anthropic

client = anthropic.Anthropic(base_url="https://api.routerplus.com", api_key=os.environ["TM_API_KEY"])
msg = client.messages.create(
    model="claude-sonnet-4-5", max_tokens=350,
    messages=[{"role": "user", "content": "hello"}],
)
print(msg.usage.model_dump()["cost"])
Warning

usage.cost is the full request debit, not the serving attempt's share. If a provider failed mid-prompt and the gateway failed over before your answer started, the number includes the tokens the failed attempt used. The per-attempt breakdown is at GET /v1/generation.

Usage reporting is always on:

  • Streams and non-streams both carry usage.
  • The gateway requests usage from the provider whatever you send, because RouterPlus cannot recompute unreported usage.
  • Only an explicit stream_options.include_usage: false changes anything. You are billed the same, but no usage chunk is written to you.

On the Anthropic surface, a stream that fails after your answer started has no place for usage outside message_delta. Its terminal error event carries no cost. Read those costs from /v1/generation. The OpenAI surface sends any known usage and cost before its terminal error.

Cache reads and writes

Cache tokens bill at their own rates on both surfaces. Both surfaces report the split:

ConceptOpenAI surfaceAnthropic surfaceBilled at
Non-cached inputprompt_tokens minus the two details belowinput_tokensprompt
Cache readsprompt_tokens_details.cached_tokenscache_read_input_tokenscached_prompt
Cache writesprompt_tokens_details.cache_write_tokenscache_creation_input_tokenscache_write
Outputcompletion_tokensoutput_tokenscompletion

On the OpenAI surface, prompt_tokens includes cache reads and writes. Billed responses always have prompt_tokens_details with both fields, set to zero when the provider reports none. Stream and non-stream usage have the same shape.

On Claude, a cache write costs 1.25 times the input price (cache_write). A cache read costs a tenth of it or less (cached_prompt).

When an agent sends a conversation with tools or earlier turns and no cache marks of its own, the gateway turns on Claude's automatic caching for it. The first turn pays a cache write on its prompt. The next turns read that prompt at the cache price.

  • The x-tm-auto-cache response header says whether automatic caching applied.
  • The request header x-tm-auto-cache: off turns it off.
  • Wire compatibility has the rules.

RouterPlus bills a web search that the provider runs for the model at the provider's price per search, plus the tokens:

ToolWherePrice
Anthropic's web search server tool (web_search_20250305 and later)Claude models on POST /v1/messages$10 per 1,000 searches ($0.01 a search)
Anthropic's web fetch server toolClaude models on POST /v1/messagesNo fee: only the tokens of the fetched page
OpenAI's hosted web_search toolOpenAI models on POST /v1/responses$10 per 1,000 calls
OpenAI's older web_search_preview toolGPT-4o, GPT-4o mini and GPT-4.1 mini on POST /v1/responses$25 per 1,000 calls
  • Each search counts once, whatever the number of results. A failed search is not billed.
  • The pages a search returns become input tokens at the model's input price, as on the provider's own API. On a stream, the input is the count at the end of the turn.
  • The fee is part of usage.cost, and of cost_usd in GET /v1/usage & /v1/generation. There, each attempt also shows server_tool_use (web_search_requests, web_fetch_requests) and server_tool_fee_usd. On /v1/messages, the answer's usage.server_tool_use.web_search_requests also gives the number of searches.
  • While the request runs, the hold includes the fee for each web search tool's max_uses searches (at most 20), or for 5 searches when the tool sets no max_uses. A tool of your own named web_search holds nothing.
  • If the model searches more often than the hold allows, you pay for every search it made. The hold limits what is set aside, and the charge has no such limit.
  • On your own provider connection (BYOK), RouterPlus charges no fee. The provider bills you.

Anthropic's server tools, web search included, work only for Claude models on POST /v1/messages, through the anthropic route. Claude Code calls them there. See POST /v1/messages.

RouterPlus's own server tools are a different thing. The gateway runs tako:search and the parallel:* tools itself, for any chat model, on POST /v1/chat/completions, POST /v1/messages and POST /v1/responses. Their prices follow. See Server tools.

tako:search is a server tool the gateway itself runs, for any chat model on POST /v1/chat/completions, POST /v1/messages and POST /v1/responses, opted in by a tools entry or the x-tm-tools: tako:search header (see Server tools). Each search costs $7 per 1,000 searches ($0.007 a search), Tako's list price at instant or fast effort, with no markup. A search that fails is not billed. The model's turns are billed as ordinary chat requests. Each search holds its $0.007 just before it runs, and is its own attempt in GET /v1/usage & /v1/generation (provider tako, model tako:search, server_tool_fee_usd: 0.007). usage.cost on the answer is the turns plus the searches, and usage.server_tool_use.tako_search_requests counts the searches billed.

Parallel tools

parallel:search, parallel:extract, parallel:image_search, parallel:place_search and parallel:decisions are server tools the gateway runs with Parallel, on the same three surfaces, opted in by tools entries or the x-tm-tools header (any of tako:search and the six parallel:* values, parallel:research included, comma-separated; see Server tools). Parallel's list prices, with no markup:

  • search: $1 per 1,000 searches ($0.001 a search) in turbo or fast mode, with up to 10 results; $5 per 1,000 searches ($0.005 a search) in basic or advanced mode;
  • extract: $1 per 1,000 URLs ($0.001 a URL), for each URL Parallel read; a URL it could not read is not billed (what Parallel counted in our probes; the gateway charges the URLs Parallel counts as read);
  • image search and place search: $1 per 1,000 calls ($0.001 a call) in fast mode, $5 per 1,000 calls ($0.005 a call) in advanced mode, with up to 20 results;
  • decisions: $1 per 1,000 calls ($0.001 a call), for up to max_questions questions, billed even when every answer is a refusal.

A search, image search, place search or decisions call holds its price (by tool and mode) just before it runs and is charged exactly that; an extract holds $0.001 for each URL it sends and is charged for the URLs read, never more than it held. A call that fails is not billed. Each call is its own attempt in GET /v1/usage & /v1/generation: provider parallel, model parallel:search, parallel:image_search, parallel:place_search or parallel:decisions (web_search_requests: 1, server_tool_fee_usd: 0.001 or 0.005) or parallel:extract (web_fetch_requests: the URLs billed). usage.cost on the answer is the turns plus every call, and usage.server_tool_use has a <function>_requests count per tool (parallel_search_requests, parallel_decisions_requests, and so on).

A server tool may be free for a while. Tools then shows its list price struck through with "Free", and its entry in /api/tools.json says "free": true. Its calls hold nothing and are not charged (with a balance of $0 a call is refused with 429 insufficient_quota, as a 100 % decisions discount is): server_tool_fee_usd and cost_usd are 0 on the call's attempt (inference_cost_usd is the list price), and usage.cost leaves the call out. usage.server_tool_use and x-tm-server-tools still count it. The model's turns are billed as usual.

The Parallel launch offer

Parallel Search (parallel:search), the Parallel Decisions tool (parallel:decisions) and the Parallel Decisions model (parallel/decisions) are free for paid organizations, up to $25 of list price a day each. The offer has no end date: it runs until RouterPlus ends it. It also ends when the launch budget is used. After the offer ends, each call costs its list price.

  • A paid organization has bought credit, or has a grant that is not the trial credit.

  • The offer covers calls with the organization's API keys. It covers its Playground runs too.

  • The $25 counts the list price of each free call: $0.001, or $0.005 for a search in basic or advanced mode. The count starts again at 00:00 UTC.

  • A call outside these terms is not refused. It is held and charged at its list price, like any paid call.

  • A free tool call shows as described above. A free Parallel Decisions call shows usage.cost 0, usage.cost_before_discount 0.001 and usage.discount_percent 100.

  • In the Console's request log, a free call's "Cost, recomputed" shows the list price and then the line "Free (100% off)".

  • While the offer is active, Tools and the model's page show the list price struck through with "Free". After it, they show the list price.

  • research (parallel:research): $0.01 a call at low effort, $0.05 at medium ($10 and $50 per 1,000), Parallel's list price for the effort the call ran at, with no markup. A call holds the price of the effort asked for and is never charged more; one that fails is not billed. Model parallel:research, web_search_requests: 1, usage.server_tool_use.parallel_research_requests (see Parallel research).

Reasoning tokens

Reasoning tokens are part of output. They are never billed on top of it.

  • The settlement math splits them out and prices them at the model's reasoning rate.
  • Today every cataloged model prices reasoning equal to completion, so the split changes nothing until a provider declares a distinct rate.
  • The OpenAI surface reports them in completion_tokens_details.reasoning_tokens. The Anthropic surface does not report them separately.

Price changes: frozen snapshots

You pay the price in effect at dispatch time.

  • Price rows are append-only. A change is a new effective-dated row, never an edit.
  • The row in effect when your request is reserved is pinned into the reservation and written onto every attempt's ledger row.
  • A price change published while your request is in flight does not affect it.
  • Past attempts always settle, and audit, against the prices they were dispatched under.

Create an account at Sign up, complete Clerk authentication and email verification, and save your first API key. Signup and card verification alone do not grant credit. Existing customers keep their balance and API keys.

Standard credit purchases start at $10 in Billing. The payment adds the amount you buy as paid credit. Your balance is the sum of credit ledger entries minus settled spend.

We match your first $100 in credit purchases, dollar for dollar. Maximum $100 in matching credit per account. The offer applies to eligible accounts; Billing shows your remaining match.

With the full match available: $10 purchase → $20 credits. $100 purchase → $200 credits. A partially used cap adds only the matching credit remaining.

  • New matching offers have a lifetime maximum of $100 per account across eligible purchases. Billing shows the offer and the matching credit left for your account.
  • Matching credit is promotional and shows as its own ledger entry.
  • Refunds and chargebacks reverse the matching credit. A partial refund reverses its proportional matching credit.
  • Adding a card without a purchase does not earn a bonus.
  • Existing trial and card-verification grants stay in the ledger. Those signup offers are no longer available.

Before an organization buys credit, its customer keys share the trial rate of 20 requests a minute. A purchase lifts that cap. Each key then has its own ceiling (300 for a console key). RouterPlus can also limit past trial credit when it detects unusual usage. Contact support if that happens. See Rate limits and spend caps.

Worked example

A claude-sonnet-4-5 request reports 1,200 prompt tokens (800 of them cache reads, no cache writes) and 350 completion tokens:

non-cached input:   400 × 3,000,000  = 1,200,000,000
cache reads:        800 ×   300,000  =   240,000,000
output:             350 × 15,000,000 = 5,250,000,000
                                       ─────────────
sum / 1,000,000 (floor)              = 6,690 micro-USD

usage.cost in the response is 0.00669. The attempt's cost_usd in GET /v1/usage & /v1/generation is the same number, from the same computation.

Worked example: an image

A gpt-image-2 request for two medium 1024×1024 images (n: 2) with a 12-token prompt estimate. Text in is $5 / M, image out is $30 / M, and the per-image ceiling is 8,232 tokens.

The reservation, before RouterPlus contacts a provider:

prompt estimate:  12 ×  5,000,000 =         60,000,000
output ceiling:   2 × 8,232 × 30,000,000 = 493,920,000,000
                                           ───────────────
ceil(sum / 1,000,000)                    = 493,980 micro-USD

The provider reports 12 input tokens and 3,512 output tokens (1,756 per image). Settlement:

input:            12 ×  5,000,000 =         60,000,000
output:        3,512 × 30,000,000 =    105,360,000,000
                                        ───────────────
floor(sum / 1,000,000)            =    105,420 micro-USD

usage.cost in the response is 0.10542. RouterPlus releases the hold in full, and you pay the settled amount.

For agents: /docs/pricing.md and /llms.txt