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:
curl -s https://app.routerplus.com/api/models.json \
| jq '.models[] | select(.id == "claude-sonnet-4-5").pricing_usd_per_million'{
"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.
| SKU | What it bills | Example (claude-sonnet-4-5) |
|---|---|---|
prompt | Non-cached input tokens | $3 / M |
cached_prompt | Prompt-cache reads | $0.30 / M |
cache_write | Prompt-cache writes | $3.75 / M |
completion | Output tokens, including reasoning unless a distinct rate is declared | $15 / M |
internal_reasoning | The reasoning part of output, when a provider declares a distinct rate | (none) |
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 id | Text in /1M | Image out /1M | Per-image ceiling |
|---|---|---|---|
gpt-image-2 | $5 | $30 | 8,232 tokens |
gpt-image-2.5-flare | $5 | $30 | 8,232 tokens |
gpt-image-2.5-sunburst | $5 | $30 | 8,232 tokens |
gpt-image-1.5 (until 2026-12-01) | $5 | $32 | 6,500 tokens |
gpt-image-1-mini (until 2026-12-01) | $2 | $8 | 6,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 3 | Price |
|---|---|
| 1K image | $0.03 |
| 2K image | $0.06 |
high thinking | adds $0.02 |
| Each reference up to 1,048,576 pixels | adds $0.02 |
| Each larger reference, or a reference sent as a URL | adds $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:
| Provider | Where the reported cost comes from |
|---|---|
| Recraft | Recraft's own figure for the request: its credits, $0.001 each |
| Replicate | Replicate reports no cost, so it is worked out from Replicate's published price for what was rendered |
| Krea | Krea reports no cost, so the gateway works out Krea's published price from the request and the images it measured |
| MachGen | MachGen'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.jsonshow 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 id | Input /1M | Cached /1M | Output /1M | What the token counts are |
|---|---|---|---|---|
typesafe/jev-1.13 | $0.042 | – | $0 | The provider's input count |
bespokelabs/nimble-v4 | $0.04 | – | $0 | The provider's input count |
bespokelabs/nimble-v4-max | $0.09 | – | $0 | The provider's input count |
cloudflare/clef | $0.24 | – | $0 | The provider's input count |
cloudflare/clef-flash | $0.09 | – | $0 | The provider's input count |
routerplus/decider-2b | $0 | $0 | $0 | The provider's input count; an answer from its cache bills $0 |
routerplus/kev-4b | $0 | $0 | $0 | The provider's input count; an answer from its cache bills $0 |
perplexity/pplx-decider-v1-27b | $0.04 | – | $0 | The provider's input count, which holds the state once per question |
perplexity/pplx-decider-v1.3 | $0.02 | – | $0 | The 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 | – | $0 | The provider's input count: the state once, and about 150 tokens for each question |
levanto/sage-1.2 | $0.05 | – | $0 | The provider's input count, which holds the state once per question |
scaledown/classify-1 | $0.05 | – | $0 | The provider's input count, summed over its questions (each one is a call) |
fastino/gliner-2.5-decide | $0.03 | – | $0 | Fastino'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-latestis in no list. It bills at $0.04 per million input tokens, Bespoke's price fornimble-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.costis0on 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_tokensis Fastino'sprompt_tokens.usage.output_tokensis itscompletion_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:
| Where | What it shows |
|---|---|
usage.cost | What you paid, after the discount |
usage.cost_before_discount | The charge at the list price |
usage.discount_percent and the x-tm-discount-percent header | The percent taken off |
cost_usd in GET /v1/generation | What you paid, after the discount |
inference_cost_usd in GET /v1/generation | The 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.costis 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:
- 01Reserve. 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(ormax_completion_tokens, ormax_output_tokenson 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/responsesthe 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_usessearches (at most 20), or for 5 when it sets none (see Web search). - Images: on
/v1/images/generations, the output is reserved atn× the model's per-image ceiling (notmax_tokens), and the input at the prompt bytes ÷ 4.
- 02Dispatch. The request goes to a provider. Prices are pinned at this moment (see Price changes).
- 03Settle. 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).
- 04Release. 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_crashin 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
| Cause | Refusal |
|---|---|
| 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_deltausage at stream end.
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{
"prompt_tokens": 1200,
"completion_tokens": 350,
"total_tokens": 1550,
"prompt_tokens_details": { "cached_tokens": 800, "cache_write_tokens": 0 },
"cost": 0.00669
}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 USDimport 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"])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: falsechanges 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:
| Concept | OpenAI surface | Anthropic surface | Billed at |
|---|---|---|---|
| Non-cached input | prompt_tokens minus the two details below | input_tokens | prompt |
| Cache reads | prompt_tokens_details.cached_tokens | cache_read_input_tokens | cached_prompt |
| Cache writes | prompt_tokens_details.cache_write_tokens | cache_creation_input_tokens | cache_write |
| Output | completion_tokens | output_tokens | completion |
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-cacheresponse header says whether automatic caching applied. - The request header
x-tm-auto-cache: offturns it off. - Wire compatibility has the rules.
Web search
RouterPlus bills a web search that the provider runs for the model at the provider's price per search, plus the tokens:
| Tool | Where | Price |
|---|---|---|
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 tool | Claude models on POST /v1/messages | No fee: only the tokens of the fetched page |
OpenAI's hosted web_search tool | OpenAI models on POST /v1/responses | $10 per 1,000 calls |
OpenAI's older web_search_preview tool | GPT-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 ofcost_usdin GET /v1/usage & /v1/generation. There, each attempt also showsserver_tool_use(web_search_requests,web_fetch_requests) andserver_tool_fee_usd. On/v1/messages, the answer'susage.server_tool_use.web_search_requestsalso gives the number of searches. - While the request runs, the hold includes the fee for each web search tool's
max_usessearches (at most 20), or for 5 searches when the tool sets nomax_uses. A tool of your own namedweb_searchholds 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
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
turboorfastmode, with up to 10 results; $5 per 1,000 searches ($0.005 a search) inbasicoradvancedmode; - 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
fastmode, $5 per 1,000 calls ($0.005 a call) inadvancedmode, with up to 20 results; - decisions: $1 per 1,000 calls ($0.001 a call), for up to
max_questionsquestions, 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
basicoradvancedmode. 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.cost0,usage.cost_before_discount0.001 andusage.discount_percent100.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. Modelparallel: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.
Paid credits and purchase matching
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-USDusage.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-USDThe 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-USDusage.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