Verification Checklist

  • ✓When you call DeepSeek-R1 or another reasoning model, check the raw response body yourself — does it actually return a separate reasoning_content field alongside content, rather than assuming based on memory
  • ✓Does your billing/usage dashboard break out completion_tokens_details with a separate reasoning_tokens figure for the chain-of-thought, or does it only show one lumped-together output token total
  • ✓Have you ever estimated a call's cost only by eyeballing the length of the final visible answer, without accounting for the reasoning_content chain-of-thought — which is usually not shown in full and is often much longer
  • ✓If the official per-token price and your actual bill don't line up, have you confirmed whether reasoning tokens are being billed at the output rate too, instead of assuming the bill is simply wrong
  • ✓If the model or API exposes a setting to disable or dial down reasoning depth (such as a reasoning_effort parameter or a thinking toggle), have you evaluated turning it down for tasks that don't actually need multi-step reasoning, to control cost

1. The setup: DeepSeek-R1's response splits chain-of-thought and final answer into two fields

DeepSeek-R1, a "reasoning model," works differently from a regular chat model like deepseek-chat: before producing its official answer, it generates a fairly long intermediate reasoning process — what the official docs call chain-of-thought. In the API response structure, this shows up as its own field, reasoning_content, while the answer actually meant for the end user sits in a separate content field. In other words, a single request with reasoning/thinking enabled returns a message object containing two distinct chunks of content: how the model got there, and what it finally said. Developers who only surface the content field in their product UI — a common default, since chain-of-thought text is often long and not really formatted for end users — can easily overlook that reasoning_content is real, model-generated text too, and that has a direct bearing on whether it's billed.

2. The core question: is chain-of-thought billed as output, at the same rate?

That's the central question this article sets out to answer: is the reasoning_content chain-of-thought billed the same way as content, as output tokens? And if it is, is the rate identical to the final answer, or is there a separate price tier? Based on DeepSeek's current official API documentation, a reasoning model's output token count adds together both the chain-of-thought and the final answer, and both are billed at the same output rate — the chain-of-thought is not a free intermediate step; it's counted in full against this call's output usage. Worth flagging: this reflects the official position as verified at the time of writing. Billing details and field naming for LLM APIs change as models iterate (a later version could rename fields or change the billing model entirely), so treat this as a snapshot, not a permanent rule — always confirm against the current official API docs and your actual bill.

3. Checking your bill: the completion_tokens_details and reasoning_tokens fields

Knowing "chain-of-thought counts as output" only gets you so far — what actually helps when auditing a bill is knowing which field to check for the real numbers. In DeepSeek's official API docs, the usage object returned with each call includes the usual prompt_tokens (input token count), completion_tokens (total output token count), and total_tokens, plus a nested completion_tokens_details object that breaks down the output further — including a reasoning_tokens field that specifically counts how many tokens this call's chain-of-thought consumed. In other words, if you want to know how many tokens went into the reasoning versus the final answer for a specific call, you don't need to count characters yourself: check usage.completion_tokens_details.reasoning_tokens in that call's response, and subtract it from completion_tokens to get the tokens spent on the actual answer. Instead of staring at one lump output-token total on your monthly bill, check the usage details in the raw API response, or whether your platform's billing dashboard even surfaces this same breakdown — if it only shows a single combined figure, contact platform support directly to confirm.

4. The cost trap: chain-of-thought is usually far longer than the final answer

Here's a very concrete cost implication that trips up a lot of developers new to reasoning models: chain-of-thought text is typically much longer than the final answer. The model unpacks its reasoning step by step in the chain-of-thought — trying different approaches, self-correcting along the way — and that text often runs several times longer than the final answer, especially for math or coding tasks that require multi-step reasoning. If a developer habitually estimates a call's cost just by eyeballing the length of the final answer shown to the user — the text actually displayed in the UI — and mentally converting that to a token count, they'll badly underestimate the real usage, because the bulk of the cost usually sits in the reasoning_content portion that's never shown to the user and easy to leave out of any manual estimate. The more complex the task and the more reasoning steps it requires, the wider this gap between chain-of-thought and final-answer length tends to get, and the more that underestimate compounds.

5. What to actually do: audit your usage details, decide when full reasoning is worth it

Two practical habits help here. First, get in the habit of checking usage details rather than just a monthly total or a single lumped output-token figure — look at the usage object in the raw response, or the billing page, for a breakdown between reasoning_tokens and answer tokens, so you actually know where the cost is coming from on a given call. Second, if the platform or model exposes a way to control reasoning depth or turn chain-of-thought on or off (a reasoning_effort setting, or a thinking toggle), consider dialing it down or disabling it for simple tasks that don't really need an extended reasoning process — cutting token usage at the source rather than reacting after a surprising bill shows up. Exactly what that parameter is called, what values it accepts, and what the default is varies by model version, so check the official docs for the specific model version you're calling before you rely on it.

6. Takeaway: reasoning_content isn't a free intermediate step — it's the bulk of the bill

When you call DeepSeek-R1 or a similar reasoning model, reasoning_content (chain-of-thought) and content (final answer) are two distinct fields in the API response, but from a billing standpoint, the current official position bills both uniformly as output tokens, with no separate rate. The completion_tokens_details.reasoning_tokens field in your usage/billing data is the key place to check exactly how much the chain-of-thought itself consumed — far more useful than eyeballing a single lumped output-token total. More importantly, chain-of-thought is typically much longer than the final answer, so estimating cost from the visible answer alone will badly misjudge the real number. Field names, billing logic, and rates can all shift with future official updates, so check the current API docs and your actual usage details before and after you build against this, rather than relying on a fixed price sheet.