Table of Contents
Claude Fable 5 vs Sonnet 5 vs Opus 4.8: Pricing and Which Model to Use (July 2026)
Anthropic runs three production Claude models right now: Sonnet 5 at $2/$10 per million tokens (introductory, through August 31), Opus 4.8 at $5/$25, and Fable 5 at $10/$50, per Anthropic's model and pricing docs. Here is when each one makes sense. For most agent and coding work, Sonnet 5 is the right default while the introductory rate holds. Opus 4.8 is the middle tier and, for now, the only frontier-class Claude you can run under a zero-data-retention contract. Fable 5 is what you reach for when one correct answer on a long, hard task beats ten fast-but-wrong ones, and you accept paying roughly double Opus 4.8 to get it.
That is the decision. The numbers underneath it are less tidy than the sticker prices look, for two reasons. Sonnet 5's introductory rate expires on August 31, and Fable 5 ships an API behavior that silently breaks integrations written for older models. Both move the math. If you have been running Opus 4.8, our May review still holds up and it remains a sound default, but it is no longer the top of the lineup.
Three models, three price points
All prices are per million tokens (MTok), taken from Anthropic's model and pricing docs and verified July 21.
| Model | API ID | Input /MTok | Output /MTok | Context | Key constraint | Source |
|---|---|---|---|---|---|---|
| Sonnet 5 | claude-sonnet-5 | $2 intro, $3 from Sep 1 | $10 intro, $15 from Sep 1 | 1M | Intro window closes Aug 31 | Anthropic |
| Opus 4.8 | claude-opus-4-8 | $5 | $25 | 1M | none | models overview |
| Fable 5 | claude-fable-5 | $10 | $50 | 1M | 30-day retention, refusals, no ZDR | Anthropic docs |
Sonnet 5's introductory $2/$10 holds through August 31, 2026, then steps to $3/$15, which lands it at the same rate as the outgoing Sonnet 4.6, per Anthropic's Sonnet 5 announcement. At the top of the range, Fable 5 lists at $10 input and $50 output, with a 1M-token context window by default and up to 128k output tokens per request, per Anthropic's Fable 5 documentation. Opus 4.8 sits between them at $5/$25 with the same 1M window (models overview). Sonnet 5 is also the default model on the Free and Pro claude.ai plans, so most people using the chat app are already on it whether they picked it or not, per the Sonnet 5 announcement.
The cost math: when the Fable 5 premium is worth paying
Start with a workload and run it through all three. Take 100,000 API calls in a month, each sending 1,000 input tokens and returning 500 output tokens. That is 100 million input tokens and 50 million output tokens. Multiply by the prices above and you get the monthly bill:
| Model | Input cost | Output cost | Total | vs Sonnet 5 intro | Source |
|---|---|---|---|---|---|
| Sonnet 5 (intro) | $200 | $500 | $700 | 1x | prices |
| Sonnet 5 (from Sep 1) | $300 | $750 | $1,050 | 1.5x | prices |
| Opus 4.8 | $500 | $1,250 | $1,750 | 2.5x | prices |
| Fable 5 | $1,000 | $2,500 | $3,500 | 5x | prices |
These are arithmetic on the published per-token prices, not measured guesses. Swap in your own volume and the ratios hold: Fable 5 is five times Sonnet 5 at introductory pricing, and double Opus 4.8. The output-token gap is what drives it. At $50 per million output tokens against Opus 4.8's $25 (models overview), Fable 5 pushes any text-heavy workload (long reports, verbose agent traces, multi-file code) further toward that 2x line.
So which task types justify the Fable 5 premium? The ones where a wrong answer is expensive and hard to catch: a long-horizon research agent working across a large document set, a multi-step coding agent that has to hold a whole repository in context, legal or compliance review where a missed clause costs more than the entire API bill. Fable 5's 1M-token window and its long-horizon reasoning are the reason to pay, and they only earn their keep when the task is genuinely hard and the output is checked downstream.
The premium is wasted on the rest. Support chatbots, autocomplete, text summarization, classification, and routine extraction do not get meaningfully better on Fable 5, and they run at high volume where a 5x price gap turns into real money. Route those to Sonnet 5 and keep the frontier model for the small share of calls that need it.
The export-control detour that explains the timing
Part of why so many developers only started evaluating Fable 5 this month: it was pulled from global availability for most of June. Fable 5 shipped as Anthropic's most capable widely released model, then spent a stretch of mid-June under US export controls before Anthropic restored access, as it describes in its redeployment statement. The model is back to general availability now on the Claude API and the major clouds. The relevant fact for a pricing decision is simply that the evaluation window for most teams opened in July, not June, which is why the cost question feels new even though the model is not.
Sonnet 5: the new default, and its closing price window
Sonnet 5 is the interesting one for budgets, because Anthropic priced it to pull agent workloads off Opus. At introductory rates it is a little over half the cost of Opus 4.8 on the example workload above ($700 against $1,750), and Anthropic positions it as near-Opus quality on agentic tasks, per the Sonnet 5 announcement. For a solo developer or a cost-sensitive team building agents, that is the value pick today.
The catch is the calendar. On September 1 the introductory discount ends and Sonnet 5 moves to $3/$15, per Anthropic's announcement, a straight 1.5x step on both input and output. On the example workload that is $700 becoming $1,050 a month, a 50% jump with no change to your code or traffic.
There is a second, quieter cost shift for anyone migrating up from Sonnet 4.6. The new model uses an updated tokenizer, and Anthropic notes that the same text can map to more tokens, roughly 1.0 to 1.35 times as many depending on content type, per the Sonnet 5 announcement. If you benchmark cost on Sonnet 4.6 and assume the token counts carry over, you will understate the bill before you even reach the price step. The two effects stack: more tokens per request from the tokenizer, then a 1.5x per-token price on September 1.
The practical move is to measure your own token usage on Sonnet 5 itself, now, so the token counts are already the new ones. Count before you commit:
pip install -U anthropicimport anthropic
client = anthropic.Anthropic()
count = client.messages.count_tokens(
model="claude-sonnet-5",
messages=[{"role": "user", "content": your_prompt}],
).input_tokens
# Multiply count by your monthly call volume, then by the per-token price.
# Model the September 1 number at $3 input / $15 output, not the intro rate.Build the September step into your forecast today. A workflow that pencils out at introductory pricing can look different once the discount lapses.
The Fable 5 API change you have to handle
This is the most actionable technical content in the lineup, and it is easy to miss. Its safety classifiers can decline a request, and a declined request comes back as a successful HTTP 200 with stop_reason: "refusal", not as an error, per Anthropic's Fable 5 docs. Any integration built on the assumption that "no error means a usable response" will silently discard those refusals or crash when it reaches for content[0] on an empty response.
Three concrete steps close the gap.
First, check stop_reason before you read the content. This is the one-line fix that keeps the failure loud instead of silent:
resp = client.messages.create(
model="claude-fable-5",
max_tokens=1024,
messages=[{"role": "user", "content": prompt}],
)
# A 200 does not guarantee an answer on Fable 5.
if resp.stop_reason == "refusal":
handle_declined(resp) # content is empty or partial
else:
print(resp.content[0].text)Second, decide how to recover. Anthropic gives you three fallback paths: a server-side fallbacks parameter (in beta on the Claude API), SDK middleware on the client, and a manual retry you build yourself, per the Fable 5 docs. The server-side option is the least code. You name a fallback model and the API re-runs the refused request on it inside the same call:
resp = client.beta.messages.create(
model="claude-fable-5",
max_tokens=1024,
betas=["server-side-fallback-2026-06-01"],
fallbacks=[{"model": "claude-opus-4-8"}],
messages=[{"role": "user", "content": prompt}],
)Given the same prompt that Fable 5 declines, this returns an Opus 4.8 answer rather than an empty refusal, and Anthropic does not bill you for a request that is refused before any output is generated. That last detail matters for cost modeling: refusals are not a line item, but the fallback call bills at the fallback model's own rate.
Third, know the hard blocker. The model carries a 30-day data retention requirement and is not available under zero data retention, because it is designated a Covered Model, per the Fable 5 docs. Teams in regulated industries with ZDR contracts cannot use Fable 5 at all as of July 2026, and should stay on Opus 4.8 until that changes. This is not a preference to weigh, it is a gate: the request returns a 400 if your org's retention setting does not meet the requirement.
Which model for which workflow
| Use case | Pick | Why |
|---|---|---|
| Support chatbot | Sonnet 5 | High volume, low stakes, no reasoning depth needed. The 5x gap to Fable 5 is pure waste here. |
| Code completion and autocomplete | Sonnet 5 | Latency and cost matter more than frontier reasoning. |
| Text summarization and extraction | Sonnet 5 | Routine work Sonnet handles at a fraction of the cost. |
| Long-horizon research agent | Fable 5 | The 1M window and long-horizon reasoning are the reason to pay the premium. |
| Complex multi-step agentic coding | Fable 5 | One correct patch across a large repo beats several cheap wrong ones. Cursor exposes both models in its picker if you would rather not manage API billing. |
| Balanced agent automation (n8n, Make) | Sonnet 5, escalate to Fable 5 | Route by task difficulty. Most calls stay on Sonnet 5. |
| Regulated or ZDR-required team | Opus 4.8 | Fable 5 is not available under zero data retention. Opus 4.8 is the frontier-class fallback. |
If your coding work lives in an editor rather than a raw API integration, Cursor lets you select Claude models from its picker, so you can point a task at Fable 5 or Sonnet 5 without wiring up billing yourself. Our July Cursor review covers how the model lineup shifted after the SpaceX acquisition.
The routing play: Sonnet 5 by default, Fable 5 on escalation
The way to pay for Fable 5 without paying for it on every call is to run Sonnet 5 as the default and escalate only the calls that fail a confidence threshold. On a mixed workload where a minority of requests are genuinely hard, this cuts average cost sharply, because the expensive model only ever sees the small share of traffic that needs it.
n8n makes this a first-class pattern. A small, cheap classifier reads each request and scores its difficulty, a Switch node routes low-difficulty work to Sonnet 5 and high-difficulty work to Fable 5, and an aggregator puts every answer back on one rail. Our n8n LLM routing guide walks through building that router node by node, a pattern n8n documents in its own LLM routing post. The economics are the whole point: if 80% of your traffic can run on Sonnet 5, your blended rate sits far closer to $2/$10 than to $10/$50, and you still get frontier reasoning on the calls that actually need it.
The verdict
Match the model to the job and the budget, then act before August 31 if Sonnet 5 is in your plan.
- Solo developer building agents on a budget: Sonnet 5 at introductory pricing, starting now. Measure your token usage on Sonnet 5 (not Sonnet 4.6) and build the September 1 step to $3/$15 (Anthropic) into your cost model before you commit.
- Team running high-stakes autonomous workflows (legal review, compliance, complex multi-repo coding): Fable 5, gated behind a Sonnet 5 router so you only pay the premium on the calls that earn it. Add the refusal check and a fallback to Opus 4.8 before you ship.
- Any team under a zero-data-retention contract or strict data residency: Opus 4.8. Anthropic has not added ZDR support to Fable 5, so it stays off the table, and Opus 4.8 is the frontier-class model you can actually run.
- Building on Sonnet 5 before August 31: treat the introductory rate as a deadline, not a discount. Measure now, forecast at the standard rate, and decide whether the September number still works.
FAQ
Will Fable 5 ever support zero data retention? Anthropic has not announced ZDR support for Fable 5. It is a Covered Model with a 30-day retention requirement as of July 2026, per the Fable 5 docs. Until that changes, ZDR teams should plan around Opus 4.8.
Can I mix models in one Claude API account? Yes. The model is a per-request parameter, so a single account and key can send some calls to Sonnet 5 and others to Fable 5. That is exactly what the routing pattern above relies on.
Is Sonnet 5 available on AWS Bedrock and Google Vertex AI? Sonnet 5 is available on the Claude API and the major cloud platforms, though feature parity across providers can lag the first-party API. Confirm the specific features you need (server-side fallback, for one, is not offered on Bedrock or Vertex) against the current models overview before you build.
What happens to my Opus 4.8 workflows when I switch to Fable 5?
The request shape is largely the same, but Fable 5 changes three things: it can return stop_reason: "refusal" on a 200, it requires 30-day data retention, and its output tokens cost twice as much, per Anthropic's Fable 5 docs. Add the refusal handling and a fallback path, confirm your retention setting, and re-run your cost model at $10/$50 before you move production traffic.