The Answer Is Short. Reasoning Still Bills.

1. Invisible reasoning bills as output

OpenAI’s reasoning guide describes reasoning tokens as the tokens a model spends breaking down a prompt and trying approaches. They are not visible through the API. They still occupy the context window, and they bill as output tokens. A short answer can therefore cost more than the words on screen. Responses puts the total in output_tokens and the detail in output_tokens_details.reasoning_tokens. Chat Completions calls the total completion_tokens and the detail completion_tokens_details.reasoning_tokens. The detail is inside the total. Adding the two columns bills the same reasoning twice.

This is not DeepSeek putting the chain of thought in reasoning_content. There you can read a text field, and that field bills as output. Here the raw reasoning is not returned. Persisted reasoning items stay opaque. A summary is opt-in through summary. auto selects the most detailed summarizer that model offers at the time. The summary lives in the reasoning item’s summary array, and it is omitted unless you ask. Leaving the summary off does not set reasoning_tokens to zero. Turning it on does not give you the raw chain, and the summary’s length is not a credit against the bill.

This column is also not the prompt-cache write premium. A cache write costs more because the prefix was stored. A hit is the discount. Reasoning tokens are output generated on this call, whether or not a cache breakpoint was placed well. Explicit cache storage is a third meter: that one can bill with no calls, by the hour. Reasoning output exists because generation happened. All three can sit on one monthly invoice. None of them explains the other two.

2. The cap covers generation, not the visible answer

The cost control is not “how many words the answer may contain.” On Responses, max_output_tokens limits every token the model generates, including reasoning, visible output, and non-visible formatting tokens. The token-counting guide says both caps cover non-visible tokens, there is no fixed gap between visible output and reported usage, and you should leave headroom. Chat Completions uses max_completion_tokens. The API reference defines it as the upper bound on visible output tokens and reasoning tokens. The older max_tokens parameter is deprecated, and it is not compatible with o-series models. Leaving it in the client is not an automatic ceiling on a reasoning model. That parameter is the wrong one.

If generation hits the context window or the max_output_tokens you set, status is incomplete and incomplete_details.reason is max_output_tokens. The docs say this can happen before any visible output tokens are produced. You can pay for input and reasoning and still have an empty answer. An empty answer is not a free call, and it is not the same event as a moderation cut. Moderation has its own fields. Here you read the cap and usage. OpenAI’s starting advice is to reserve at least 25,000 tokens for reasoning and outputs while you learn a workload, then tighten. That figure is a buffer, not a price, and not a universal default.

Setting the max low to “save money” saves the wrong thing. Too low, and the model spends the budget on reasoning, stops before the visible answer, and the tokens that were generated are still output-priced. Too high, and reasoning can run to tens of thousands of tokens beside a one-line answer. Reconcile the reasoning detail and the total in usage. Do not paste output_text into a local tokenizer and call that the bill.

3. A zero reasoning field can still outrun the text

The counting guide separates another gap. Some models, including GPT-5 models, emit tokens that format or delimit response channels, tool calls, and other message structure. Those tokens do not appear in message content or in logprobs, and they are not necessarily itemized in usage. Reported output or completion tokens can therefore exceed visible tokens, and exceed the tokens in logprobs, even when reasoning_tokens is 0.

That splits two misreads. The first is “the detail is zero, so this model did not reason, and the bill should match the answer’s length.” Formatting tokens can raise the total while the reasoning detail stays at zero. The second is “the detail is large, so everything above the answer is chain of thought.” The detail explains only the reasoning slice. Total minus detail is visible output plus formatting that was not listed on its own. It is not a transcript you can check word for word. A local tokenizer misses still more, because role markers and message boundaries in the request may never have been in the plain text you pasted.

reasoning.effort is not a valve that locks reasoning tokens to a number. It guides how much the model thinks. Supported values depend on the model and can include none, minimal, low, medium, high, xhigh, and max. Not every model has every value. Lower effort favors speed and fewer tokens. Higher effort thinks more completely. The model also adapts: simpler tasks use fewer tokens, harder ones use more. Defaults are model-dependent too. Do not copy one model’s medium onto the whole catalog. GPT-5.6 and GPT-6 also have reasoning.mode. standard is the default. pro is for harder tasks and can accept higher latency and more tokens. Mode and effort do not replace each other. When effort is omitted, the docs say GPT-5.6 defaults to medium in both modes. Switching mode to pro without reading usage is how a short answer sits next to a long reasoning detail.

4. Whether the next turn keeps reasoning depends on the model

Conversation state and reasoning state are different. Passing visible messages gives the model the chat. Persisted reasoning decides whether compatible reasoning items from earlier turns are rendered into the next sample. The docs split the default in two. The GPT-5.6 family supports all_turns and uses it by default. Earlier models default to current_turn. Omitting reasoning.context, or setting auto, uses that model’s default. The reasoning.context field on the response is the effective mode, either current_turn or all_turns. The setting does not invent reasoning items that are not already available.

current_turn makes this turn’s reasoning available and does not render earlier reasoning into the next sample. The docs say you can use it, when replaying older items, to reduce rendered context. That is carrying less. It is not a refund of the previous reasoning bill. all_turns renders available, compatible reasoning items, but only when the request can see them: previous_response_id, a conversation, or a manual replay of the full history. On the first request the two modes match, because no earlier reasoning exists. Pasting only the visible user and assistant text leaves the reasoning items out, so all_turns has nothing to render and the next turn thinks again. That new thinking is new output.

Reasoning can be reused only inside the same model family. The docs’ example is that GPT-5.6 models can reuse one another’s reasoning, and that it does not carry between the GPT-5.6 and GPT-5.5 families. When you switch families, incompatible reasoning is omitted from context even if reasoning.context is all_turns. The switch does not make reasoning free. It drops the previous chain, and this turn may generate another one. With store false, or Zero Data Retention on the organization, reasoning items include encrypted_content by default. To use all_turns without storage, keep every output item, including the encrypted reasoning and the assistant phase, append the next user message, and replay the whole history. Drop the encrypted field and the next turn has only the visible chat.

5. A top-up does not shrink reasoning already generated

Reconcile four columns. First, usage: the reasoning detail and the total, whether the call was Responses or Chat, and whether anyone added the detail on top of the total. Second, status and incomplete_details.reason. An empty answer is checked against the cap before it is checked against moderation. Third, reasoning.context on the response, and whether this request had previous_response_id or a full replay. Fourth, effort and mode. They guide how much is generated. They are not a hard ceiling, and pro can lengthen reasoning beside a short answer. Model names move. Use the model on this response and the reasoning guide, not a marketing name, in place of usage.

Funding the OpenAI account is a fifth ledger. Moving stablecoins on-chain into assets that can top up the account happens before that credit lands. It does not reduce reasoning tokens already generated, and it does not raise max_output_tokens on the call that already ran. When that funding step is what you need, AllSwap is a no-signup, non-custodial swap. A completed swap means the assets moved. Reasoning output beside a short answer still shows up in usage.