The standard price is $8 per million input tokens and $40 per million output tokens—20% less than Fable 5.1’s $10 and $50. Anthropic released Claude Fable 5.2 on 2026-11-09, and its model page, release notes, and fast mode documentation all list the prices. This article was verified on 2026-11-10 Beijing time. Prices and availability may change.
This isn’t an estimate. The figures in the table come from official model, pricing, and fast mode pages. Any figures calculated using a pricing rule are labeled “calculated at 50% of standard pricing” or “estimated based on the multiplier.”
Key takeaway: By the end of this article, you’ll have a Claude Fable 5.2 pricing table you can copy straight into your budget, an example calculation clearly marked as an example, and a list of items to confirm before placing an order.
Claude Fable 5.2 Pricing: Key Points
First, let’s clarify the relationship between Fable and Mythos. The launch post says: Claude Fable and Claude Mythos are the same underlying model. Fable has stronger cybersecurity and biosafety safeguards, so it’s available to all users. Mythos is available only to organizations in projects that have passed life sciences or cybersecurity vetting. The two have the same pricing; Mythos isn’t a separate, more powerful model.
The table below lists all Claude Fable 5.2 pricing, in US dollars per million tokens:
| Pricing item | Price (USD / million tokens) | Notes |
|---|---|---|
| Standard input | $8 | 20% less than Fable 5.1’s $10 |
| Standard output | $40 | 20% less than Fable 5.1’s $50 |
| 5-minute cache write | $10 | Listed separately by the official pricing page |
| 1-hour cache write | $16 | Listed separately by the official pricing page |
| Cache read | $0.20 | 2.5% of the standard input price |
| Batch input / output | $4 / $20 | Calculated at 50% of standard pricing |
| Fast mode input / output | $16 / $80 | Listed separately by the official pricing page; same intelligence |
Claude Fable 5.2 Specs and Model IDs
Your budget will also depend on the context and output limits. According to the model page, Claude Fable 5.2 has a 1M-token context window and a maximum output of 128K tokens for synchronous Messages API requests. It accepts text and images as input and generates text as output. Its latency tier is Moderate, adaptive thinking is always on, and its reliable knowledge cutoff is June 2026.
The model page notes that some models on the Message Batches API can raise the output limit to 300K using a beta header. Fable 5.2 isn’t on that list, so don’t budget for 300K output per request.
Model IDs by platform:
- Claude API, Google Cloud, Microsoft Foundry, Claude Platform on AWS:
claude-fable-5-2 - Amazon Bedrock:
anthropic.claude-fable-5-2 - Mythos 5.2 API ID:
claude-mythos-5-2; on Bedrock:anthropic.claude-mythos-5-2
Claude Fable 5.2 Pricing Compared with Fable 5.1 and Opus 5.5
Many teams compare Fable 5.2 with the previous-generation Fable 5.1 and the contemporaneous Opus 5.5. The table below includes only figures provided in the reference materials; any missing figures are marked “Not listed.”
| Model | Standard input | Standard output | 5-minute cache write | 1-hour cache write | Cache read | Fast mode |
|---|---|---|---|---|---|---|
| Fable 5.2 | $8 | $40 | $10 | $16 | $0.20 | $16 / $80 |
| Fable 5.1 | $10 | $50 | Not listed in the reference materials | Not listed in the reference materials | $0.25 | Not listed in the reference materials |
| Opus 5.5 | $4 | $20 | $5 | $8 | $0.20 | $8 / $40 |
Two takeaways stand out:
- The cache-read prices are the same in dollar terms: Fable 5.2 and Opus 5.5 both cost $0.20. Cache reads are 2.5% of Fable’s input price and 5% of Opus 5.5’s. Their base prices differ, so the resulting cache-read prices happen to be equal.
- All other prices are 2×: Fable 5.2 costs twice as much as Opus 5.5 for standard input, standard output, both cache-write durations, and fast mode.
Fable 5.1’s cache-read price is also 2.5% of its input price, but its base price is $10, making cache reads $0.25. When you switch from 5.1 to 5.2, the cache-read price drops by 20% along with the base price.
How to think about Claude Fable 5.2’s cost efficiency
A model costing twice as much per token doesn’t necessarily cost twice as much per task. According to Anthropic’s announcement on 2026-11-09, Fable 5.2 scored around 45.3% on FrontierCode 2.0 at the High effort level, close to Opus 5.5’s best score of 45.5%, while costing about half as much per task. These figures come from Anthropic, not an independent retest, and apply only to this benchmark.
The announcement recommends starting with Opus 5.5 for most coding and knowledge work, then moving up to Fable or Mythos for more difficult tasks—or down to Sonnet 5.5 or Haiku 5.5. Fable 5.2 can also serve as an advisor or orchestrator, assigning simpler tasks to smaller models. This tiered approach is often more cost-effective than using Fable throughout the entire workflow.
Claude Fable 5.2: A Sample Cost Calculation
Here’s an example—not a benchmark—to show how the different billing items add up.
Suppose a task uses 1 million input tokens and 100,000 output tokens:
- Standard pricing: 1 million input tokens × $8 per million = $8; 100,000 output tokens × $40 per million = $4, for a total of $12.
- All 1 million input tokens are cache hits: 1 million cache-read tokens × $0.20 per million = $0.20; output still costs $4, for a total of $4.20.
This example only counts the input and output listed above. It doesn’t include any other fees. In a real bill, the first cache write is charged at the cache-write rate, and the hit rate won’t always be 100%. Use this example to understand how the bill is structured, then plug in your own usage.
Effort levels affect Claude Fable 5.2’s output token count
Adaptive thinking is always on in Fable 5.2 and can’t be turned off. To make it think less, you can only adjust the effort level; prompt instructions won’t help. The update notes say that at medium effort or higher, phrases like “don’t think, just answer” won’t stop it from thinking.
The default effort level varies by entry point:
- The default effort level for the Claude API is
high. - The default effort level for the Claude app and Claude Code is Medium.
Effort level affects the number of output tokens, so it also affects the bill. How much you actually save depends on the task—you can’t treat any one level as a fixed discount. Also, unless otherwise noted, the results table in the announcement post uses each model’s highest effort level at the time, not its default. Keep that in mind when estimating costs from the results.
Claude Fable 5.2 Fast Mode Pricing
Fast mode uses the same model with a faster inference configuration. Its intelligence and capabilities are unchanged, but it can generate output up to 2.5 times faster than standard mode. It costs twice as much as the standard rate: $16 for input and $80 for output. Mythos 5.2 is also $16 / $80, while Opus 5.5 fast mode is $8 / $40.
The fast mode page says that prompt caching multipliers are applied on top of fast mode pricing, but the docs don’t provide a separate fast mode cache pricing table. The fast mode cache prices below are calculated using those multipliers:
| Billing item | Standard mode | Fast mode | Source of fast mode price |
|---|---|---|---|
| Input | $8 | $16 | Listed separately by the provider |
| Output | $40 | $80 | Listed separately by the provider |
| Cache reads | $0.20 | $0.40 | Calculated using the multiplier ($16 × 0.025) |
| 5-minute cache writes | $10 | $20 | Calculated using the multiplier ($16 × 1.25) |
| 1-hour cache writes | $16 | $32 | Calculated using the multiplier ($16 × 2) |
How to Use Claude Fable 5.2 Fast Mode
Each platform has a different way to enable fast mode:
- Claude API: Add the
speedfield to the request and set it tofast. - Microsoft Foundry: Use a different model ID ending in
-fast; don’t includespeedin the request. - Availability: The announcement lists Claude Code, Claude Platform, Anthropic-hosted and Google-hosted Claude Models on Google Cloud, and Anthropic-hosted models on Microsoft Foundry. Amazon Bedrock isn’t listed as supporting fast mode, but the standard model is available on Bedrock.
There’s another detail that affects your bill: prompt caches aren’t shared between speeds. Switching from fast mode back to standard mode results in a cache miss, and any previously written cache has to be written again. Workflows that frequently switch between the two speeds will see a noticeable drop in cache hit rates.
The announcement also says Fable 5.2 generates output up to 30% faster than Fable 5.1. This doesn’t conflict with its Moderate latency tier: the former compares generation speed with version 5.1, while the latter indicates its relative tier within the current product line.
A Few Things to Check Before Ordering Claude Fable 5.2
The following items aren’t pricing details, but they can affect whether your requests succeed, as well as your bill and compliance requirements:
| Item | Official guidance | Impact on budget or integration |
|---|---|---|
| Refused requests | Returns HTTP 200 with stop_reason set to refusal |
Whether a refusal is billed depends on the refusal category. All refused requests count toward rate limits. |
| Data retention | Retained for 30 days by default | This isn’t zero data retention. If your use case requires zero data retention, confirm authorization first. |
| Sampling parameters | Setting temperature, top_p, or top_k returns 400 |
Remove these fields when migrating from older models. |
| Forced tools | Setting tool_choice to any or tool returns 400 |
Workflows that rely on forced tool calls will need to be rewritten. |
| Safety fallback | Requests blocked for cybersecurity topics are answered by Opus 4.8; requests blocked for biological topics are answered by Opus 5 | Some requests are actually answered by a different model. |
The captured article text doesn’t specify the refusal billing categories or say which, if any, are free. Leave some room in your budget rather than assuming refused requests are always free.
For data retention, Fable 5.2 and Mythos 5.2 require 30-day retention unless Anthropic explicitly authorizes otherwise. The announcement says enterprises can conduct private testing through Enterprise Frontier Safeguards. Eligible customers can still use zero data retention before they connect to this monitoring system. Data from other customers is retained for 30 days for safety monitoring.
There’s also a capability limitation that can affect your budget. Capabilities directly related to AI research and development—such as accelerator kernel optimization and improving Large Language Model architectures—are intentionally limited to around the level of Opus 5.5. For a small number of topics, the model transparently falls back to Opus 5 during reasoning. This isn’t a failed request, but if those topics are central to your use case, Fable 5.2 may deliver results similar to Opus 5.5 at Fable 5.2 prices.
Which Models You Can Use with Claude Fable 5.2—and Which Aren’t Available Yet
The short version: As of November 10, 2026, we checked APIYI’s model list (docs.apiyi.com/models.md) and public pricing API (api.apiyi.com/api/pricing). Neither listed claude-fable-5-2, and neither listed any Mythos models. The pricing API returned 283 models that day. We didn’t make any live calls using an API key. We’ll launch this model as soon as possible. Check the platform’s model list for the latest model IDs and prices.
Until Fable 5.2 is available, this article won’t list an APIYI price for it or apply a group multiplier to its official price. The table below shows models that were already available in the model list that day and can be used to compare against Fable 5.2’s official price:
| Model | Input | Output | Cache read | Endpoints | Available platform |
|---|---|---|---|---|---|
claude-fable-5-2 |
Not available | Not available | Not available | — | Official channels; coming soon to APIYI apiyi.com |
claude-opus-5-5 |
$4 | $20 | $0.2 | chat, messages | APIYI apiyi.com |
claude-fable-5-1 |
$10 | $50 | $0.25 | chat, messages | APIYI apiyi.com |
claude-fable-5 |
$10 | $50 | $1 | chat, messages | APIYI apiyi.com |
gpt-6-astra |
$10 | $50 | $1 | responses (primary), chat | APIYI apiyi.com |
A few notes:
claude-opus-5-5,claude-fable-5-1, andclaude-fable-5each have a corresponding-thinkingversion at the same price.- The footnote for
gpt-6-astraonly specifies input pricing tiers: $10 per million input tokens from 0 to 272,000 tokens, and $20 per million from 272,001 to 1,050,000 tokens. The footnote doesn’t specify output pricing for long contexts; refer to your console bill. - The dollar amounts in the model list are listed prices. Actual charges also depend on the token group multiplier; refer to your bill.
Get Your Claude Integration Working with APIYI First
To get your integration pipeline working before Fable 5.2 launches, test with an available model first. Once the new model is available, you’ll only need to change the model ID:
- Sign up at APIYI apiyi.com to get an API key and free testing credits for new users.
- Set the
base_urlfor your OpenAI-compatible client tohttps://api.apiyi.com/v1, and choose the chat or messages endpoint. - Start with
claude-opus-5-5orclaude-fable-5-1, and verify that requests and billing fields are working as expected. - Remove
temperature,top_p, andtop_kin advance, and check for forced tool calls to avoid 400 errors after switching to Fable 5.2. - Once Fable 5.2 is available, check the platform’s model list for the correct ID and price, then switch models.
Integration tip: Fable 5.2 costs twice as much per unit as Opus 5.5. You can first run your real tasks with
claude-opus-5-5on APIYI apiyi.com and record the input and output token counts. Once Fable 5.2 is available, run the same tasks on both models and compare the cost per task to decide where an upgrade is worthwhile.
Claude Fable 5.2 Pricing FAQ
Q1: What’s the standard price for Claude Fable 5.2?
It costs $8 per million input tokens and $40 per million output tokens—20% less than Fable 5.1’s $10 and $50. Mythos 5.2 has the same pricing.
Q2: Is Claude Fable 5.2 smarter in fast mode?
No. Fast mode uses the same model with a faster inference configuration, so its intelligence and capabilities are unchanged. It can generate output up to 2.5 times faster, but costs twice as much as standard mode ($16 / $80).
Q3: Is Fable 5.2 batch pricing the same as Opus 5.5 standard pricing?
Only for input and output tokens. With the 50% batch discount, Fable 5.2 costs $4 per million input tokens and $20 per million output tokens—the same as Opus 5.5’s standard input and output rates. Other items, such as cache writes, can’t be compared this way, and the models themselves are different.
Q4: Why isn’t Claude Fable 5.2’s cache read rate one-tenth of its input rate?
For the Fable tier, cache reads cost 2.5% of the standard input rate, so the calculation is $8 × 0.025 = $0.20. Fable 5.1 also uses a 2.5% rate, which works out to $0.25. Opus 5.5 and Sonnet 5.5 use a 5% rate; for Opus 5.5, that also works out to $0.20.
Q5: How is caching priced in fast mode?
The cache multipliers are applied to fast mode prices. Based on those multipliers, cache reads cost $0.40, 5-minute cache writes cost $20, and 1-hour cache writes cost $32. The official site doesn’t list a separate pricing table for these rates. Also, caches aren’t shared between speed modes, so switching modes can result in cache misses.
Q6: Can I call Claude Fable 5.2 through APIYI now?
Not as of 2026-11-10. The model catalog and pricing API don’t include `claude-fable-5-2` yet. We’ll make this model available as soon as possible; check the platform’s model list for the available model IDs and prices. In the meantime, you can use `claude-opus-5-5` or `claude-fable-5-1` on APIYI apiyi.com to test your integration.
Q7: Do rejected requests incur a charge?
If a request is rejected before generating output, whether it’s billed depends on the rejection category, but it still counts toward rate limits. The official documentation we checked doesn’t specify the categories or which ones are free, so that’s currently unknown.
Claude Fable 5.2 Pricing: Key Takeaways
- Standard pricing: $8 for input and $40 for output—20% less than Fable 5.1.
- Caching: $10 for a 5-minute write, $16 for a 1-hour write, and $0.20 for a read. The read price is 2.5% of the input price.
- Batch processing: Half the standard price, or $4 for input and $20 for output.
- Fast mode: $16 / $80. Intelligence is unchanged, speed can reach up to 2.5×, and the field is
speed: fast. - Compared with Opus 5.5: Cache reads cost the same at $0.20; all other Fable 5.2 prices are 2× higher.
- Effort level: The API defaults to high, while the app and Claude Code default to Medium. The selected level affects output tokens.
- Availability: As of 2026-11-10, APIYI hadn’t listed Fable 5.2 yet. Check the platform’s model list for the latest status.
Summary
To budget for Claude Fable 5.2, keep three things in mind:
- Pricing: Standard pricing is $8 / $40. Cache reads cost $0.20. Batch processing is half price at $4 / $20, and fast mode costs $16 / $80.
- Variables: The effort level affects output tokens, switching speed modes invalidates the cache, and rejected requests still count toward rate limits.
- Requirements: Data is retained for 30 days by default. You can’t set sampling parameters or force tool use, so check whether these limitations affect your business before placing an order.
For example, 1 million input tokens plus 100,000 output tokens costs $12 at standard rates, or $4.20 if all input tokens hit the cache. To estimate your actual costs, plug in your own workload.
Author: APIYI Technical Team
Technical note: Pricing and availability were checked on 2026-11-10. Refer to the official pricing page and the platform’s model list for the latest information.
