Fable 5.2 API pricing: when it beats Opus 5.5

Fable 5.2 API pricing is $8 per million input tokens and $40 per million output tokens, exactly twice Opus 5.5's $4 and $20. Yet a cache hit costs the same $0.20 per million tokens on both models. That shared number decides your bill, and on list prices alone Fable 5.2 never costs less per request.

By the end of this post you'll know what one request costs on each model at three workload shapes, why the much-quoted 0.025x cache multiplier is not the saving it looks like, and the one condition under which Fable 5.2 comes out cheaper per task. That condition is a claim Anthropic makes about token use, and it's the thing to test before you move production traffic. All prices are list prices on the Claude API as of November 10, 2026.

Fable 5.2 API pricing against Opus 5.5, line by line

Anthropic launched Claude Fable 5.2 on November 9, 2026 under the model ID claude-fable-5-2. The pricing page lists Fable 5.1 and Fable 5 at $10 and $50, so the new rate is a 20% cut on the Fable line. It is not a cut relative to Opus 5.5, which still lists at half the price.

Price per million tokens	Fable 5.2	Opus 5.5	Fable 5.1 (legacy)
Base input	$8	$4	$10
5-minute cache write	$10	$5	$12.50
1-hour cache write	$16	$8	$20
Cache hit	$0.20	$0.20	$0.25
Output	$40	$20	$50
Batch input / output	$4 / $20	$2 / $10	$5 / $25
Fast mode input / output	$16 / $80	$8 / $40	Not listed

Every figure in that table comes from Anthropic's pricing documentation, with fast mode rates from the fast mode page. The models overview gives both models a 1M-token context window and 128K tokens of maximum output, so capacity does not separate them.

The 0.025x cache read is the same $0.20 Opus 5.5 charges

Fable 5.2 bills cache hits at 0.025x its base input price, against the standard 0.1x on older models. Opus 5.5 bills cache hits at 0.05x. Because Fable's base price is twice Opus's, both multipliers land on the same $0.20 per million tokens, a figure the pricing page states for each model.

That matters because "Fable has a quarter of the usual cache multiplier" reads like a reason Fable gets cheaper as your cached context grows. It doesn't. A cached token costs the same on either model. Everything else in the request, the fresh input, the cache writes and every output token, costs twice as much on Fable 5.2. Caching narrows the gap between the two models; it never reverses it.

The comparison where the multiplier does pay is within the Fable line. Fable 5 bills cache hits at $1 per million, so a workload moving from Fable 5 to Fable 5.2 sees its cached-token cost fall by 80%. If you are comparing Fable versions, the cache change is the headline. If you are comparing Fable with Opus 5.5, it is a wash. For the mechanics of setting cache breakpoints well, our guide to prompt caching covers what moves the hit rate.

What one request costs at three workload shapes

The arithmetic below uses list prices only. The token counts are illustrative figures we chose to represent common shapes; they are not measurements from any workload, and your own logs are the only numbers that should drive the decision.

Shape 1: a long cached-context agent turn

Take an agent turn that reads 200,000 tokens from cache, adds 5,000 fresh input tokens and writes 2,000 output tokens. On Fable 5.2 that is $0.04 for the cache read, $0.04 for fresh input and $0.08 for output: $0.16. On Opus 5.5 it is $0.04, $0.02 and $0.04: $0.10. Fable costs 1.6 times as much, the closest the two models get at these prices.

Shape 2: a short, uncached call

A classification or extraction call with 3,000 input tokens and 800 output tokens, nothing cached, costs $0.056 on Fable 5.2 and $0.028 on Opus 5.5. With no cache reads to share, the ratio is the full 2x.

Shape 3: the first turn that writes the cache

Writing 200,000 tokens to the 5-minute cache costs $2.00 on Fable 5.2 and $1.00 on Opus 5.5. The 1-hour cache write doubles that to $3.20 and $1.60. If your sessions are short-lived and the cache keeps expiring, the write cost repeats and you pay the full 2x on every one.

Illustrative request	Fable 5.2	Opus 5.5	Ratio
200K cached + 5K fresh in, 2K out	$0.16	$0.10	1.6x
3K fresh in, 800 out	$0.056	$0.028	2.0x
200K written to 5-minute cache	$2.00	$1.00	2.0x

The pattern holds at any token counts: Fable 5.2 costs between 1x and 2x Opus 5.5 per request, closer to 1x the more of your input is cache reads and the fewer output tokens you generate. In Shape 1, Fable 5.2 only matches Opus 5.5 on cost per task if it finishes the same task in no more than 62.5% of the turns ($0.10 divided by $0.16), or with proportionally fewer output tokens.

Is Fable 5.2 cheaper than Opus 5.5 for production API workloads?

Fable 5.2 is cheaper per task only if it uses substantially fewer tokens to reach the same result, and that is exactly what Anthropic claims. The launch post says Fable 5.2 at High effort scores 45.3% on FrontierCode 2.0, "about the same" as Opus 5.5's best score of 45.5%, "for roughly half the cost per task." On WANDR at Medium effort, it says Fable 5.2 matches Opus 5.5's top score for "about 40% of the cost per task."

Those are vendor claims, and the strongest version of them deserves a fair hearing. A model that plans better can take fewer agent turns, call fewer tools and stop sooner, and at a 2x token price that is the only way to come out ahead. The comparison is also pitched sensibly: Fable at High effort against Opus 5.5 at its best, which is the trade a team chasing Opus's top accuracy would actually make.

Three things limit how far you can carry them. The launch post plots cost per task on a log scale but doesn't describe how cost was calculated; it points readers to the system card for methodology. The tasks are coding and agent benchmarks, not your document pipeline. And Anthropic's own models overview still says to start with Opus 5.5 for most workloads, using Fable 5.2 for demanding reasoning and long-horizon agentic work, or when your evals on Opus 5.5 at higher effort still fall short.

Note the defaults, too. The same overview lists Fable 5.2's default effort as high and Opus 5.5's as medium. Effort steers how many tokens the model spends, so a straight model-ID swap with no effort setting changes two variables at once. Pin effort explicitly on both sides of any comparison you run.

Batch, fast mode and US-only inference change the multiplier

The Batch API takes 50% off input and output, putting Fable 5.2 at $4 and $20, the same per-token price as Opus 5.5 run synchronously. Anthropic's pricing page says the cache multipliers stack with the batch discount. For overnight evaluation, document backfills and anything that can wait, batch is the cheapest way to run Fable 5.2 on work that genuinely needs it.

Fast mode goes the other way. It costs $16 and $80 per million tokens on Fable 5.2, four times Opus 5.5's standard rate, for up to 2.5x higher output tokens per second. The speed gain is in output throughput, not time to first token. Fast mode cannot be combined with batch, and the fast mode page warns that falling back from fast to standard speed is a prompt cache miss, because requests at different speeds don't share cached prefixes. A fallback path on a 200K-token context re-pays the cache write.

Data residency adds a flat surcharge. Setting inference_geo: "us" applies a 1.1x multiplier to every token category, including cache reads and writes, so Shape 1 rises from $0.16 to $0.176 on Fable 5.2. Global routing, the default, uses standard prices.

Does Fable 5.2 have a long-context surcharge?

No. Anthropic's long context pricing section says Claude 4.6 and later models, except Haiku 5.5, include the full 1M-token window at standard pricing: a 900K-token request is billed at the same per-token rate as a 9K-token one. Fable 5.2 has no separate rate to model above any prompt-length threshold.

Retention rules can block Fable 5.2 before price does

Fable 5.2 is a designated Covered Model. Anthropic's data retention documentation says Covered Models require 30-day data retention and are not available under zero data retention unless Anthropic expressly authorizes it. Organizations on ZDR can enable 30-day retention for one specific workspace, leaving other workspaces on ZDR, but the Default Workspace always follows the organization setting.

The same constraint follows the model onto gateways. Vercel's AI Gateway changelog lists Fable 5.2 as anthropic/claude-fable-5.2 and states that Anthropic does not support zero data retention for it: teams with ZDR enabled get an error instead of a response, and prompts and completions are retained for 30 days. Vercel also notes that Fable 5.2 has cybersecurity and biology safety classifiers enabled, and suggests a models fallback array for requests the cybersecurity classifier declines. If you configure that fallback, the fallback model's price applies to those requests.

Claude Fable 5.2 on AWS Bedrock

On Amazon Bedrock the model ID is anthropic.claude-fable-5-2, per the models overview. The prices in this post are Claude API prices: Anthropic's pricing page says Bedrock has independent regional pricing, so check AWS's own price list. The retention documentation says the 30-day requirement applies there too, with retained data staying inside your cloud provider's environment.

Is Fable 5.1 still available on the API?

Yes. As of November 10, 2026, Anthropic's models overview lists Fable 5.1 and Fable 5 under "Legacy models (still available)," at the $10 and $50 rates. The model deprecations page shows neither as deprecated, with a tentative retirement for claude-fable-5-1 of not sooner than September 1, 2027. If you are on Fable 5.1 today, moving to Fable 5.2 is a straight 20% saving on every listed standard, cache and batch rate, and needs no comparison with Opus at all.

If you are reading a Fable price of $10 and $50 anywhere, it describes Fable 5.1 or Fable 5, not 5.2. Fable 5.2 itself has a tentative retirement date of not sooner than November 9, 2027, on the same page.

Should you move production from Opus 5.5 to Fable 5.2?

Move a workload when three things are true: it is long-horizon agent work where Opus 5.5 at higher effort is falling short on your evals, most of its input is cache reads, and your own replay shows Fable 5.2 finishing tasks in well under two-thirds of the turns or output tokens. Short uncached calls fail the first two tests and will cost you 2x. This is the wrong move for classification, extraction and routing traffic, and for any team on ZDR that cannot open a 30-day retention workspace.

The test that settles it is cheap: replay a few hundred logged production tasks through both models through the Batch API, pinning effort explicitly, and compare cost per completed task, not per token. Then keep watching after cutover, because per-task cost is the number that drifts; our post on AI spend monitoring covers catching that before the invoice does.

If you are weighing that move for an agent or document pipeline already running on Claude, our AI engineering services team can set up the replay harness, pin effort and caching on both models, and give you a per-task cost comparison from your own traffic rather than from a benchmark chart.