Claude Fable 5.1 pricing at a glance
Here is the whole rate card, straight from the Claude Platform pricing docs. Every figure is per million tokens (MTok), in USD.
| Meter | Claude Fable 5.1 | Claude Fable 5 (prior) |
|---|---|---|
| Base input | $10 / MTok | $10 / MTok |
| Output | $50 / MTok | $50 / MTok |
| Cache reads (hits and refreshes) | $0.25 / MTok | $1 / MTok |
| 5-minute cache writes | $12.50 / MTok | $12.50 / MTok |
| 1-hour cache writes | $20 / MTok | $20 / MTok |
The pattern to notice: four of the five numbers are identical to Fable 5. This is not a new price tier, it is the same model rate card with one line rewritten. So if you were budgeting off Fable 5, your input and output math does not change at all.
One more thing worth pinning down before you model any of this: Fable 5.1 uses the same tokenizer as Fable 5 (the one introduced with Opus 4.7). Against models older than Opus 4.7, the same text produces roughly 30% more tokens, so do not port a token estimate from a pre-4.7 model without adjusting for it.
The one number that changed: cache reads
If you only read one section, this is it. The cache-read price fell from $1 to $0.25 per million tokens, a 75% cut.
Why does one meter matter this much? Prompt caching lets you store a chunk of a prompt (a system prompt, a big document, tool definitions) once, then re-read it on later calls instead of paying full input price each time. On Fable 5.1, a cache read now costs 0.025x the base input price, versus 0.1x on other Claude models. The 512-token minimum cacheable length is unchanged.
The reason this lands so hard on agentic work: a long-running agent re-reads its context on every step. If your agent takes forty tool calls to finish a task, it is reading that cached prefix forty times. Cut the price of that read by three-quarters and the total bill moves a lot, even though the headline $10/$50 never budged. The change rewards exactly the kind of work Fable 5.1 is built for.
What "effective savings" actually means
Anthropic quotes two savings numbers, and they are worth reading carefully rather than treating as one figure. The cache-read cut lowers a typical workload's cost by about 25%, and a highly agentic workload's cost by up to 45%, versus Fable 5.
Two caveats on those numbers, because a percentage is only as good as its baseline:
- They are measured against Fable 5, not against Opus 5 or any competitor. This is a same-model comparison.
- They were measured at default effort over four weeks of real August 2026 usage across Claude Enterprise, Claude Code, and the API. Your mix of cached versus fresh tokens decides where you land in that 25-to-45% band. A workload that barely uses caching sees barely any of it.
The practitioners running it in anger reported roughly the same shape. One team put it plainly after a week on multi-agent loops:
"One team ran Claude Fable 5.1 for 7 days straight on multi-agent coding loops and cut token spend 25%"
That is the low end of the band, which is about what you would expect for a coding loop that is not maximally cache-heavy.
Batch, US-only, and the other line items
Two rates sit outside the main table and change the math for specific setups.
Batch processing runs at 50% off the standard rate: $5 per million input tokens and $25 per million output. If your work is not latency-sensitive (overnight document processing, bulk classification, offline evals), this is the single biggest lever on the whole card, bigger than the cache cut for non-interactive jobs.
US-only inference is available for workloads with a data-residency requirement, at 1.1x the input and output price. So $11 in / $55 out per million tokens if you need every request to run in the US.
Claude Mythos 5.1, the same underlying model with lighter safeguards, is priced identically to Fable 5.1. It is not a cheaper tier, and it is limited to Project Glasswing participants (vetted cyberdefenders and life scientists), so for almost everyone it is not a purchasing option anyway.
Fable 5.1 vs Opus 5 vs Sonnet 5
Pricing a single model in isolation hides the real decision, which is which Claude you should be paying for. Here is the current family, API rates per million tokens, from the platform pricing table.
| Model | Input | Cache read | Output |
|---|---|---|---|
| Claude Fable 5.1 | $10 | $0.25 | $50 |
| Claude Opus 5 | $5 | $0.50 | $25 |
| Claude Sonnet 5 | $2 | $0.20 | $10 |
The counterintuitive bit: Fable 5.1 is the most expensive Claude on base input and output, twice Opus 5 and five times Sonnet 5, yet its $0.25 cache read is the cheapest of the three, undercutting even Opus 5's $0.50. That is not an accident. Anthropic priced the meter that a long agent session hammers, so the more agentic your workload, the more that gap works in Fable's favour.
Anthropic's own guidance is refreshingly blunt about when to actually pay for Fable. Their docs say to start with Opus 5 for most workloads and only reach for Fable 5.1 when Opus 5 at higher effort still falls short, or for the most ambitious long-running projects.
At least one developer found the cheaper-effort math compelling on its own terms:
"Fable 5.1 at low effort is often competitive with Opus and Sonnet on $ / task while scoring higher. on CursorBench 3.2.0, Fable 5.1 at low effort is at parity w/ Fable 5 at high effort at a third of the cost."
Effort is the lever most people miss when they compare rate cards: a model at low effort thinks less and spends fewer tokens, so the per-task cost of an "expensive" model can be lower than the sticker rate suggests. Fable 5.1's adaptive thinking is always on and controlled by the effort parameter, defaulting to high.
What you do not pay for
A small but real part of Claude Fable 5.1 pricing is the stuff that is now free that used to cost you money on a refusal.
Fable 5.1 reroutes some requests to safeguard models instead of answering. Flagged cyber queries fall back to Opus 4.8, flagged biology queries to Opus 5, and crucially you are not charged Fable prices for a rerouted request. There is also fallback credit that refunds the prompt-cache cost of switching models on a refused request, and you are not billed for a refusal that arrives before any output.
That billing detail matters because refusals are a live complaint. Developers hit false positives on their own code:
"Fable is useless. Me: "Find my security problems in my own code. This is code I own. I'm doing this under authorization of the CEO/CTO of our company." Fable: "yeah, no.""
To be fair to Anthropic, the direction of travel on this is better, not worse: Claude Code users can expect about 60% fewer cyber-safeguard interventions per session than on Fable 5, and Fable 5.1 can now identify software vulnerabilities defensively. The point for a budget is narrower: a refusal is annoying, but at least it is not a line on your invoice.
Plan availability and where you can call it
The token rate card is the API story. On the consumer side, Fable 5.1 is available to Pro, Max, Team, and Enterprise users, and it is not on the free tier. For the exact monthly subscription dollar figures, Anthropic points to claude.com/pricing, which is the source of truth to check live before quoting a Pro or Max number, since those move independently of the API rates above.
One nuance if you are on a subscription rather than the API: default effort differs by surface. Fable 5.1 defaults to high effort in Claude Code, and medium in Claude Cowork and on Claude.ai. Higher effort burns more tokens, which is part of why even Max users report hitting usage limits quickly on Fable-class models.
On the API, you can call claude-fable-5-1 across every major platform: the Claude API directly, Amazon Bedrock and Claude Platform on AWS, Google Cloud Vertex AI, and Microsoft Foundry. The rate card is the same wherever you call it from.
Estimate your Claude Fable 5.1 cost
Rate cards are abstract until you plug in your own numbers. This calculator takes token volumes and the split between fresh and cached input, and returns a monthly figure at Fable 5.1 rates, with Opus 5 and Sonnet 5 alongside for comparison. Everything runs in your browser, nothing is sent anywhere.
Play with the cache percentage and you will see the whole point of the 5.1 update: push more of your input through cache and Fable's total drops fast, because that is the one meter Anthropic slashed.
Model is infrastructure, eesel is the teammate
Here is the thing a rate card cannot tell you: the token price is not the cost of solving your problem, it is the cost of one raw ingredient. Claude Fable 5.1 is a model. To turn it into something that actually resolves a customer ticket, you still have to build retrieval over your help docs, guardrails so it does not confidently invent a refund policy, an escalation path to humans, and a way to test it before it touches a real customer. That work is where the real spend and the real risk live, not in the $10-versus-$50 line.
That is the gap eesel fills. eesel is an AI teammate platform, and its AI support teammate arrives already knowing how to do the job: it plugs into your existing helpdesk, trains on your past tickets and knowledge base, and joins the queue like a new hire. You do not assemble it from a model and a stack of glue code. And because a coding agent like Claude Code, Codex, or Cursor can drive the same teammate through the eesel CLI, the automation you build is scriptable end to end, not locked behind a dashboard.
The pricing difference is the part that matters for anyone who just read this whole rate card. Token metering is variable by design: a chatty agent run costs more than a terse one, and you find out after the fact. eesel bills per resolved ticket instead, so support automation stays a predictable line item no matter how many times the underlying model re-reads its context. You can try eesel free, and run it against your own historical tickets first to see the resolution rate and the cost before it ever answers a live customer.