How to Turn Off Thinking on Claude Opus 5.5 and Sonnet 5.5

Because Anthropic made thinking always-on for Opus 5.5. On Opus 5 you could send disabled at high effort or below. On Opus 5.5 the same request fails at every effort level, and so does the old manual budget ({type: "enabled", budget_tokens: N}). This is the error you'll see:

HTTP 400 invalid_request_error
"thinking.type.disabled" is not supported for this model.
Use "thinking.type.adaptive" and "output_config.effort" to control thinking behavior.

The Opus 5.5 release notes list it as the first of four breaking changes, and Fable 5.1 shares it. The fix is boring: delete the thinking field (omitting it means adaptive) and set effort instead.

The trap is the model swap, not the new model. Most of the code I've seen with disabledhardcoded got it from a latency fix months ago. Nobody remembers it's there until a router or a config change points it at Opus 5.5. If you also force a tool with tool_choice, check that too: Opus 5.5 rejects forced tool use with its own 400.

The Models API reports this per model (the between_toolsflag was added on October 15), so you don't have to guess or dig through five migration guides. Here's what GET /v1/models returned for my org on October 20, 2026:

Every model in that list supports adaptive thinking. Opus 4.5, Haiku 4.5 and Sonnet 4.5 are the odd ones out: they only do manual budgets, no adaptive. The "high effort or below" caveats come from the effort docs, not the Models API. The API tells you a type is supported, not at which effort levels, so at xhigh or max you should assume adaptive is the only option.

Read the flags at runtime instead of hardcoding them. The response looks like this:

curl -s https://api.anthropic.com/v1/models/claude-sonnet-5-5 \
  -H "x-api-key: $ANTHROPIC_API_KEY" -H "anthropic-version: 2023-06-01"

# ...
"thinking": {
  "supported": true,
  "types": {
    "enabled":       { "supported": false },
    "adaptive":      { "supported": true },
    "disabled":      { "supported": false },
    "between_tools": { "supported": true }
  }
}

Small detail I liked: this endpoint answered fine on an org whose credit balance is at zero, while every Messages call from the same key came back "credit balance is too low" before any parameter validation ran. So you can build and test capability checks without spending anything.

It skips the up-front thinking, the deliberation Claude does before it writes an answer or picks its first tool, while still letting the model leave short notes between tool calls. It's the lowest thinking setting Sonnet 5.5 has, and it's Anthropic's stated replacement for disabled on that model.

Four rules from the Sonnet 5.5 prompting guide that will bite you if you skip them:

• Low, medium or high effort only. At xhigh or maxit's a 400.
• Effort is locked for the conversation. A per-message output_config.effort that differs from the current level returns a 400. If you bump effort for hard turns, stay on adaptive.
• The notes still come back as thinking blocks. Notes longer than a sentence or two return as thinking blocks with a summary. Pass them back unchanged in your tool loop.
• No tools means no thinking at all. In a plain request, between_tools answers cold. For anything that needs a few steps of working out, use adaptive.

That last one is the important one. If you're using between_toolson a JSON extraction endpoint with no tools, you've turned off thinking completely, which is fine for "pull the email address out of this" and risky for "total these line items and apply the discount." More on that split in my structured outputs vs tool use post.

Less than I expected on easy work, and less tied to effort than the docs make it sound. I ran three easy tasks (a one-word support email classification, a JSON lead extraction, a five-line JavaScript bug fix) and one task that needs real working out: a first-year invoice total with an annual discount, mid-year prorated seats, and sales tax on seats only. Every task had a checked answer.

"Always on" doesn't mean "always thinks." On every easy task, Opus 5.5 at low and medium spent zero thinking tokens. Same for Sonnet 5.5 at low. Adaptive thinking looked at a classification prompt and just answered. If your workload is routing, tagging and extraction, losing disabled probably costs you close to nothing.

On the invoice, effort barely moved Opus 5.5.It thought 113 to 154 tokens whether I asked for low, medium or high, and got it right every time. The task set the thinking budget, not the dial. At Opus 5.5's $20 per million output tokens, 150 thinking tokens is $0.003 a call, or about $300 per 100,000 calls. Real money at volume, small money per request.

Haiku 5.5 is the interesting one. It thought two to three times as much as Opus on the same invoice (299 to 378 tokens) and still missed once at low effort, answering $2,463.83 instead of $2,464.48. At medium it was 2 for 2. At $0.50 per million output tokens that extra thinking is basically free, so for math-shaped work I'd run Haiku at medium rather than chase the lowest setting. I compared Haiku generations in detail in Haiku 5.5 vs Haiku 4.5 on cost.

One thing to keep in mind for your bill: thinking is charged as output tokens even under the default display: "omitted", where the thinking block comes back empty. You pay for tokens you never see. The only place they show up is usage.output_tokens_details.thinking_tokens, so log it.

Ask the Models API what the model accepts and pick the lowest setting from the answer. This is the helper I use. I ran it against the live API before putting it here:

import json, os, urllib.request

def get_model(model_id: str) -> dict:
    req = urllib.request.Request(
        f"https://api.anthropic.com/v1/models/{model_id}",
        headers={"x-api-key": os.environ["ANTHROPIC_API_KEY"],
                 "anthropic-version": "2023-06-01"},
    )
    with urllib.request.urlopen(req) as r:
        return json.load(r)

def least_thinking(model_id: str, effort: str = "low") -> dict:
    """Request params for the least up-front thinking this model accepts."""
    types = get_model(model_id)["capabilities"]["thinking"]["types"]
    params = {"output_config": {"effort": effort}}
    high_or_below = effort in ("low", "medium", "high")
    if types.get("disabled", {}).get("supported") and high_or_below:
        params["thinking"] = {"type": "disabled"}
    elif types.get("between_tools", {}).get("supported") and high_or_below:
        params["thinking"] = {"type": "between_tools"}
    # otherwise send nothing: adaptive is the floor
    return params

# claude-opus-5-5   -> {'output_config': {'effort': 'low'}}
# claude-sonnet-5-5 -> {..., 'thinking': {'type': 'between_tools'}}
# claude-haiku-5-5  -> {..., 'thinking': {'type': 'disabled'}}

Cache the model lookup. Capabilities don't change between requests, and you don't want an extra round trip on every call. Then three more changes for anything coming off Opus 5:

Parse content blocks by type

A 5.5 response can start with a thinking block whose text is empty. Code that reads content[0].text breaks quietly. Filter for type == "text".

Delete prompts that stood in for thinking

If your prompt says "explain your reasoning step by step before answering" because thinking was off, remove it. Anthropic's Opus 5.5 guide warns that prompts pushing the model to reproduce its reasoning in the answer can be declined with a reasoning_extraction refusal. Ask for display: "summarized" if you want to read the reasoning.

Re-run your effort sweep

Opus 5.5 defaults to medium, one level below Opus 5's high. A request that never set effort is already thinking less than before. I walk through picking a level in which Claude effort level to use, and the full Opus 5 to 5.5 change list is in my Opus 5.5 migration notes.

Mostly no. I turned thinking off on older models for one reason: time to first token on chatty, simple requests. My numbers say adaptive at low already skips thinking on exactly those requests, and it spends tokens only where the task needs them, which is where you'd want them anyway.

Where I'd still push: latency-critical voice and chat paths. There, Sonnet 5.5 with between_tools or Haiku 5.5 with disabledgives you a hard guarantee instead of a model's judgment call. Opus 5.5 and Fable 5.1 don't offer that guarantee, so keep them off the hot path. If Fable is on your list, check the Fable 5.1 pricing breakdown first. At $50 per million output tokens, its thinking is 2.5 times the price of Opus 5.5's.

How I tested this: capability flags from GET /v1/models (14 models, no pagination) on October 20, 2026. Thinking tokens from 36 calls through Claude Code in headless mode (claude -p --output-format json --effort <level>, no tools, no MCP) on my Max plan, reading usage.output_tokens_details.thinking_tokens, because my API org had no credit that day. That path runs adaptive thinking, so it measures the floor on Opus 5.5 but not between_tools or disabledthemselves. Easy tasks: 2 runs each at the configs marked; invoice: 2 runs per config. Prices from Anthropic's pricing page on the same day.