DeepSeek Thinking Mode: How It Works and How to Use It

Last verified: October 3, 2026

DeepSeek Thinking Mode is the reasoning mode in DeepSeek’s API. When it is enabled, the model can generate reasoning before returning the final answer. In the API response, that reasoning is returned separately as reasoning_content, while the final user-facing answer is returned as content.

The most important implementation detail is that Thinking Mode is currently enabled by default, with the default reasoning effort set to high. You can explicitly enable it, disable it, or choose an effort level such as low, high, or max. DeepSeek documents this behavior in its Thinking Mode guide and Chat Completions API reference.

Thinking Mode is useful for complex reasoning, coding, debugging, agents, and multi-step technical work. It is not always the best production default. For simple Q&A, fast classification, short extraction, or strict formatting, non-thinking mode can be faster and easier to control.

Quick answer: is DeepSeek Thinking Mode enabled by default?

Yes. DeepSeek’s current API documentation says Thinking Mode is enabled by default, and the default effort is high. In OpenAI-compatible Chat Completions, you can control it with the thinking object and reasoning_effort.

The safe production approach is to set the mode intentionally instead of relying on defaults. That makes your code easier to audit when DeepSeek changes model behavior or when different teams reuse the same API wrapper.

Current model names for Thinking Mode

DeepSeek’s current Chat Completions API reference lists deepseek-flash and deepseek-v4-pro as the model IDs to use. The Models & Pricing page says both support non-thinking and thinking modes, with thinking as the default. DeepSeek Models & Pricing

Older tutorials may use deepseek-reasoner or deepseek-chat. DeepSeek’s changelog says those legacy names were scheduled for discontinuation in 2026, and the current Chat Completions reference no longer lists them as the model IDs to use. For new code, use the current documented model names. DeepSeek Change Log

How to enable DeepSeek Thinking Mode in Python

The following examples use the OpenAI Python SDK with DeepSeek’s OpenAI-compatible endpoint. Keep your API key in an environment variable, not in source code.

pip install openai

On macOS or Linux:

export DEEPSEEK_API_KEY="your-api-key"

On Windows PowerShell:

$env:DEEPSEEK_API_KEY="your-api-key"

Then enable Thinking Mode explicitly:

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["DEEPSEEK_API_KEY"],
    base_url="https://api.deepseek.com",
)

response = client.chat.completions.create(
    model="deepseek-flash",
    messages=[
        {
            "role": "user",
            "content": "Explain why database indexes can speed up reads but slow down writes."
        }
    ],
    reasoning_effort="high",
    extra_body={
        "thinking": {
            "type": "enabled"
        }
    },
)

message = response.choices[0].message

reasoning = getattr(message, "reasoning_content", None)
answer = message.content

print("REASONING:")
print(reasoning)

print("\nFINAL ANSWER:")
print(answer)

The important part is that reasoning_content and content are different fields. Your application can inspect, store, suppress, or display them separately depending on your product design.

How to disable DeepSeek Thinking Mode

Use non-thinking mode when you want a shorter, faster, or more formatting-sensitive response. For example, classification, simple extraction, short summaries, and deterministic formatting often do not need reasoning mode.

response = client.chat.completions.create(
    model="deepseek-flash",
    messages=[
        {
            "role": "user",
            "content": "Classify this ticket as billing, technical, or account: I cannot reset my password."
        }
    ],
    extra_body={
        "thinking": {
            "type": "disabled"
        }
    },
)

print(response.choices[0].message.content)

You can also disable Thinking Mode with reasoning_effort="none", according to DeepSeek’s Chat Completions reference. In production code, avoid sending conflicting controls such as thinking: enabled and reasoning_effort: none in the same request.

response = client.chat.completions.create(
    model="deepseek-flash",
    messages=[
        {"role": "user", "content": "Return only the category: billing, technical, or account."}
    ],
    reasoning_effort="none",
)

print(response.choices[0].message.content)

How reasoning_effort works

reasoning_effort controls whether Thinking Mode is used and how much reasoning effort the model should apply. DeepSeek’s current docs list none, low, high, and max. The default effort is high.

DeepSeek’s Thinking Mode guide also documents compatibility aliases: minimal maps to low, medium and xhigh map to high, and ultra maps to max. For new code, use the canonical values none, low, high, and max.

Do not assume these levels correspond to fixed reasoning-token budgets. Treat them as API controls that change the model’s reasoning behavior, then measure latency, output length, cost, and answer quality on your own workload.

reasoning_content vs content

When Thinking Mode is enabled, DeepSeek returns two separate pieces of text:

Do not automatically display reasoning_content to end users. It can be long, implementation-specific, and unsuitable for every product experience. It may also contain sensitive prompt context if your application sends sensitive data, so avoid logging it unnecessarily.

For most applications, the final answer should come from message.content. Treat reasoning_content as a separate field that you handle deliberately.

Streaming DeepSeek Thinking Mode responses

When streaming is enabled, DeepSeek can stream reasoning and final answer deltas separately. The API schema includes delta.reasoning_content and delta.content. Do not mix them into one string unless your product intentionally wants that behavior.

stream = client.chat.completions.create(
    model="deepseek-flash",
    messages=[
        {
            "role": "user",
            "content": "Design a simple retry strategy for a Python API client."
        }
    ],
    stream=True,
    reasoning_effort="high",
    extra_body={
        "thinking": {
            "type": "enabled"
        }
    },
)

reasoning_parts = []
answer_parts = []

for chunk in stream:
    if not chunk.choices:
        continue

    delta = chunk.choices[0].delta

    reasoning_delta = getattr(delta, "reasoning_content", None)
    content_delta = getattr(delta, "content", None)

    if reasoning_delta:
        reasoning_parts.append(reasoning_delta)

    if content_delta:
        answer_parts.append(content_delta)
        print(content_delta, end="", flush=True)

print()

reasoning_text = "".join(reasoning_parts)
final_answer = "".join(answer_parts)

If you also need token usage in a streaming request, DeepSeek’s Chat Completions reference says the last chunk before data: [DONE] carries the token usage statistics. If stream_options.include_usage is true, every chunk includes a usage field, but it is null except on the final chunk.

Multi-turn conversations without tools

For normal multi-turn conversations without tools, DeepSeek says previous reasoning_content does not need to be passed back. If it is passed back in a request that does not carry tools, the API ignores it and does not concatenate it into the next context.

The simplest pattern is still to append the returned assistant message and continue the conversation. The important point is that non-tool conversations do not require you to manually preserve previous reasoning traces for correctness.

messages = [
    {"role": "user", "content": "Which is greater, 9.11 or 9.8?"}
]

first = client.chat.completions.create(
    model="deepseek-flash",
    messages=messages,
    reasoning_effort="high",
    extra_body={"thinking": {"type": "enabled"}},
)

messages.append(first.choices[0].message)

messages.append({
    "role": "user",
    "content": "Now explain the comparison in one sentence."
})

second = client.chat.completions.create(
    model="deepseek-flash",
    messages=messages,
    reasoning_effort="high",
    extra_body={"thinking": {"type": "enabled"}},
)

print(second.choices[0].message.content)

Tool calls, reasoning history, and 400 errors

Thinking Mode behaves differently when the request includes tools. DeepSeek’s Thinking Mode guide says tool calls are supported, but for requests carrying tools, the reasoning_content from previous turns must be fully passed back in subsequent requests. If your code fails to pass it back correctly, the API can return a 400 error.

The safest implementation pattern is to append the full assistant message returned by the SDK, because it contains content, reasoning_content, and tool_calls.

# In a tool-enabled thinking workflow, preserve the full assistant message.
assistant_message = response.choices[0].message
messages.append(assistant_message)

Do not manually rebuild a partial assistant message unless you are sure you are preserving every field DeepSeek requires.

There is another common source of 400 errors: tool_choice="required" and forcing a named function are not supported in Thinking Mode. DeepSeek’s Chat Completions API reference says the API returns a 400 error for those combinations. If you need required or a named tool choice, disable Thinking Mode first.

response = client.chat.completions.create(
    model="deepseek-flash",
    messages=messages,
    tools=tools,
    tool_choice="required",
    extra_body={
        "thinking": {
            "type": "disabled"
        }
    },
)

Tool calls also require the normal security boundary: the model requests a function, but your application executes it. Allowlist tool names, parse and validate arguments, enforce user authorization, and return each tool result with the correct tool_call_id.

Parameters that behave differently in Thinking Mode

Several parameters behave differently when Thinking Mode is enabled. This is one reason generic OpenAI-compatible examples can produce surprising behavior when copied into DeepSeek integrations.

For JSON output, DeepSeek supports response_format={"type": "json_object"}, but the API reference also says you must instruct the model to produce JSON in the prompt. If your application needs strict predictable formatting, test both Thinking Mode and non-thinking mode with your exact schema and failure cases.

Thinking Mode vs non-thinking mode

Thinking Mode is a tool, not a universal upgrade. Use it when extra reasoning is worth the additional complexity. Disable it when speed, cost, or output predictability matters more than multi-step reasoning.

In production, choose based on measured outcomes: answer quality, latency, completion tokens, error rate, retry rate, and cost per successful task. A default that is excellent for coding agents may be inefficient for short support-ticket classification.

Common mistakes and fixes

Production checklist

• Set Thinking Mode explicitly instead of relying only on defaults.
• Choose reasoning_effort intentionally for each workload.
• Read reasoning_content separately from final content.
• Do not show reasoning traces to end users unless your product deliberately supports that experience.
• Do not log sensitive reasoning traces unnecessarily.
• Use non-thinking mode for simple, high-throughput, or formatting-sensitive tasks.
• Set explicit max_tokens when cost or response length needs to be predictable.
• Preserve full assistant messages when tools require reasoning history.
• Disable Thinking Mode before using tool_choice="required" or a named function.
• Do not expect temperature, presence_penalty, or frequency_penalty to control Thinking Mode output.
• Test latency, completion tokens, and answer quality before production rollout.
• Recheck DeepSeek model names and API behavior after documentation updates.

Frequently asked questions

What is DeepSeek Thinking Mode?

DeepSeek Thinking Mode is the API mode where the model generates reasoning before the final answer. The reasoning is returned in reasoning_content, while the final answer is returned in content.

Is DeepSeek Thinking Mode enabled by default?

Yes. DeepSeek’s current documentation says Thinking Mode is enabled by default and the default effort is high.

How do I turn off DeepSeek Thinking Mode?

Use extra_body={"thinking": {"type": "disabled"}} in an OpenAI-compatible Chat Completions request, or set reasoning_effort="none" according to the current API reference.

What is reasoning_effort?

reasoning_effort controls whether Thinking Mode is used and how much reasoning effort the model should apply. Current values are none, low, high, and max.

What is reasoning_content?

reasoning_content is the reasoning output returned by the model in Thinking Mode. It is separate from content, which is the final answer.

Is DeepSeek Thinking Mode the same as deepseek-reasoner?

No. deepseek-reasoner is a legacy model name used in older DeepSeek API versions and tutorials. Current DeepSeek API documentation lists deepseek-flash and deepseek-v4-pro as the model IDs to use.

Does DeepSeek Thinking Mode work with streaming?

Yes. Streaming chunks can include delta.reasoning_content for reasoning and delta.content for final answer text. Your stream parser should handle them separately.

Does DeepSeek Thinking Mode work with tool calls?

Yes. DeepSeek says Thinking Mode supports tool calls. However, tool-enabled thinking workflows require careful handling of reasoning_content across subsequent requests.

Why do I get a 400 error with tool calls?

Common causes include dropping required reasoning_content in a tool-enabled thinking workflow, using tool_choice="required" while Thinking Mode is enabled, or forcing a named function while Thinking Mode is enabled.

Does temperature work in DeepSeek Thinking Mode?

No. DeepSeek’s current documentation says temperature has no effect in Thinking Mode. It also says presence_penalty and frequency_penalty are not supported in Thinking Mode.

Should I use Thinking Mode for every request?

No. Use Thinking Mode for tasks that benefit from deeper reasoning, such as coding, debugging, complex planning, math, and agent workflows. Use non-thinking mode for simple, fast, high-throughput, or strict-format tasks.

Does Thinking Mode cost more?

It can increase token usage or latency because the model may generate reasoning before the final answer. Do not assume a fixed cost increase. Measure completion tokens, latency, and answer quality on your own workload.

Can I hide the reasoning from users?

Yes. Display only message.content to users and keep reasoning_content internal, or avoid storing it altogether if your product does not need it.

Bottom line

DeepSeek Thinking Mode is powerful, but it is not a setting to ignore. It is enabled by default, returns reasoning separately from the final answer, changes how several parameters behave, and has special rules when tools are involved.

Use Thinking Mode when deeper reasoning improves the result. Disable it for simple, fast, high-throughput, or strict-format tasks. In production, explicitly set the mode, track latency and token usage, separate reasoning_content from content, and preserve full assistant messages when using tool calls.

Official references

• DeepSeek Thinking Mode guide
• DeepSeek Chat Completions API reference
• DeepSeek Models & Pricing
• DeepSeek Tool Calls guide
• DeepSeek Change Log