Quick answer: Claude Fable 5.1 costs $10 per 1M input tokens and $50 per 1M output tokens — identical to Claude Fable 5. Anthropic did not cut those rates. What changed is one line item: cache reads dropped 75%, from $1.00 to $0.25 per 1M tokens. That is where the widely reported "25% cheaper" comes from, and it means the discount reaches you in exact proportion to how much of your bill was cache reads. Long agentic sessions save ~25% on typical workloads and up to ~45% on context-heavy ones. A single-turn call with no caching saves exactly nothing.
Here is the trap this article exists to defuse: you read "Fable 5.1 is 25% cheaper," you rebuild your cost forecast on a 25% reduction, and then your stateless extraction pipeline comes in at exactly the price it was before — because that pipeline never had a cache read to discount.
Credibility note: every rate below is from Anthropic's Claude Platform documentation and the September 1, 2026 launch announcement, read September 6, 2026. The worked examples are our own arithmetic applied to those published rates, with every assumption stated — they are illustrations of the mechanism, not measurements of your workload. Prompt-cache behaviour varies by framework and prompt structure, so treat them as a model to adapt, not a quote. This analysis was AI-assisted; the rate card and every worked example were re-checked against Anthropic's published rates before publication.
What This Article Solves
The pain point is a headline that names an outcome and hides the mechanism. "25% cheaper" describes a measured average across Anthropic's own aggregate usage, not a property of the price card. Two teams switching to Fable 5.1 on the same day can see a 45% reduction and a 0% reduction, and both are behaving exactly as documented.
By the end of this page you will have the complete rate card, understand precisely which token type moved, be able to predict your own savings before you migrate, and know when Fable 5.1 is the wrong thing to spend money on at all. For the capability side — specs, benchmarks, and the three breaking changes — see what Claude Fable 5.1 actually is.
The Complete Rate Card
| Token type | Price per 1M tokens |
|---|---|
| Input | $10.00 |
| Output | $50.00 |
| Cache read | $0.25 |
| Cache write (5 minute TTL) | $12.50 |
| Cache write (1 hour TTL) | $20.00 |
| Batch API | 50% discount on input and output |
Source: Claude Platform documentation, verified September 6, 2026.
Three observations before the arithmetic:
Output is 5x input. At $50 versus $10, tokens Fable 5.1 writes cost five times what tokens it reads. This is why effort level is a pricing control, not just a quality control — a higher effort setting produces more reasoning tokens, and reasoning tokens are output tokens.
Cache writes cost more than fresh input. $12.50 (5 min) or $20 (1 hr) against $10 for uncached input. Writing to cache is a loss on any prefix you read once. It only pays back across repeated reads — which is exactly what an agent loop does and exactly what a one-shot API call does not.
There is no long-context surcharge. Anthropic publishes no threshold above which rates change. This is a real, under-discussed difference from GPT-6 Astra, where requests above 272,000 input tokens are billed at 2x input and 1.5x output for the entire request. If your work involves very large single requests, that asymmetry can outweigh everything else on this page.
Where the 25% Comes From
Anthropic reduced the cache-read rate by 75% — from $1.00 to $0.25 per 1M tokens — and changed nothing else.
The reason a single line item can move a bill by a quarter: in a long agentic session, the same system prompt, tool definitions, and accumulated conversation history are re-read on every single turn. Turn 40 re-reads everything turns 1 through 39 established. After enough turns, cache reads are not a component of the bill — they are the majority of it. Cut them 75% and most of the cost disappears with them.
Anthropic's published measurements, taken over four weeks of actual August 2026 usage at default effort:
| Workload shape | Indexed cost (Fable 5 = 100) | Saving |
|---|---|---|
| Typical — Claude Enterprise, Claude Code, and API combined | 75 | ~25% |
| Highly agentic — context-heavy, tool-heavy, cache reads dominate | 55 | ~45% |
| Single-turn, no caching | 100 | 0% |
That third row is not in Anthropic's chart. It follows directly from the price card: if none of your tokens are cache reads, none of your tokens got cheaper.
Three Worked Examples
All three use the published rates above. Assumptions are stated so you can substitute your own.
Example 1: One-shot classification — saves nothing
5,000 input tokens, 1,500 output tokens, no caching.
| Line | Fable 5.1 | Fable 5 |
|---|---|---|
| Input (5K @ $10/M) | $0.050 | $0.050 |
| Output (1.5K @ $50/M) | $0.075 | $0.075 |
| Total | $0.125 | $0.125 |
Saving: $0.00 (0%). If this is your workload, Fable 5.1 is a free capability upgrade at unchanged cost — genuinely good, just not what the headline promised.
Example 2: A coding session — lands on ~25%
60,000-token cached prefix (system prompt, tools, repo context), 40 turns, 2,000 new input and 1,500 output tokens per turn, 5-minute cache TTL.
| Line | Fable 5.1 | Fable 5 |
|---|---|---|
| Cache write (60K @ $12.50/M, once) | $0.75 | $0.75 |
| Cache reads (40 × 60K = 2.4M) | $0.60 | $2.40 |
| New input (80K @ $10/M) | $0.80 | $0.80 |
| Output (60K @ $50/M) | $3.00 | $3.00 |
| Total | $5.15 | $6.95 |
Saving: $1.80 (26%). This is the "typical workload" case, and it reproduces Anthropic's ~25% figure closely — which is a reassuring sign that the published number describes the mechanism honestly.
Example 3: A long research agent — approaches 45%
250,000-token average cached context, 80 turns, 500K total cache writes, 1,500 new input and 1,500 output tokens per turn.
| Line | Fable 5.1 | Fable 5 |
|---|---|---|
| Cache writes (500K @ $12.50/M) | $6.25 | $6.25 |
| Cache reads (80 × 250K = 20M) | $5.00 | $20.00 |
| New input (120K @ $10/M) | $1.20 | $1.20 |
| Output (120K @ $50/M) | $6.00 | $6.00 |
| Total | $18.45 | $33.45 |
Saving: $15.00 (45%). Note what happened to the composition: cache reads went from being 60% of the Fable 5 bill to 27% of the Fable 5.1 bill. Output tokens are now the largest line. Which sets up the next section.
The Cost Lever Most Teams Never Touch
Once cache reads are cheap, output dominates — and output is controlled by effort.
Fable 5.1 supports low, medium, high, xhigh, and max, with defaults that differ by surface: High in Claude Code, Medium in Claude Cowork and on claude.ai. Anthropic's own claim in the launch announcement is that at Low or Medium effort, Fable 5.1 achieves results similar to or better than Fable 5's at a much lower cost.
Read that carefully, because it is a pricing statement dressed as a capability statement. If Fable 5.1 at Medium matches Fable 5 at its default, then a team upgrading and also dropping one rung on the effort ladder gets the cache-read discount and a reduction in output tokens — the expensive line — at no quality cost relative to what they had yesterday.
Two features make this practical rather than theoretical. Per-message effort (currently beta) lets you change effort partway through a conversation without invalidating the prompt cache — so you can run an agent at Low for routine steps and escalate to High only for the hard one, without paying to rebuild the cache. And Batch API takes 50% off both input and output for anything latency-tolerant.
Stack them: Medium effort instead of High, Batch for offline work, and the cache-read cut, and the gap to Fable 5's real-world cost gets much wider than 25%.
How Fable 5.1 Compares Inside the Claude Lineup
| Model | Input / 1M | Output / 1M | Context | Max output | Knowledge cutoff |
|---|---|---|---|---|---|
| Claude Fable 5.1 | $10 | $50 | 1M | 128K | Jun 2026 |
| Claude Opus 5 | $5 | $25 | 1M | 128K | May 2026 |
| Claude Sonnet 5 | $2 | $10 | 1M | 128K | Jan 2026 |
| Claude Haiku 4.5 | $1 | $5 | 200K | 64K | Feb 2025 |
Fable 5.1 is exactly 2x Opus 5 on both input and output, with the same context window and the same output ceiling.
The uncomfortable question that follows — is Fable 5.1 twice as good as Opus 5? — is one Anthropic effectively answers itself. Its documentation says to start with Claude Opus 5 for most workloads, and reach for Fable 5.1 "for demanding reasoning and long-horizon agentic work, or when your evals on Claude Opus 5 at higher effort still fall short."
A vendor telling you its flagship is not the default is worth taking at face value. On Anthropic's own benchmark table the two are close on several measures — Terminal-Bench 4.0 at 55.8% versus 52.3%, GDPval-AA v2 at 1853 versus 1824, Humanity's Last Exam with tools at 65.0% versus 63.6%. Those are single-digit gaps at double the price. Where Fable 5.1 genuinely separates is Terminal-Bench-Science (52.6% versus 29.0%) and long unattended autonomy — so if your work is not that, Opus 5 is the better spend.
Fable 5.1 vs GPT-6 Astra on Price
Both list at $10 input / $50 output. They are not the same cost.
| Rate per 1M | Claude Fable 5.1 | GPT-6 Astra |
|---|---|---|
| Input | $10.00 | $10.00 |
| Output | $50.00 | $50.00 |
| Cache read | $0.25 | $1.00 |
| Cache write | $12.50 (5m) / $20 (1h) | $12.50 |
| Above 272K input tokens | No surcharge | 2x input, 1.5x output, whole request |
| Batch | 50% discount | 50% of Standard |
| Flex | Not offered | 50% of Standard |
On the price card, Fable 5.1 wins the two lines that matter for agents: cache reads are 4x cheaper, and there is no long-context cliff.
But the price card is not the bill. Independent measurement from Artificial Analysis, checked September 6, 2026, puts cost per Intelligence Index task at $6.12 for Claude Fable 5.1 (max with fallback) against $2.57 for GPT-6 Astra (max) — Astra roughly 2.4x cheaper per completed task, while scoring 55 to Fable 5.1's leading 57. The reason is token consumption: Fable 5.1 at max effort emits considerably more, and at $50 per 1M, output swamps a cache-read discount.
The rule that falls out of this: cheaper cache reads win when your prefix is large and stable and re-read constantly. Cheaper token consumption wins when your tasks are one-shot-ish and effort is cranked. Check which of those describes your traffic before assuming the lower cache rate makes Fable 5.1 the cheaper model. The full Astra comparison puts both rate cards and both benchmark tables next to each other.
The fastest way to settle it is to run the same real task through both and compare the actual token counts. Both GPT-6 Astra and Claude Fable 5.1 are in the same model picker on glm5.app, on one credit balance — which beats provisioning two vendor accounts to answer a question you can resolve in an afternoon.
When Fable 5.1 Is the Wrong Spend
Your calls are short and stateless. No cache reads, no discount. You are paying $50 per 1M output for a job Sonnet 5 does at $10.
Opus 5 already passes your evals. Half the input rate, half the output rate, same 1M context, same 128K output ceiling. Anthropic's own guidance points here first.
Latency is your constraint. Anthropic documents Fable 5.1's comparative latency as Slower — the slowest tier in the current lineup. There is no Fast-mode equivalent to buy your way out of it, unlike Astra.
You need to edit conversation history. Fable 5.1 has three breaking changes from Fable 5, and one of them is that editing earlier turns invalidates thinking blocks. Many agent frameworks prune or rewrite history as standard practice; on Fable 5.1 that discards the preserved reasoning you are paying premium rates to generate.
Your workload is bulk and latency-tolerant. Batch's 50% is good, but Astra stacks Flex at 50% as a separate structural option. For pure throughput economics, that matters.
Frequently Asked Questions
Is Claude Fable 5.1 cheaper than Fable 5? Only through prompt caching. Input and output rates are identical at $10 and $50 per 1M. Cache reads dropped 75% to $0.25 per 1M, which Anthropic measures as ~25% lower cost on typical workloads and up to ~45% on highly agentic ones. Without caching, the cost is unchanged.
How much does Claude Fable 5.1 cost per 1M tokens? $10 input, $50 output, $0.25 cache read, $12.50 cache write on the 5-minute TTL, $20 on the 1-hour TTL. Batch API takes 50% off input and output.
Is Claude Fable 5.1 free? No. There is no free API tier. Anthropic's own documentation recommends Claude Opus 5 as the default for most workloads, at half the rate.
Does Claude Fable 5.1 cost the same as GPT-6 Astra? The list rates are identical: $10 / $50. The effective cost is not. Fable 5.1's cache reads are 4x cheaper ($0.25 vs $1.00) and it has no long-context surcharge, while Astra has no Fable-equivalent to its 272K rule and offers Flex at 50% that Anthropic does not match. On independent cost-per-task measurement, Astra currently comes out substantially cheaper because it emits fewer tokens.
How do I reduce Claude Fable 5.1 costs? Four levers, roughly in order of impact: drop one rung on the effort ladder (Anthropic says Low or Medium matches Fable 5's results); enable prompt caching wherever a prefix is re-read more than a few times; use the Batch API for anything latency-tolerant; and use per-message effort (beta) to escalate only on the hard steps without invalidating your cache.
Which cache write TTL should I use? The 5-minute tier at $12.50 per 1M is the default choice for interactive agent loops, where turns arrive seconds apart. The 1-hour tier at $20 costs 60% more to write and only pays back if reads are spread over a long session with real gaps — a research agent that pauses for tool calls or human input, rather than a tight coding loop.
Sources
- Claude Fable 5.1 — Claude Platform documentation — the complete rate card including both cache-write tiers and the Batch discount, plus context, output limits, default effort, and the breaking-change list.
- Introducing Claude Fable 5.1 and Claude Mythos 5.1 — Anthropic — the cache-read price change, the indexed-cost measurements behind the ~25% and ~45% figures and their methodology, and the low/medium effort claim.
- Models overview — Claude Platform documentation — lineup pricing comparison and Anthropic's own model-selection guidance.
- GPT-6 Astra model reference — OpenAI API docs — the competitor rate card, including the cached-input rate, the 272K threshold rule, and Flex pricing.
- Artificial Analysis — model comparison — independent cost-per-task and Intelligence Index figures, checked September 6, 2026.
Worked examples are our arithmetic on published rates with stated assumptions, not measurements of any real workload; actual cache-hit behaviour varies by framework and prompt structure. All rates verified September 6, 2026 — confirm against Anthropic's pricing documentation before committing a production budget.
