Reasoning tokens: the invisible line on your LLM bill

Updated August 20, 2026.

Price tables quote dollars per million output tokens. What they don't say is how many output tokens a reasoning model will decide to generate before it starts writing the answer you actually see. That gap — billed but invisible — is now one of the most common sources of "why is the bill 4x the estimate?"

The billing rule: thinking is output#

Every major provider bills internal reasoning at the output-token rate:

• OpenAI counts reasoning inside completion_tokens, with the share reported in completion_tokens_details.reasoning_tokens.
• Google states it on the price page: output prices "include thinking tokens"; the count arrives as thoughtsTokenCount.
• Anthropic bills extended thinking as output; the response usage carries a thinking-token detail.
• DeepSeek prices thinking and non-thinking modes identically per token — but the thinking mode emits more tokens.

Output is already the expensive direction (3–6x input). Reasoning multiplies the quantity of it.

Why estimates miss#

Consider a support-bot reply that reads as ~300 tokens. On a reasoning model with a hard problem in front of it, the model may generate several thousand thinking tokens first. The visible answer is unchanged; the billed output is 5–15x larger. Two properties make this hard to budget:

1. It varies per request. The same prompt template spends differently depending on how hard each instance happens to be.
2. It varies with settings. Reasoning-effort parameters (minimal → xhigh at OpenAI, adaptive thinking at Anthropic, configurable reasoning on Grok 4.6) change token spend materially — often more than switching models would.

How to see it in your usage data#

The counts are in every response's usage object — most teams just never look:

Log them per request, and "reasoning share of spend" becomes a metric you can watch. When a prompt change or an effort-setting change doubles it, you find out the day it happens — not when the invoice arrives.

Controlling it#

• Match effort to the task. Low-stakes classification does not need high reasoning effort. The cheapest fix in the reasoning era is a per-feature effort setting.
• Route by difficulty. Send easy traffic to non-reasoning tiers (GPT-5.6 Luna, Haiku 4.5, Gemini 3.5 Flash-Lite) and reserve reasoning models for requests that earn it.
• Cap output. Max-token limits bound worst-case thinking spend on APIs that count thinking toward the cap.

Track it per call, not per invoice#

Reasoning spend is invisible precisely because it hides inside aggregate output numbers. Tracking each call's full usage object — which is what Marginal's track() does — keeps the real cost per request, per feature, per customer, computed from the tokens the provider actually reported.

See current prices for reasoning models or estimate a workload with the calculator.

List prices are the easy part.

Marginal tracks what you actually spend — every LLM call priced at that day's rates and sliced by customer, feature, or any field you define. Integration is one track() call.

Start trackingRead the docs