Reasoning

Some hosted models support extended thinking. The model generates reasoning tokens before its final answer and returns them in reasoning_content, separate from the final content.

Supported models

Model	Slug	Reasoning
DeepSeek V4 Pro 0813	`deepseek-ai/DeepSeek-V4-Pro-0813`	Enabled by default
DeepSeek V4 Flash 0731	`deepseek-ai/DeepSeek-V4-Flash-0731`	Enabled by default
DeepSeek V4.1 Flash	`deepseek-ai/DeepSeek-V4.1-Flash`	Enabled by default
DeepSeek V4.1 Flash Fast	`deepseek-ai/DeepSeek-V4.1-Flash-Fast`	Enabled by default
OpenAI GPT 120B	`openai/gpt-oss-120b`	Enabled by default
Kimi K3	`moonshotai/Kimi-K3`	Enabled by default
Muse Spark Open	`meta-models/muse-spark-open`	Always enabled
GLM 5.2	`zai-org/GLM-5.2`	Opt-in through `chat_template_args`
GLM 5.2 Fast	`zai-org/GLM-5.2-Fast`	Enabled by default
GLM 5.3	`zai-org/GLM-5.3`	Enabled by default
GLM 5.3 Fast	`zai-org/GLM-5.3-Fast`	Enabled by default
GLM 5.3 Flash	`zai-org/GLM-5.3-Flash`	Enabled by default
Nemotron 3.5 Super VL	`nvidia/NVIDIA-Nemotron-3.5-Super-VL-120B-A12B`	Opt-in through `reasoning_effort`
Nemotron Ultra	`nvidia/NVIDIA-Nemotron-3-Ultra-550B-A55B`	Opt-in through `chat_template_args`

Models not listed here don’t support reasoning.

Enable thinking

For GLM 5.2 and Nemotron Ultra, enable thinking by passing chat_template_args. For Nemotron 3.5 Super VL, set reasoning_effort to high.

Python
JavaScript
cURL

Pass chat_template_args through extra_body since it extends the standard OpenAI API:

enable_thinking.py

response = client.chat.completions.create(
    model="zai-org/GLM-5.2",
    messages=[{"role": "user", "content": "What is the sum of the first 100 prime numbers?"}],
    extra_body={"chat_template_args": {"enable_thinking": True}},
    max_tokens=4096,
    stream=True,
)

Include chat_template_args directly in the request options:

enable_thinking.js

const response = await client.chat.completions.create({
    model: "zai-org/GLM-5.2",
    messages: [{ role: "user", content: "What is the sum of the first 100 prime numbers?" }],
    chat_template_args: { enable_thinking: true },
    max_tokens: 4096,
    stream: true,
});

Include chat_template_args in the JSON request body:

Request

curl https://inference.baseten.co/v1/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $BASETEN_API_KEY" \
  -d '{
    "model": "zai-org/GLM-5.2",
    "messages": [{"role": "user", "content": "What is the sum of the first 100 prime numbers?"}],
    "chat_template_args": {"enable_thinking": true},
    "max_tokens": 4096,
    "stream": false
  }'

Control reasoning depth

Set the top-level reasoning_effort parameter to control how much reasoning a supported model performs. Only the models in this table apply the parameter.

Model	Supported values
DeepSeek V4 Pro 0813	`none`, `low`, `high`, `max`
DeepSeek V4 Flash 0731	`none`, `minimal`, `low`, `medium`, `high` (default), `xhigh`, `max`
DeepSeek V4.1 Flash	`none`, `high` (default), `max`
DeepSeek V4.1 Flash Fast	`none`, `high` (default), `max`
Kimi K3	`none`, `low`, `high`, `max` (default)
Muse Spark Open	`low`, `medium`, `high`, `xhigh` (default)
OpenAI GPT 120B	`none`, `minimal`, `low`, `medium` (default), `high`, `xhigh`, `max`
GLM 5.2	`none`, `low`, `high`, `max`
GLM 5.2 Fast	`none`, `low`, `high`, `max`
GLM 5.3	`none`, `low`, `high` (default), `max`
GLM 5.3 Fast	`none`, `low`, `high` (default), `max`
GLM 5.3 Flash	`none`, `low`, `high` (default), `max`
Nemotron 3.5 Super VL	`none` (default), `minimal`, `low`, `medium`, `high`, `xhigh`, `max`
Nemotron Ultra	`none`, `high`

Nemotron 3.5 Super VL defaults to non-thinking responses. Set reasoning_effort to high to enable reasoning, or none to turn it off. The other accepted values also enable reasoning. Setting only chat_template_args.enable_thinking: true returns HTTP 400; use reasoning_effort instead. Muse Spark Open always reasons. none and minimal are accepted and run at low, the lightest level. Unknown values return HTTP 400. Use low or medium to reduce reasoning-token usage and latency compared with the xhigh default. Lower reasoning depths reduce reasoning-token usage and latency. Higher depths use more output tokens for reasoning. Accepted values can map to the same depth. On models that support a non-thinking mode, set reasoning_effort to none to request a direct answer. OpenAI GPT 120B can still return reasoning_content when you set reasoning_effort to none. On Nemotron Ultra, none disables reasoning and high enables it. DeepSeek V4.1 Flash and DeepSeek V4.1 Flash Fast do not support low; a request with low still reasons at the default depth, so use high, max, or none. Baseten treats reasoning_effort: "none" as low for GLM 5.3, GLM 5.3 Fast, and GLM 5.3 Flash. Setting none doesn’t disable reasoning. These models also accept chat_template_args.enable_thinking: false. Responses can include reasoning_content with either setting.

Python
JavaScript
cURL

Pass reasoning_effort through extra_body since it extends the standard OpenAI API:

reasoning_effort.py

from openai import OpenAI
import os

client = OpenAI(
    base_url="https://inference.baseten.co/v1",
    api_key=os.environ["BASETEN_API_KEY"],
)

response = client.chat.completions.create(
    model="deepseek-ai/DeepSeek-V4-Flash-0731",
    messages=[{"role": "user", "content": "What is the sum of the first 100 prime numbers?"}],
    extra_body={"reasoning_effort": "high"},
)

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

Include reasoning_effort directly in the request options:

reasoning_effort.js

import OpenAI from "openai";

const client = new OpenAI({
    baseURL: "https://inference.baseten.co/v1",
    apiKey: process.env.BASETEN_API_KEY,
});

const response = await client.chat.completions.create({
    model: "deepseek-ai/DeepSeek-V4-Flash-0731",
    messages: [{ role: "user", content: "What is the sum of the first 100 prime numbers?" }],
    reasoning_effort: "high",
});

console.log(response.choices[0].message.content);

Include reasoning_effort in the JSON request body:

Request

curl https://inference.baseten.co/v1/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $BASETEN_API_KEY" \
  -d '{
    "model": "deepseek-ai/DeepSeek-V4-Flash-0731",
    "messages": [{"role": "user", "content": "What is the sum of the first 100 prime numbers?"}],
    "reasoning_effort": "high"
  }'

Use reasoning for mathematical calculations, multi-step logic, code generation with complex requirements, and analysis that requires several intermediate steps. For simple questions or text generation, reasoning adds latency and output tokens. Use a model without reasoning support or set reasoning_effort to low.

Parse the response

The message object returns reasoning in reasoning_content and the final answer in content.

Python
JavaScript
cURL

Read reasoning_content and content directly off the message object:

parse_reasoning.py

from openai import OpenAI
import os

client = OpenAI(
    base_url="https://inference.baseten.co/v1",
    api_key=os.environ["BASETEN_API_KEY"],
)

response = client.chat.completions.create(
    model="zai-org/GLM-5.2",
    messages=[{"role": "user", "content": "Is 91 a prime number? Answer in one sentence."}],
    extra_body={"chat_template_args": {"enable_thinking": True}},
)

message = response.choices[0].message
print("Reasoning:", message.reasoning_content)
print("Answer:", message.content)

Read reasoning_content and content from the returned message:

parse_reasoning.js

import OpenAI from "openai";

const client = new OpenAI({
    baseURL: "https://inference.baseten.co/v1",
    apiKey: process.env.BASETEN_API_KEY,
});

const response = await client.chat.completions.create({
    model: "zai-org/GLM-5.2",
    messages: [{ role: "user", content: "Is 91 a prime number? Answer in one sentence." }],
    chat_template_args: { enable_thinking: true },
});

const message = response.choices[0].message;
console.log("Reasoning:", message.reasoning_content);
console.log("Answer:", message.content);

Pipe the response through jq to extract each field:

Request

curl https://inference.baseten.co/v1/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $BASETEN_API_KEY" \
  -d '{
    "model": "zai-org/GLM-5.2",
    "messages": [{"role": "user", "content": "Is 91 a prime number? Answer in one sentence."}],
    "chat_template_args": {"enable_thinking": true}
  }' | jq '.choices[0].message | {reasoning: .reasoning_content, answer: .content}'

The response body contains both fields on the assistant message:

Response

{
  "choices": [
    {
      "message": {
        "role": "assistant",
        "reasoning_content": "The user is asking whether 91 is a prime number... 91 = 7 × 13, so it is not prime...",
        "content": "No, 91 is not a prime number because it can be factored as $7 \\times 13$."
      }
    }
  ],
  "usage": {
    "prompt_tokens": 21,
    "completion_tokens": 203,
    "total_tokens": 224
  }
}

Baseten includes reasoning tokens in completion_tokens and counts them toward your total usage and billing.

Set a reasoning token budget

max_tokens caps the whole completion, reasoning tokens included. reasoning.max_tokens caps reasoning tokens alone: once the model has generated that many reasoning tokens, it stops thinking and spends the rest of max_tokens on its final answer. Set max_tokens above the reasoning budget so the model has room to answer. DeepSeek V4 Flash 0731 enforces reasoning.max_tokens; other reasoning models ignore it. On DeepSeek V4 Flash 0731, reasoning stops at 4,096 tokens by default, including at reasoning_effort: max. Raise the budget when a hard problem needs more thinking room:

Python
JavaScript
cURL

Pass reasoning through extra_body since it extends the standard OpenAI API:

reasoning_budget.py

from openai import OpenAI
import os

client = OpenAI(
    base_url="https://inference.baseten.co/v1",
    api_key=os.environ["BASETEN_API_KEY"],
)

response = client.chat.completions.create(
    model="deepseek-ai/DeepSeek-V4-Flash-0731",
    messages=[{"role": "user", "content": "What is the sum of the first 100 prime numbers?"}],
    extra_body={"reasoning": {"max_tokens": 20000}},
    max_tokens=24000,
)

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

Include reasoning directly in the request options:

reasoning_budget.js

import OpenAI from "openai";

const client = new OpenAI({
    baseURL: "https://inference.baseten.co/v1",
    apiKey: process.env.BASETEN_API_KEY,
});

const response = await client.chat.completions.create({
    model: "deepseek-ai/DeepSeek-V4-Flash-0731",
    messages: [{ role: "user", content: "What is the sum of the first 100 prime numbers?" }],
    reasoning: { max_tokens: 20000 },
    max_tokens: 24000,
});

console.log(response.choices[0].message.content);

Include reasoning in the JSON request body:

Request

curl https://inference.baseten.co/v1/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $BASETEN_API_KEY" \
  -d '{
    "model": "deepseek-ai/DeepSeek-V4-Flash-0731",
    "messages": [{"role": "user", "content": "What is the sum of the first 100 prime numbers?"}],
    "reasoning": {"max_tokens": 20000},
    "max_tokens": 24000
  }'

Get started

Model APIs

Inference

Training

Sandboxes

Development

Deployment

Engines

Model Labs

Organization

Hosting options

Observability

Troubleshooting

Supported models

Enable thinking

Control reasoning depth

Parse the response

Set a reasoning token budget

Next steps

Model APIs overview

Structured outputs

​Supported models

​Enable thinking

​Control reasoning depth

​Parse the response

​Set a reasoning token budget

​Next steps

Model APIs overview

Structured outputs

Supported models

Enable thinking

Control reasoning depth

Parse the response

Set a reasoning token budget

Next steps