Are Reasoning Tokens Billed? OpenAI, Claude, and Gemini Costs

Yes. OpenAI, Anthropic, and Google all bill reasoning tokens as output tokens, at the model's normal output rate. None of the three publishes a separate reasoning price. You pay for the reasoning the model actually generated on that request, not for the effort level or output cap you set, and hiding or summarizing the reasoning text does not make it cheaper.

What differs between providers is the usage report, not the rate:

• OpenAI and Claude already include reasoning in the output total (output_tokens, or completion_tokens in Chat Completions). The reasoning_tokens or thinking_tokens field is a breakdown of that total. Do not add it again.
• Gemini's native API reports the answer (candidatesTokenCount) and the thinking (thoughtsTokenCount) separately. Billed output is the sum of the two.

Because reasoning is paid at the output rate, it is usually the largest part of a reasoning-model bill. In the worked example below, a request with 2,000 input tokens and 5,000 reasoning tokens costs $0.064 on GPT-6 Sol, and $0.050 of that is reasoning. The fastest controls are a lower effort or thinking level, a cheaper model, or Batch pricing. A tight output cap can backfire: it can leave you paying for reasoning with no visible answer.

Prices in this guide are Standard rates as of September 25, 2026. Every dollar figure is a worked calculation from those published rates, not a measured invoice.

Where each API reports reasoning tokens

The first thing to settle is whether the reasoning count you see is already part of the output number you are billed for. The answer depends on the API format, not on how smart the model is.

If you are unsure which OpenAI endpoint your code uses, the field names tell you. Chat Completions vs Responses API covers the differences between the two endpoints.

OpenAI: reasoning_tokens is already inside output_tokens

OpenAI's reasoning guide says reasoning tokens are not visible through the API but "are billed as output tokens." Its own usage example shows how they are nested:

{
  "usage": {
    "input_tokens": 75,
    "output_tokens": 1186,
    "output_tokens_details": { "reasoning_tokens": 1024 },
    "total_tokens": 1261
  }
}

You are billed for 1,186 output tokens, of which 1,024 were reasoning. The check is 75 + 1,186 = 1,261. If your tracker computes 1,186 + 1,024 = 2,210, it is overstating output by 1,024 tokens.

The remaining 162 tokens are non-reasoning output, but they are not an exact count of the answer text. OpenAI's token counting guide notes that the output total also covers non-visible formatting tokens, so retokenizing the answer will not necessarily give you 162.

Claude: thinking_tokens is already inside output_tokens

Anthropic's thinking pricing notes say thinking is billed as output tokens and call usage.output_tokens "the inclusive, authoritative total used for billing." Their example reports 348 output tokens with thinking_tokens: 312, so the bill uses 348, not 660.

Two details matter for cost reviews:

• Billing is the same whether thinking is returned as a summary (display: "summarized") or hidden (display: "omitted"). You pay for the full thinking the model generated, and summaries cost nothing extra. The visible thinking text will never match the billed token count.
• thinking_tokens is a read-only breakdown and can be missing in older SDKs or through intermediaries. When it is missing, output_tokens is still the right number to bill.

Gemini: add thoughtsTokenCount to candidatesTokenCount

Gemini's native UsageMetadata works the other way. candidatesTokenCount counts the response candidates only, and thoughtsTokenCount counts the thinking. Google's pricing page labels its output column "Output price (including thinking tokens)", and the thinking guide states that response pricing is the sum of output tokens and thinking tokens.

Take this illustrative generateContent usage block:

{
  "promptTokenCount": 200,
  "candidatesTokenCount": 300,
  "thoughtsTokenCount": 900,
  "totalTokenCount": 1400
}

Billed output is 300 + 900 = 1,200 tokens. Three common mistakes produce three different wrong numbers:

• Using candidatesTokenCount alone misses the 900 thinking tokens.
• Treating totalTokenCount (1,400) as output charges the 200 prompt tokens at the output rate, because the total is prompt + thoughts + candidates.
• Adding thoughts to totalTokenCount counts them twice.

Two further notes. promptTokenCount includes cached content, so cached tokens need their own rate if you use context caching. The Interactions API uses snake_case names; Google's example there reports 62 input, 171 output, and 297 thought tokens for a total of 530, and you are billed for 171 + 297 output tokens.

If you call Gemini through Google's OpenAI-compatible endpoint, Google's documentation does not say whether completion_tokens there already includes thoughts. Look at the raw usage object from a real response before choosing a formula. The same applies to any gateway: its field names may look like OpenAI's while its arithmetic follows its own rules.

When the reasoning count is missing

A missing breakdown means something different in each format.

With OpenAI or Claude, a missing reasoning_tokens or thinking_tokens only means you lack the split. The inclusive output total is still correct, and you can bill from it. With native Gemini, a missing thoughtsTokenCount leaves the billed output unknown, because the thinking half of the sum is absent. Store it as unknown, not zero. If you run a Gemini model with thinking turned off and have confirmed that the field is omitted in that case, make "missing means zero" an explicit rule for that model only.

How much reasoning costs at current prices

Reasoning is charged at the output column of each price table. Output rates are several times higher than input rates on every model below, which is why long reasoning dominates the bill even when the visible answer is short.

Output prices that apply to reasoning

Standard rates in USD per 1M tokens, as of September 25, 2026, with the Gemini rows checked again on October 10, 2026 (OpenAI rows are for prompts up to 272K tokens; the Gemini rows are the Developer API paid tier):

Sources: OpenAI pricing, Claude pricing, Gemini API pricing. All three offer Batch processing at 50% off, and the discount applies to reasoning because reasoning is output. Rates change often, and several rows above carry promotions or end dates, so check the pricing page for the date of the requests you are reviewing. Cached input, OpenAI cache writes, longer prompts, Gemini's Priority tier, and cloud marketplaces such as Vertex AI or Amazon Bedrock all have their own rates. Gemini 3.5 Flash, listed at $1.50 / $9.00 on September 25, and 3.7 Flash were deprecated on October 8, 2026; Google routes their requests to 3.6 Flash and 3.8 Flash and no longer lists a price for the old IDs (release notes).

Worked example: 5,000 reasoning tokens behind a 1,000-token answer

Assume one request with 2,000 input tokens and 6,000 billed output tokens, of which 5,000 are reasoning. On Gemini that is candidatesTokenCount 1,000 plus thoughtsTokenCount 5,000. No caching.

cost = input_tokens × input_price / 1,000,000
     + output_tokens × output_price / 1,000,000   (output already includes reasoning)

Every model in this table prices output at five times input, so reasoning is about 78% of each total. The shape of the request, not the vendor, drives that share.

The same request tracked incorrectly:

• A GPT-6 Sol tracker that adds the 5,000 reasoning tokens to the inclusive output total reports $0.114 instead of $0.064.
• A Gemini 3.8 Flash tracker that uses candidatesTokenCount alone reports $0.00525 instead of $0.024.

Read this as arithmetic, not as a ranking of vendors. Different models use different tokenizers and reason for different lengths on the same task, so identical token counts across providers are an assumption. For per-task comparisons, see GPT-6 Luna vs. Sol pricing and Claude Opus 5.5 vs GPT-5.6 Sol: Same Price Tag, Different Bills.

Check one request from its usage object

This Python sketch reads a native usage object and returns the billed input and output tokens plus the reasoning part. A value of None means the field was missing, which is not the same as zero. It ignores cached-input rates, cache writes, Gemini tool-use prompt tokens, and long-context tiers, so treat the result as an estimate to compare with your provider's usage page.

def billed_tokens(api, usage):
    """Return (input, billed_output, reasoning). None means unknown."""
    def get(obj, *path):
        for key in path:
            if not isinstance(obj, dict):
                return None
            obj = obj.get(key)
        return obj

    if api == "openai.responses":
        return (get(usage, "input_tokens"),
                get(usage, "output_tokens"),
                get(usage, "output_tokens_details", "reasoning_tokens"))
    if api == "openai.chat":
        return (get(usage, "prompt_tokens"),
                get(usage, "completion_tokens"),
                get(usage, "completion_tokens_details", "reasoning_tokens"))
    if api == "claude.messages":
        return (get(usage, "input_tokens"),
                get(usage, "output_tokens"),
                get(usage, "output_tokens_details", "thinking_tokens"))
    if api == "gemini.generateContent":
        candidates = get(usage, "candidatesTokenCount")
        thoughts = get(usage, "thoughtsTokenCount")
        output = None if candidates is None or thoughts is None else candidates + thoughts
        return (get(usage, "promptTokenCount"), output, thoughts)
    raise ValueError(f"Unknown API format: {api}")


def request_cost(tokens, input_price, output_price):
    """Prices in USD per 1M tokens. Returns None if any count is unknown."""
    input_tokens, output_tokens, _ = tokens
    if input_tokens is None or output_tokens is None:
        return None
    return (input_tokens * input_price + output_tokens * output_price) / 1_000_000


# OpenAI's documented example at GPT-6 Sol rates: 75 in, 1,186 out
print(request_cost(billed_tokens("openai.responses", {
    "input_tokens": 75,
    "output_tokens": 1186,
    "output_tokens_details": {"reasoning_tokens": 1024},
}), 2.00, 10.00))  # 0.01201

The function never adds reasoning to an inclusive total, and it only sums the two Gemini fields. Pass the API format explicitly rather than guessing it from the model name, because the same Gemini model returns different fields through generateContent, the Interactions API, and the OpenAI-compatible endpoint.

How to lower reasoning cost: reasoning effort and thinking level

You cannot buy reasoning at a discount separately from output, so cost control comes down to generating fewer reasoning tokens, paying a lower output rate, or both.

Lower the effort or thinking level. This is the main lever on all three platforms, and each one treats it as guidance rather than a guaranteed token count:

• OpenAI: reasoning.effort (Responses) or reasoning_effort (Chat Completions). Supported values depend on the model and range from none to max. GPT-6 Sol, GPT-6 Luna, and GPT-5.6 default to medium and accept none; GPT-6 Astra rejects none with an HTTP 400. OpenAI says lower effort favors speed and lower token usage. Setting reasoning.mode to pro does more work per answer, and that work is billed at the model's standard token rates.
• Claude: effort with low, medium, high, xhigh, or max. The default is high on most models and medium on Opus 5.5. Effort shapes all output, not only thinking. Opus 5.5 always thinks, while Sonnet 5 can turn thinking off. Manual budget_tokens is rejected on Claude 4.7 and later models. Changing effort between requests invalidates prompt-cache breakpoints, so pick a level per workload instead of switching it on every call. Claude Opus 5.5 Effort: Choose a Level, Set It, and Measure the Cost walks through measuring each level.
• Gemini: thinking_level on Gemini 3 and later (thinkingLevel in generateContent). Defaults are medium for Gemini 3.8 Flash and 3.6 Flash, minimal for 3.5 Flash-Lite, and high for 3.1 Pro Preview. Through the OpenAI-compatible endpoint, reasoning_effort maps to a thinking level, and thinking cannot be switched off for Gemini 3 models.

No provider publishes how many tokens each effort level uses, so measure on your own prompts. As a hypothetical, if lowering effort on GPT-6 Sol cut reasoning from 5,000 to 1,000 tokens on 1,000 requests a day, you would save 1,000 × 4,000 × $10 / 1,000,000 = $40 per day. Check answer quality on the same prompts before you keep the change.

Choose the model by task. Output prices in the table span a factor of 100 between GPT-6 Luna and GPT-6 Astra. For simple extraction or classification a smaller model at low effort often costs less than a larger one; for hard tasks a stronger model may need fewer retries. Gemini Text Models in 2026 and Gemini 3.8 Flash API Guide cover the Gemini choices, and Claude Opus 5.5: API Price, Model ID, and Migration Checks covers Anthropic's current flagship.

Use Batch for work that can wait. The 50% Batch discount applies to reasoning tokens as well as visible output.

Set an output cap for safety, not savings. A cap limits the worst case per request, but it does not make reasoning cheaper. The next section explains why a cap that is too tight costs money.

Hiding reasoning does not reduce the bill. Claude's omitted display, Gemini's thought summaries, and gateway options such as OpenRouter's reasoning.exclude only change what you see. The model still reasons, and the full reasoning is billed.

Why an empty or cut-off answer still costs money

Every output cap on these platforms covers reasoning and the answer together. If the model spends the cap on reasoning, you pay for the input and the reasoning, and you may get no visible answer.

Example on GPT-6 Sol: 2,000 input tokens and a max_output_tokens of 4,096 that is entirely spent on reasoning cost 2,000 × $2 / 1,000,000 + 4,096 × $10 / 1,000,000 ≈ $0.045, with nothing to show the user. If you retry with a larger cap and that call produces the full 6,000-token output from the worked example, the answer has cost about $0.109 in total, because the first attempt is still billed.

What each provider recommends instead:

• OpenAI suggests reserving at least 25,000 tokens for reasoning and output when you start experimenting, then tuning down once you know how much your prompts use.
• Anthropic suggests raising max_tokens if the truncated requests needed the reasoning, or lowering effort if they were over-thought.
• Google suggests lowering thinking_level rather than setting a small max_output_tokens.

In Claude tool-use loops, each request has its own max_tokens, so the cap does not bound the spend of a whole agent turn.

Your bill looks higher than expected: what to check

Work through one request that looks wrong before you look at the monthly total. Most surprises come from one of these causes, roughly in this order.

1. Your tracker adds reasoning to an inclusive total. This is a client-side bug, not a provider charging twice. The open-source agent library browser-use had exactly this problem: its issue #4065 describes reasoning_tokens being added to completion_tokens, which roughly doubled reported usage for reasoning models. It was closed on February 10, 2026. If your own dashboard shows about twice what the provider's usage page shows, check this first.

2. Gemini fields are combined the wrong way. Using candidates alone undercounts; treating totalTokenCount as output, or adding thoughts to it, overcounts.

3. Streaming events or retries are counted wrong. Anthropic's streaming guide says usage in message_delta events is cumulative, so take the last value or the SDK's final message rather than summing the events. On OpenAI Chat Completions with stream_options.include_usage, the usage arrives in one extra final chunk; if the stream is interrupted, that chunk may never arrive.

Keep one record per request that reached the provider, and update it as later usage arrives:

• Snapshots of 80 and then 140 output tokens for the same request mean 140, not 220.
• The same final event delivered twice by two log pipelines is still one request.
• A retry is a separate request, billed on its own usage, even if the prompt and answer are identical. Do not deduplicate by prompt text.
• A stream that ends without final usage leaves the amount unknown. The provider may still have billed the tokens generated before the interruption, so mark the record as pending and reconcile it against the provider's usage page instead of recording zero.

4. Earlier reasoning comes back as input on the next turn. On Claude models that keep thinking from earlier turns (Opus 4.5 and later, Sonnet 4.6 and later, Fable, and Mythos), earlier thinking blocks stay in context and are billed as input on later requests. That is new input spend on a new request, not a second charge for the old output. GPT-5.6 and later models render available reasoning from earlier turns into the next request by default (reasoning.context: all_turns). OpenAI's documentation does not spell out how that shows up in usage, so compare input_tokens across turns if long conversations look expensive.

5. The rate is not the one you assumed. Confirm the model that actually served the request (since October 8, 2026, calls to the deprecated gemini-3.5-flash and gemini-3.7-flash are served by gemini-3.6-flash and gemini-3.8-flash, and Google doesn't say which SKU they are billed under), the service tier, whether a promotional price had ended, whether the prompt crossed a long-context threshold, and whether cached input or cache writes apply. Prices on cloud marketplaces differ from the direct APIs.

6. A gateway reshaped the usage. Gateways and SDK wrappers can rename, drop, or recombine fields. OpenRouter, for example, documents that reasoning counts as output and that excluded reasoning is still billed, but its reasoning.max_tokens share rules are its own. Read the raw usage your gateway returns and its documentation before reusing a formula from this page.

Quick answers

Am I charged for the effort level or cap I set, or for what the model actually used? For what it used. Effort is guidance, and max_output_tokens or max_tokens is only an upper limit. Neither is a prepaid allocation. You pay for the reasoning and answer tokens reported in the response's usage.

Is there a separate, cheaper rate for reasoning tokens? No. OpenAI, Anthropic, and Google charge reasoning at the model's regular output rate. The only discounts that reach reasoning are the ones that apply to all output, such as Batch.

Do reasoning tokens use up the context window? Yes. OpenAI notes that reasoning tokens occupy context window space even though you never see them, and every provider counts them against the output cap.

If I only see a short answer, why is output usage so high? Because most of the output was reasoning you did not see. Compare the reasoning field (or thoughtsTokenCount on Gemini) with the output total. If reasoning accounts for most of it on simple prompts, a lower effort or thinking level is the first thing to test.