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	`deepseek-ai/DeepSeek-V4-Pro`	Enabled by default
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
Inkling	`thinkingmachines/inkling`	Enabled by default
Inkling Small	`thinkingmachines/inkling-small`	Enabled by default
OpenAI GPT 120B	`openai/gpt-oss-120b`	Enabled by default
Kimi K2.6	`moonshotai/Kimi-K2.6`	Opt-in through `chat_template_args`
Kimi K2.7 Code	`moonshotai/Kimi-K2.7-Code`	Opt-in through `chat_template_args`
Kimi K3	`moonshotai/Kimi-K3`	Enabled by default
GLM 4.7	`zai-org/GLM-4.7`	Opt-in through `chat_template_args`
GLM 5.2	`zai-org/GLM-5.2`	Opt-in through `chat_template_args`
GLM 5.2 Fast	`zai-org/GLM-5.2-Fast`	Opt-in through `chat_template_args`
GLM 5.3 Flash	`zai-org/GLM-5.3-Flash`	Always enabled
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 models marked opt-in in the table above, enable thinking by passing chat_template_args.

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="moonshotai/Kimi-K2.6",
    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: "moonshotai/Kimi-K2.6",
    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": "moonshotai/Kimi-K2.6",
    "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

The reasoning_effort parameter controls the amount of reasoning a model performs. Supported values vary by model:

Model	Supported values
DeepSeek V4 Pro	`none`, `minimal`, `low`, `medium` (default), `high`, `xhigh`, `max`
DeepSeek V4 Pro 0813	`none`, `low`, `high`, `max`
DeepSeek V4 Flash 0731	`none`, `minimal`, `low`, `medium`, `high` (default), `xhigh`, `max`
Inkling	`none`, `minimal`, `low`, `medium`, `high` (default), `xhigh`, `max`
Inkling Small	`none`, `minimal`, `low`, `medium`, `high` (default), `xhigh`, `max`
Kimi K3	`none`, `low`, `high`, `max` (default)
OpenAI GPT 120B	`none`, `minimal`, `low`, `medium` (default), `high`, `xhigh`, `max`
GLM 5.2	`none`, `high`, `max`
GLM 5.2 Fast	`none`, `high`, `max`
GLM 5.3 Flash	`low`, `high` (default), `max`

Lower values reduce reasoning-token usage and latency. Higher values use more output tokens for reasoning. reasoning_effort: "none" disables reasoning for every model in this table except GLM 5.3 Flash, which doesn’t support none and cannot be disabled. Use low for minimal reasoning on GLM 5.3 Flash. Inkling and Inkling Small ignore chat_template_args: {"enable_thinking": false}. Kimi K3 supports both reasoning_effort: "none" and chat_template_args: {"enable_thinking": false}. GLM 5.2 and GLM 5.2 Fast return a 400 error for values outside their supported sets. Some model templates also read reasoning_effort from chat_template_args or chat_template_kwargs; GLM 5.2 and GLM 5.3 Flash accept either placement. Use the top-level parameter so the API can validate it. Invalid top-level values return 400, while invalid values inside chat_template_args can be ignored without an error.

A successful request does not confirm that reasoning_effort took effect. Models not listed in this table accept the parameter but ignore it.

DeepSeek V4 Pro
DeepSeek V4 Pro 0813
OpenAI GPT 120B
GLM 5.2

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.get("BASETEN_API_KEY")
)

response = client.chat.completions.create(
    model="deepseek-ai/DeepSeek-V4-Pro",
    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-Pro",
    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-Pro",
    "messages": [{"role": "user", "content": "What is the sum of the first 100 prime numbers?"}],
    "reasoning_effort": "high"
  }'

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.get("BASETEN_API_KEY")
)

response = client.chat.completions.create(
    model="deepseek-ai/DeepSeek-V4-Pro-0813",
    messages=[
        {"role": "system", "content": "You are a helpful assistant"},
        {"role": "user", "content": "Hello"},
    ],
    stream=False,
    extra_body={"reasoning_effort": "high", "thinking": {"type": "enabled"}}  
)

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-Pro-0813",
    messages: [
        { role: "system", content: "You are a helpful assistant" },
        { role: "user", content: "Hello" },
    ],
    stream: false,
    reasoning_effort: "high",
    thinking: { type: "enabled" },
});

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-Pro-0813",
    "messages": [
      {"role": "system", "content": "You are a helpful assistant"},
      {"role": "user", "content": "Hello"}
    ],
    "stream": false,
    "reasoning_effort": "high",
    "thinking": {"type": "enabled"}
  }'

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.get("BASETEN_API_KEY")
)

response = client.chat.completions.create(
    model="openai/gpt-oss-120b",
    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: "openai/gpt-oss-120b",
    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": "openai/gpt-oss-120b",
    "messages": [{"role": "user", "content": "What is the sum of the first 100 prime numbers?"}],
    "reasoning_effort": "high"
  }'

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.get("BASETEN_API_KEY")
)

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={"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: "zai-org/GLM-5.2",
    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": "zai-org/GLM-5.2",
    "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.get("BASETEN_API_KEY"),
)

response = client.chat.completions.create(
    model="moonshotai/Kimi-K2.6",
    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: "moonshotai/Kimi-K2.6",
    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": "moonshotai/Kimi-K2.6",
    "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
  }
}

Reasoning tokens are included in completion_tokens and count toward your total usage and billing.

Get started

Model APIs

Inference

Training

Development

Deployment

Engines

Model Labs

Organization

Hosting options

Observability

Troubleshooting

Supported models

Enable thinking

Control reasoning depth

Parse the response

Next steps

Model APIs overview

Structured outputs

​Supported models

​Enable thinking

​Control reasoning depth

​Parse the response

​Next steps

Model APIs overview

Structured outputs

Supported models

Enable thinking

Control reasoning depth

Parse the response

Next steps