Reasoning tokens are the tokens a reasoning model generates while it works through a problem, before it writes the answer you see. The API doesn't return them, but OpenAI bills them as output tokens at the model's output price and reports the count in each response's usage, under output_tokens_details.reasoning_tokens. A single request can use anywhere from a few hundred to tens of thousands, so a feature can cost several times more after a switch to a reasoning model or a higher effort setting, with the same number of requests.
What counts as a reasoning token
A reasoning model works through the problem in tokens of its own before it answers. They aren't in the response text, and the API doesn't expose the raw reasoning, although you can ask for a summary of it with the summary setting of the reasoning parameter. In the Responses API, reasoning appears in the output as opaque items with encrypted content.
How many reasoning tokens a request uses depends on how hard the problem is and on the reasoning effort setting. OpenAI's reasoning guide lists effort values from none and minimal up through low, medium, high, xhigh and max, and which ones a model accepts varies. If you leave the setting out, models such as GPT-6.1 Sol default to medium.
How reasoning tokens are billed
Reasoning tokens are billed as output tokens. On the current models we checked in OpenAI's November 2026 price list, output costs five to eight times as much as input. For example, gpt-6.1-sol is $2.00 per million input tokens and $10.00 per million output tokens, and gpt-5-mini is $0.25 and $2.00. Check the pricing page for current prices.
Reasoning tokens also take up room in the context window, and they're included in output_tokens, so the visible answer is output_tokens minus reasoning_tokens. In this example usage object from the Responses API, 1,024 of the 1,186 output tokens are reasoning:
"usage": {
"input_tokens": 75,
"output_tokens": 1186,
"output_tokens_details": { "reasoning_tokens": 1024 },
"total_tokens": 1261
}Chat Completions reports the same count as completion_tokens_details.reasoning_tokens.
How much reasoning adds to a feature's cost
Take an example support reply with 1,500 input tokens and a 300-token visible answer, at gpt-6.1-sol's list prices of $2.00 per million input tokens and $10.00 per million output tokens.
| Scenario | Reasoning tokens | Billed output tokens | Cost per reply | 100,000 replies |
|---|---|---|---|---|
| No reasoning, for comparison | 0 | 300 | $0.006 | $600 |
| Moderate reasoning | 1,500 | 1,800 | $0.021 | $2,100 |
| Heavy reasoning | 4,000 | 4,300 | $0.046 | $4,600 |
List prices as of November 2026. Token counts are illustrative, so check your own requests and the current pricing page.
The input and the visible answer are the same in every row. Only the reasoning changed, and it took the cost of 100,000 replies from $600 to $4,600. On a daily spend chart, a change like this shows up as a jump on the day of the switch while request counts stay flat.
Reasoning and the output token limit
max_output_tokens caps everything the model generates, reasoning included. If a request reaches the cap while the model is still reasoning, the response comes back with status set to incomplete and incomplete_details.reason set to max_output_tokens, possibly with no visible answer at all. You still pay for the input and the reasoning tokens. OpenAI suggests reserving at least 25,000 tokens for reasoning and output when you start experimenting, then adjusting once you know what your requests use.
How to tell if reasoning is behind a cost increase
- Find the day spend rose and group that project's usage by model. A reasoning model that first appears that day is the first clue. Our checklist for finding out why an OpenAI API bill is high covers this step in more detail.
- Divide
output_tokensbynum_model_requestsin the Usage API for that project and model, before and after. The Usage API doesn't report reasoning tokens separately, but if output per request jumped and the answers aren't any longer, the difference is reasoning. - Log
reasoning_tokensfrom a sample of responses to confirm it. - Check the effort setting in your code and in any library you use. A default that changed in a library or a config file can raise effort for every request.
How to keep reasoning costs under control
Match the effort setting to the task. Classification, extraction and short replies often work well at low effort, so test lower settings against your own quality checks before you assume a task needs more. Send simple requests to a smaller model, and keep the higher settings for requests that need them. Set max_output_tokens with enough room for reasoning, as described above. When you estimate a new feature, include reasoning tokens in the output side of the sum, as in our guide to estimating what an AI app will cost to run.
OpenAI projects can also allow or deny specific models, so moving a feature onto a pricier model takes a deliberate change to the project's settings. Our post on organizing OpenAI projects and API keys covers how to set that up.
Common questions
Are OpenAI reasoning tokens billed as input or output?
As output. They're charged at the model's output token price, and they're included in output_tokens in the response's usage.
Can I see a model's reasoning tokens?
You can't see the raw tokens. The API tells you how many there were in reasoning_tokens, and you can request a summary of the reasoning with the summary setting in the reasoning parameter.
Do reasoning tokens count toward the context window?
Yes. They take up space in the request's context window along with the input and the visible output, and they count against max_output_tokens.
Why did a reasoning model return an empty response?
Most likely the request hit max_output_tokens while the model was still reasoning. The response has the status incomplete with the reason max_output_tokens, and the input and reasoning tokens are still billed. Raise the limit or lower the effort setting.
Where Braid fits
In OpenAI's data, a switch to a reasoning model shows up as a change in a project's cost and in the models it uses. Braid maps your OpenAI projects and keys to the use cases your company names, each with an owner and the models it's expected to use, and its Monday report shows what changed in each one's spend.
Braid never reads prompts or responses, so it doesn't see reasoning tokens per request. For that, log the usage object yourself. The beta currently supports OpenAI API accounts.