Skip to content

Anthropic Claude models: lineup and how to choose

  • How Anthropic’s Claude tiers are organized and what each is for.
  • The current model IDs, prices, context windows and output limits, with the official page to recheck them.
  • How to choose a model and an effort level, and when to combine models.
  • How pricing mechanics (caching, batch, long prompts, regional routing) change the bill.
  • What breaks in production: model retirement, parameter removals, refusals and data-retention constraints.

Anthropic ships Claude as a small set of named tiers. Haiku is the fast, low-cost tier, Sonnet balances speed and capability, and Opus targets long-running coding and knowledge work. In the Claude 5 generation Anthropic added Fable, positioned above Opus for the most demanding reasoning, and Mythos, a model with the same capabilities as Fable that is available only to organizations verified through Anthropic’s verification programs.

As of November 2026 the current lineup is Claude Fable 5.2, Claude Opus 5.5, Claude Sonnet 5.5 and Claude Haiku 5.5. Anthropic’s guidance is to start with Opus 5.5 for most workloads, and to move to Fable 5.2 only when evaluations on Opus at higher effort still fall short.

Every figure on this page comes from Anthropic’s documentation on the date shown. Model lineups change every few months, so treat the tables as a snapshot and the selection method as the durable part.

Tier Positioning (Anthropic’s wording, paraphrased) Typical work
Fable Demanding reasoning and long-horizon agentic work; the most capable model open to all customers Agent sessions that run for hours, multistep research, analysis carried through to a finished deliverable
Mythos Same capabilities as Fable, limited to verified organizations (for example through the Cyber Verification Program) Work covered by those programs
Opus Long-running agentic coding and knowledge work; the recommended starting point Large refactors, complex systems work, vision-heavy workflows, computer use
Sonnet The best combination of speed and intelligence Everyday coding, data analysis, content, agentic tool use
Haiku High-volume, latency-sensitive tasks Classification, extraction, routing, subagent tasks, real-time applications

Fable and Mythos are numbered on their own track (5, 5.1, 5.2), separate from the Opus, Sonnet and Haiku track (5, 5.5).

Source: Anthropic models overview and release notes.

Model Claude API ID Released Input / output per million tokens Default effort Comparative latency
Claude Fable 5.2 claude-fable-5-2 Nov 9, 2026 $8 / $40 high Moderate
Claude Mythos 5.2 (limited availability) claude-mythos-5-2 Nov 9, 2026 $8 / $40 high Not listed
Claude Opus 5.5 claude-opus-5-5 Sep 22, 2026 $4 / $20 medium Moderate
Claude Sonnet 5.5 claude-sonnet-5-5 Sep 28, 2026 $2 / $10 high Fast
Claude Haiku 5.5 claude-haiku-5-5 Oct 7, 2026 From $0.10 / $0.50 medium Fastest

Shared by all of the above, per the overview page:

  • Context window: 1M tokens. Max output: 128K tokens on the synchronous Messages API.
  • Input and output: text and image input, text output, tool use, multilingual.
  • Thinking: adaptive thinking, where the model decides how much to reason and you steer it with the effort setting. On Fable 5.2 and Opus 5.5 it is always on.
  • Reliable knowledge cutoff: June 2026.
  • Model IDs are pinned snapshots. From the 4.6 generation on, IDs carry no date suffix, and the dateless ID does not move to a newer model.

Haiku 5.5 is priced by prompt length: the “from” price applies to requests whose prompt is up to 100,000 tokens, and a request with a longer prompt pays $0.50 / $2.50 per million tokens. The other current models include the full 1M-token window at the standard rate.

On Amazon Bedrock the IDs differ (for example anthropic.claude-opus-5-5 and global.anthropic.claude-fable-5-2); on Google Cloud, Microsoft Foundry and Claude Platform on AWS they match the Claude API IDs. Partner platforms set their own lifecycle dates and regional prices.

Anthropic moves models through four states: active, legacy, deprecated (still works, replacement named, retirement date set) and retired (requests fail). It commits to at least 60 days’ notice before retiring a publicly released model.

Status of earlier models on the Claude API (November 13, 2026)

Source: Model deprecations.

Model Status
Claude Fable 5.1, Fable 5, Mythos 5.1, Mythos 5 Active
Claude Opus 5, 4.8, 4.7, 4.6, 4.5 Active
Claude Sonnet 5, 4.6 Active
Claude Haiku 4.5 Active
Claude Sonnet 4.5 Deprecated; retires November 30, 2026 (replacement: Sonnet 5.5)
Claude Mythos Preview (claude-mythos-preview) Deprecated since June 9, 2026; retirement date to be announced
Claude Opus 4.1 Retired August 5, 2026
Claude Opus 4, Claude Sonnet 4 Retired June 15, 2026
Claude Haiku 3 Retired April 20, 2026
Claude Sonnet 3.7, Claude Haiku 3.5 Retired February 19, 2026
Claude Opus 3 Retired January 5, 2026
Claude Sonnet 3.5 Retired October 28, 2025
Claude 2.x, Claude Sonnet 3 Retired July 21, 2025
Claude 1.x, Claude Instant Retired November 6, 2024

Some retired models remain available for a time on Amazon Bedrock or Google Cloud, which run their own schedules.

The practical consequence: a model ID in your configuration has a shelf life of roughly a year or two. Plan for migration as routine work.

Anthropic describes two starting strategies; in both, your own evaluation set decides.

  • Efficiency first. Start with Haiku 5.5, test thoroughly, and upgrade only where a specific capability gap shows. Suits prototypes, tight latency budgets, cost-sensitive and high-volume simple tasks.
  • Capability first. Start with Opus 5.5, tune the prompt, then reduce cost by lowering effort or moving to a smaller model. If results at xhigh or max effort still fall short on demanding reasoning or long agentic work, move to Fable 5.2.
You need Start with
The highest available capability Claude Fable 5.2
Complex agentic coding and enterprise work Claude Opus 5.5
Speed and capability for everyday coding, agents and enterprise workloads Claude Sonnet 5.5
The lowest latency and price Claude Haiku 5.5

The effort setting trades thoroughness for speed and cost inside one model. Levels are low, medium, high, xhigh and max, and it affects all output: text, tool calls and thinking. Anthropic’s guidance is that tuning effort is often a better lever than switching models, and that you should run an effort sweep on your own evaluations instead of carrying a setting over from an older model.

Two details catch people out. Defaults differ by model (medium on Opus 5.5 and Haiku 5.5, high on Fable 5.2 and Sonnet 5.5), so a request that omits effort behaves differently after a model switch. And max_tokens is a hard cap on thinking plus visible output together, so high effort with a small max_tokens truncates the answer.

A common pattern pairs a low-cost model with a frontier model so most tokens are billed at the lower rate: an orchestrator that delegates bulk work to cheaper workers, or an executor that escalates hard decisions to a stronger advisor.

The cross-provider list-price comparison is on LLM model selection. This example takes one Claude model and shows how the Claude-specific levers move the same bill.

An invented shop, OrdersPortal, classifies one million support tickets a month on Claude Sonnet 5.5. Each request sends a shared prefix of about 1,800 tokens (instructions, label definitions and examples) plus a 200-token ticket, and returns a one-word label. Thinking is billed as output, so output per request depends on effort. The output figures below are assumptions for illustration, not measurements: 900 tokens at high (Sonnet 5.5’s default), 150 at low. Measure your own from usage.output_tokens during an effort sweep.

Prices from the pricing page, November 2026, per million tokens: Sonnet 5.5 input $2, output $10, cache hits $0.10 (0.05× input); Haiku 5.5 input $0.10, output $0.50, cache hits $0.01. The Batch API halves every rate, and the discounts stack.

Step Input cost Output cost Monthly total
1. Sonnet 5.5, default high effort, no caching 2,000M × $2 = $4,000 900M × $10 = $9,000 $13,000
2. Cache the 1,800-token prefix 1,800M × $0.10 + 200M × $2 = $580 $9,000 $9,580
3. Lower effort to low (only if the evaluation still passes) $580 150M × $10 = $1,500 $2,080
4. Move to the Batch API (results can wait) $290 $750 $1,040
5. Same pipeline on Haiku 5.5 at low (1,800M × $0.01 + 200M × $0.10) ÷ 2 = $19 150M × $0.50 ÷ 2 = $37.50 about $57

What the table teaches:

  • Effort dominated this bill, not the tier. At the default high, thinking tokens were 70% of the cost. An effort sweep comes before any model switch.
  • Caching needs a stable prefix. The cached part must be byte-identical and come first: tools, then system prompt, then examples, with the ticket last. The prefix must also reach the minimum cacheable length (512 tokens on the current models). Cache writes cost 1.25× input for the 5-minute cache; with steady traffic each hit refreshes the entry, and even one write every five minutes adds only about $40 a month here.
  • Batch has conditions. Results arrive asynchronously (most batches finish within an hour; a batch that has not finished after 24 hours expires), cache hits inside a batch are best-effort, and batch processing is not eligible for zero data retention.
  • Haiku 5.5 changes the order of magnitude, but only if the graded test set says it labels well enough. If it does on most tickets, route only low-confidence cases to Sonnet.

The request shape is the same for every tier. This fragment requires an API key and was not executed against the API; it was run against the anthropic Python SDK 2.8.0 with a mocked HTTP transport returning end_turn, refusal and max_tokens responses, and each branch printed as expected (for example delivery and 212 1800 143).

# Fragment: requires ANTHROPIC_API_KEY in the environment; not executed against the API
# pip install anthropic
import anthropic
client = anthropic.Anthropic() # reads ANTHROPIC_API_KEY
INSTRUCTIONS = "Classify the support ticket as billing, login, delivery or other. Reply with the label only."
# In production this shared prefix also holds label definitions and examples (about 1,800 tokens)
response = client.messages.create(
model="claude-sonnet-5-5",
max_tokens=2048, # caps thinking plus visible output
system=[{"type": "text", "text": INSTRUCTIONS, "cache_control": {"type": "ephemeral"}}],
messages=[{"role": "user", "content": "Order A1001 has not arrived and tracking stopped updating."}],
output_config={"effort": "low"},
)
if response.stop_reason == "refusal":
print("declined:", response.stop_details) # HTTP 200, but not an answer
elif response.stop_reason == "max_tokens":
print("truncated: raise max_tokens or lower effort")
else:
label = next(b.text for b in response.content if b.type == "text")
print(label)
usage = response.usage
print(usage.input_tokens, usage.cache_read_input_tokens, usage.output_tokens)

The checks matter because a refusal and a truncated answer both arrive as HTTP 200. Code that reads content[0].text blindly also breaks on current models, where a response can begin with a thinking block.

Three more pricing rules from the pricing page, November 2026, that this example leaves out:

  • Regional routing. Requesting US-only inference with inference_geo applies a 1.1× multiplier to every token category on current models; global routing is the standard price.
  • Fast mode. Higher output speed at premium prices on selected models, and not available with the Batch API.
  • Server tools. Web search is billed per search on top of tokens, and tool definitions and tool results count as input tokens.
Choice Gain Cost
Larger tier Better results on hard, long or ambiguous tasks Price, latency, and for Fable a retention requirement (see Failure modes)
Smaller tier Speed and price; enough for most narrow tasks More prompt and evaluation work; weaker on long multi-step tasks
Higher effort More thorough reasoning and tool use More output tokens and time; needs a large max_tokens
Claude API directly Newest features first; Anthropic’s lifecycle dates A separate vendor relationship and billing
Bedrock, Google Cloud or Foundry Existing cloud contracts, IAM and regions Different IDs, feature lag on some betas, the partner’s own retirement dates
Another provider’s models Different strengths, prices or modalities (Claude models output text only) Prompts and tool behavior do not transfer unchanged

For a cross-provider view, see LLM model selection, OpenAI models, Google models and Amazon models.

  • Retirement breaks hard-coded IDs. Requests to a retired model fail. Keep model IDs in configuration, subscribe to deprecation notices, and audit usage from the Console’s usage export.
  • Parameters change between models. API version 2026-10-21 removed temperature, top_p and top_k (they return a 400 error), and earlier API versions already reject non-default values on Claude 4.7 and later. Forced tool use and disabled thinking are now model-specific; see the table below.
  • Refusals are successful responses. A declined request returns HTTP 200 with stop_reason set to refusal and a stop_details object naming the policy area. Code that only checks the status code will treat it as an answer.
  • Data-retention constraints. Fable 5.2 and Mythos 5.2 require 30-day data retention and are not available under zero data retention unless Anthropic authorizes it. Check this before routing regulated data to them.
  • Conversation history rules. On Fable 5.2, editing earlier turns, the system prompt or the tool list in a conversation that contains thinking blocks returns a 400 error. Append to history instead of rewriting it. A conversation that moves onto Fable 5.2 keeps earlier models’ reasoning on the Claude API and Google Cloud, but no model other than Mythos 5.2 reads Fable 5.2’s thinking blocks: moving from Fable 5.2 to Opus 5.5, for example, drops them (the request still succeeds).
  • Token counts differ by generation. The tokenizer introduced with Opus 4.7 produces more tokens for the same text than earlier models (Anthropic gives about 555k words per 1M tokens, against about 750k before), so cost estimates from older models are too low.

Checked against each model’s “what’s new” page and the release notes, November 2026.

Model Forced tool use (tool_choice any or tool) thinking: {"type": "disabled"} How to get less thinking Read before switching
Claude Fable 5.2 400 error 400 error (adaptive thinking always on) Lower effort What’s new
Claude Opus 5.5 400 error 400 error (adaptive thinking always on) Lower effort What’s new, migration guide
Claude Sonnet 5.5 400 error 400 error; the message points to between_tools thinking: {"type": "between_tools"} at high effort or below (400 at xhigh or max) What’s new, migration guide
Claude Haiku 5.5 Not listed as a breaking change Accepted at high effort or below (400 at xhigh or max) Lower effort, or disable thinking What’s new

Where forced tool use is rejected, Anthropic’s replacement is tool_choice: {"type": "auto"} with strict tool use (strict: true), or structured outputs, to get schema-valid JSON. Manual thinking budgets (budget_tokens) return a 400 error on all four models.

  • Fable for routine work: you pay the top price, and accept its retention requirement (see Failure modes), without a measurable gain. Use it where Opus at high effort has been shown to fall short.
  • Opus for high-volume classification or extraction: Haiku or Sonnet does the job at a fraction of the cost.
  • Haiku for long autonomous tasks: Anthropic notes that at low effort it is more likely to stop early or skip a check in long agent prompts.
  • Any Claude model when you need generated images, audio or video, since output is text only, or when data must stay on hardware you control. See Running LLMs locally.

1. What is the effort parameter and how does it differ from picking a model? Effort (low to max) controls how many tokens the model spends on a response, including thinking and tool calls. It lets you trade quality for speed and cost within one model, without changing prompts or IDs. Picking a model changes the capability ceiling and the price per token; effort changes how much of that capability is spent per request.

2. Why should model IDs live in configuration? Models are deprecated and retired on a published schedule, with at least 60 days’ notice, and requests to a retired model fail. IDs also differ between the Claude API and Bedrock. Configuration lets you switch after evaluation without a code release, run two models side by side, and keep a fallback.

3. Senior scenario: your platform serves enterprise tenants, some of whom have zero-data-retention (ZDR) agreements. Product wants Fable 5.2 for its hardest analysis feature. How do you design it? Fable 5.2 requires 30-day data retention and is not available under ZDR unless Anthropic expressly authorizes it, so the model choice becomes a per-tenant policy, not a global setting. Put the tenant’s retention tier in the request context and have the model router enforce it: ZDR tenants get Opus 5.5 at xhigh or max effort for that feature, everyone else may get Fable. Evaluate both paths on the same graded set and tell ZDR customers their path uses a different model. Audit the rest of the pipeline the same way: batch processing is not ZDR-eligible either, so a nightly batch job must not pick up ZDR tenants’ data. Log the model that served each request so compliance can prove the routing. Do not let a conversation switch from Fable to Opus mid-way as a fallback: no model other than Mythos 5.2 reads Fable 5.2’s thinking blocks, so the earlier reasoning is dropped. Restart the analysis on the fallback model instead.

  • Four public tiers: Haiku (fast), Sonnet (balanced), Opus (default for complex work), Fable (hardest tasks); Mythos is Fable-level with restricted access.
  • Start with Opus 5.5 or Haiku 5.5 depending on strategy, and let your own evaluations decide.
  • Tune effort before switching models, and set max_tokens with thinking in mind.
  • Effort, caching and batch can change the bill more than the tier does.
  • Treat model IDs as configuration with an expiry date.

Checked on November 13 and 15, 2026.