Claude Fable 5.2 costs $8 per million input tokens and $40 per million output tokens through Anthropic's standard API. LinkModel offers Claude Fable 5.2 at $6.80 per million input tokens and $34 per million output tokens, with 15% lower rates across standard input, output, and prompt caching. But for coding agents and complex research tasks, the advertised token rate is only part of the total cost.
Claude Fable 5.2 is 20% cheaper per standard input and output token than Fable 5.1, yet it remains twice as expensive as Opus 5.5 on those rates. Anthropic's published evaluations show that Fable can achieve comparable or stronger results at lower task costs in certain configurations. Understanding cost per successful task, reasoning effort, caching, and retries helps developers decide when that higher token price is justified.
For developers looking to control standard API spending, LinkModel provides 15% lower published Fable 5.2 token rates, unified model access, $0 minimum spend, and $0 monthly platform fee. New users automatically receive $1 in free Credits after registration, without payment-card binding or recharging. This one-time benefit is available only to new users, cannot be claimed repeatedly by existing users, does not expire, and applies to all models currently available on LinkModel.
Claude Fable 5.2 Pricing: Official API vs LinkModel
Claude Fable 5.2 uses token-based pricing, with separate charges for regular input, output, cache reads, and cache creation.
At standard rates, Anthropic charges $8 input and $40 output per million tokens, while LinkModel publishes corresponding rates of $6.80 and $34.
Complete Claude Fable 5.2 API Pricing Table
All prices below are USD per 1 million tokens.
| Token Type | Anthropic Official | LinkModel | Savings |
|---|---|---|---|
| Input | $8.00 | $6.80 | 15% |
| Cached input | $0.20 | $0.17 | 15% |
| Cache write (5 minutes) | $10.00 | $8.50 | 15% |
| Cache write (1 hour) | $16.00 | $13.60 | 15% |
| Output | $40.00 | $34.00 | 15% |
At these standard rates, every million regular input tokens costs $1.20 less through LinkModel. Every million output tokens costs $6 less.
This matters for applications with long generated responses or substantial reasoning output. The absolute savings increase as billable token consumption grows.
Prompt caching can reduce the cost of repeated context even further. Cached input is substantially cheaper than ordinary input, although creating cached content incurs a separate write charge.
Official pricing reference: https://platform.claude.com/docs/en/about-claude/pricing
LinkModel model pricing: https://www.linkmodel.ai/models/claude-fable-5-2
Standard API vs Batch and Fast Mode
Anthropic offers alternative processing modes with different cost and latency tradeoffs.
| Anthropic API Mode | Input / 1M | Output / 1M | Main Use |
|---|---|---|---|
| Standard | $8 | $40 | General interactive requests |
| Batch API | $4 | $20 | Asynchronous, high-volume workloads |
| Fast Mode | $16 | $80 | Speed-sensitive output generation |
Batch API reduces the standard input and output rates by 50%, making it useful when requests do not require an immediate response.
Fast Mode doubles the standard rates but can deliver output generation up to 2.5 times faster under Anthropic's documented conditions.
Fast Mode and Batch API are separate processing options and cannot be combined.
Claude Fable 5.2 vs Fable 5.1, Opus 5.5 and Sonnet 5.5
Claude Fable 5.2 was released on November 9, 2026, for demanding reasoning and long-horizon agentic work.
Anthropic recommends starting with Opus 5.5 for most everyday coding and knowledge tasks, moving to Fable when the task requires stronger capabilities.
Official Claude Model Pricing Comparison
| Claude Model | Input / 1M | Output / 1M | Typical Positioning |
|---|---|---|---|
| Fable 5.1 | $10 | $50 | Previous Fable generation |
| Fable 5.2 | $8 | $40 | Difficult technical and agentic work |
| Opus 5.5 | $4 | $20 | Advanced everyday coding and knowledge work |
| Sonnet 5.5 | $2 | $10 | Cost-sensitive general development |
Fable 5.2 is 20% cheaper than Fable 5.1 on standard input and output rates.
However, it costs twice as much as Opus 5.5 and four times as much as Sonnet 5.5 for the same regular input and output token quantities.
The decisive question is whether Fable's stronger execution on a difficult task reduces total consumption, retries, or rework enough to justify its higher unit rate.
FrontierCode 2.0: Coding Accuracy vs Cost
Anthropic evaluated Fable 5.2 using FrontierCode 2.0, an agentic software engineering benchmark.
The benchmark assesses proposed code changes in open-source repositories according to whether maintainers would merge them. Its accuracy-versus-cost chart compares model results across specified effort configurations.
| Model Configuration | FrontierCode 2.0 Score | Reported Cost Relationship |
|---|---|---|
| Fable 5.2 — High | 45.3% | Approximately half of Opus Max task cost |
| Opus 5.5 — Max | 45.5% | Comparison baseline |
| Fable 5.2 — Xhigh | 49.1% | Higher reported accuracy |
At High effort, Fable 5.2 scored 45.3%, nearly matching Opus 5.5 at Max effort, which scored 45.5%.
Anthropic reported that the Fable High configuration achieved this result at roughly half the cost per task.
This comparison uses different effort settings, rather than demonstrating a price advantage at identical settings. It shows that a higher-priced model can produce a favorable cost-quality balance under a particular workload and configuration.
At Xhigh effort, Fable reached 49.1%, its strongest reported FrontierCode 2.0 result.
For developers, the practical lesson is to compare completed coding outcomes and total execution costs at explicitly identified effort settings.
Official figure: FrontierCode 2.0 — Accuracy vs. Cost.
Source: https://www.anthropic.com/claude-fable-and-mythos-5-2
WANDR and Chartography: More Evidence on Task Efficiency
Anthropic also evaluated Fable 5.2 on agentic data collection and visual chart understanding, two workloads relevant to research and automation.
WANDR — Large-Scale Agentic Search
Perplexity's WANDR benchmark evaluates agents performing large data-collection tasks.
Anthropic reports that Fable 5.2 at Medium effort matched Opus 5.5's best relaxed-score result at approximately 40% of the task cost.
The evaluation measures task-specific search performance, rather than a generic API discount.
This suggests that Fable may be economically attractive for complex information-gathering workflows when its execution efficiency offsets the higher per-token rate.
Official figure: WANDR (relaxed score) — Accuracy vs. Cost.
Chartography — Visual Chart Understanding
Chartography measures how accurately models interpret charts and figures, without tools in the reported comparison.
Fable 5.2 at Medium effort scored 66.4%, compared with 64.4% for Opus 5.5 at Max effort.
Anthropic reported that Fable achieved this result at less than one-tenth of the task cost in the evaluated configurations.
The broader benchmark table reports a Fable 5.2 score of 73.4% at its highest available tested effort. This is a different configuration from the Medium-effort cost comparison.
Official figure: Chartography (no tools) — Accuracy vs. Cost.
These benchmarks provide useful examples of how task type and effort change model economics. They do not imply that all workloads receive the same percentage savings.
How Anthropic's Evaluations Should Be Interpreted
To compare benchmark costs meaningfully, developers need to know four details: the task, the scoring method, the effort configuration, and the cost denominator.
FrontierCode 2.0 evaluates code-change acceptance criteria. WANDR uses a relaxed-score measure for data-collection tasks. Chartography evaluates chart understanding without tools.
Anthropic's cost comparisons use the evaluated task and configuration as the unit of analysis. The resulting cost ratio is different from the standard per-million-token price ratio.
BenchCAD 2.1 provides an additional example of technical capability. In Anthropic's hardware-engineering evaluation with tools, Fable 5.2 at Max effort scored 83.5, ahead of Opus 5.5 at 65.3. The benchmark awards partial credit for how closely generated designs match reference geometry and circuits.
The official results help identify tasks worth evaluating with Fable. They are Anthropic-reported benchmarks and should be considered alongside independent measurements and the requirements of the developer's actual application.
How Much Does Claude Fable 5.2 Cost per Task?
A Fable 5.2 task can involve multiple calls, extensive context, tool execution, adaptive thinking, and repeated attempts.
For developers, the useful budgeting question is not simply how much one response costs, but how much it costs to reach an acceptable outcome.
Claude Fable 5.2 API Cost Calculator
The standard token-cost formula is:
Estimated API cost = (regular input tokens × input rate + cache-write tokens × write rate + cache-read tokens × read rate + billed output tokens × output rate) / 1,000,000
Separately charged tools or processing services can be added where relevant.
The input categories should represent distinct billed quantities. Thinking tokens included in the billed output total must not be counted a second time.
The following examples use regular input and output tokens, with no cache hits or additional tool charges.
| Example Workload | Input | Output | Anthropic | LinkModel |
|---|---|---|---|---|
| Short coding request | 10,000 | 1,000 | $0.12 | $0.102 |
| Extended research task | 100,000 | 20,000 | $1.60 | $1.36 |
| Multi-step coding agent | 1,000,000 | 200,000 | $16.00 | $13.60 |
The short coding example represents a compact prompt containing code context and a short answer.
The research scenario represents a larger input and a substantial generated response.
The coding-agent example represents aggregate usage across multiple steps, including any reasoning tokens incorporated into the output total.
At the largest illustrated workload, LinkModel saves $2.40 on the displayed standard token charges.
Across 100 identical workload repetitions, the difference becomes $240.
These calculations allow developers to estimate the cost of their own workloads by substituting expected token quantities and cache usage.
How Effort Changes Task Cost
Fable 5.2 uses always-on adaptive thinking. Developers control its reasoning depth through five effort settings.
| Effort | Recommended Application | Cost Consideration |
|---|---|---|
low | Simple, well-defined tasks | Lower reasoning overhead |
medium | Routine interactive work | Use when accepted quality holds |
high | Complex coding and agent tasks | Official API default |
xhigh | Difficult, long-running tasks | Increase only when evaluations show gains |
max | Capability-ceiling evaluations | Highest tolerance for extra cost and time |
Anthropic recommends beginning with high, since much of Fable 5.2's capability is already present at that level.
A higher setting can improve performance on difficult tasks, but it can also increase generated reasoning, tool activity, and latency.
The appropriate effort is therefore the lowest setting that reliably satisfies the task's acceptance criteria.
Cost per Successful Task vs Cost per API Call
A single API call is not necessarily a completed task.
For a coding agent, the final result may need to pass tests, satisfy project requirements, and receive approval. Repeated attempts and corrections consume additional tokens.
A more useful efficiency metric is:
Cost per successful task = Total evaluation cost / Number of accepted tasks
For example, suppose an evaluation of 20 tasks costs $100 and produces 10 accepted results. The measured cost per accepted task is $10.
If a different configuration costs $120 but produces 16 accepted results, its cost per accepted task is $7.50.
These are illustrative arithmetic scenarios, not measured Fable 5.2 success rates.
The comparison demonstrates why lower per-call cost does not automatically mean lower cost per accepted outcome.
For a fair evaluation, use the same task set, acceptance criteria, tool conditions, and measurement period, while recording each configuration's actual spending.
What Independent Evaluation Shows
Artificial Analysis provides a separate reference for Fable 5.2 performance and economics.
In the November 12, 2026 snapshot of its Medium-effort evaluation, the reported results included:
| Metric | Reported Value |
|---|---|
| Intelligence Index | 56 |
| Cost per Intelligence Index task | $3.80 |
| Time per Index task | 7.8 minutes |
| Output speed | 92 tokens/second |
| Time to first answer token | 12.02 seconds |
The $3.80 figure is a benchmark-specific average task cost, not a standard price for an arbitrary API request.
Likewise, an Intelligence Index score of 56 is not equivalent to a 56% success rate on real developer tasks.
This Medium configuration should not be ranked directly against Anthropic's FrontierCode High or Max configurations as though all evaluations used identical workloads and settings.
The useful comparison is between measured task quality, execution time, and total spending under clearly identified test conditions.
Source: https://artificialanalysis.ai/models/claude-fable-5-2-medium
How to Reduce Claude Fable 5.2 API Costs
Developers can control Fable 5.2 spending by reusing eligible context, choosing effort deliberately, reducing unnecessary retries, and using the processing mode appropriate for the workload.
Prompt Caching and Break-Even Analysis
Prompt caching is useful when an application repeatedly sends the same instructions, reference documents, repository context, or other stable material.
Consider a 100,000-token context.
At Anthropic's standard rate, processing that context without caching costs $0.80 per use.
Creating a five-minute cache entry costs $1.00, while each successful cache read costs $0.02.
| Total Uses | Uncached Cost | Five-Minute Cache Cost | Savings |
|---|---|---|---|
| 1 | $0.80 | $1.00 | -$0.20 |
| 2 | $1.60 | $1.02 | $0.58 |
| 5 | $4.00 | $1.08 | $2.92 |
| 11 | $8.80 | $1.20 | $7.60 |
With successful cache hits within the cache lifetime, five-minute caching becomes cheaper from the second total use.
A one-hour cache write costs $1.60 for 100,000 tokens, followed by $0.02 per successful read. Under the same conditions, it becomes cheaper than uncached processing from the third total use.
LinkModel's corresponding five-minute cache prices are $0.85 per 100,000 written tokens and $0.017 per 100,000 cached read tokens.
One write plus ten successful reads therefore costs $1.02 through LinkModel, compared with $1.20 at Anthropic's official rates.
These calculations make prompt caching particularly attractive for repeated long-context agent workflows.
Optimize Effort and Reduce Unnecessary Work
Start with the official API default of high effort for demanding workloads.
Use medium or low when evaluations demonstrate that task quality remains acceptable. Increase to xhigh when a difficult workload benefits from additional reasoning.
Reserve max for ceiling evaluations or tasks where the increased cost and time are justified by the required outcome.
For multi-agent systems, monitor delegation and subagent activity. Anthropic's model guidance notes that subagents can account for a substantial portion of an agent session's cost.
Avoid using the highest effort for routine transformations that can be completed reliably by a lower-cost model.
Choose the Right Model and Processing Mode
For most everyday coding and knowledge work, Anthropic recommends starting with Opus 5.5.
Move to Fable 5.2 when the task's complexity and observed success rate justify the higher standard token price.
For asynchronous workloads, Anthropic's Batch API provides a lower-cost processing option. When interactive output speed is the priority, Fast Mode offers a premium alternative.
The best economic outcome comes from matching the model, effort setting, and execution strategy to the actual workload—not from minimizing the unit token rate in isolation.
Is Claude Fable 5.2 Included in Pro, Max or Ultra?
Claude subscriptions and developer API billing are separate. A Claude app subscription does not automatically provide unlimited API access.
Fable availability and billing depend on the plan, seat type, and applicable usage rules.
Claude Subscription vs API Billing
| Access Method | Fable 5.2 Access |
|---|---|
| Claude Free | Not included |
| Claude Pro | Normally uses separate usage credits |
| Claude Max / Ultra | Included within applicable plan usage limits |
| Team standard seats | Normally uses usage credits |
| Team premium seats | Included within applicable plan limits |
| Enterprise | Depends on seat type and billing model |
| Anthropic API | Separately metered developer API |
| LinkModel API | Published model-specific token pricing |
For eligible premium seats, Fable can consume up to 50% of the applicable weekly plan usage allowance without separate usage-credit charges within that allowance.
This represents a share of the existing weekly limit, not an additional 50% of usage.
Enterprise terms depend on the specific seat and billing arrangement. Standard seats and usage-based Enterprise configurations can follow different rules.
November 2026 Launch Promotion
Anthropic introduced temporary Fable 5.2 launch benefits beginning November 9, 2026.
Eligible Pro subscribers and standard Team seats can use Fable models within up to 50% of their weekly limits during the promotion ending November 16, 2026, at 11:59 p.m. Pacific Time.
Eligible accounts may also receive a Fable-specific usage-limit reset under the launch conditions.
After the promotional period, the regular plan and usage-credit rules apply.
These subscription benefits do not provide unlimited free developer API requests.
Official source: https://support.claude.com/en/articles/17506494-claude-fable-5-2-launch-offers
Anthropic API vs LinkModel: Pricing and Developer Decisions
For workloads using the published standard Claude Fable 5.2 token categories, LinkModel offers 15% lower rates than Anthropic's official prices.
That difference is straightforward to calculate and becomes more meaningful as usage scales.
How Much Can Developers Save on LinkModel?
Consider an application consuming 5 million regular input tokens and 1 million output tokens.
| Cost Component | Anthropic | LinkModel |
|---|---|---|
| Input | $40.00 | $34.00 |
| Output | $40.00 | $34.00 |
| Total | $80.00 | $68.00 |
The same billed token quantities cost $12 less through LinkModel.
If the workload repeats ten times with identical consumption, Anthropic's standard rates produce $800 in token charges, compared with $680 on LinkModel.
That is $120 in savings.
LinkModel also offers unified model access and billing, $0 minimum spend, and $0 monthly platform fee. Developers can compare supported AI models within a shared billing environment instead of maintaining separate billing workflows for each provider.
What Should Developers Check Before Switching API Providers?
Claude Fable 5.2 supports a 1-million-token context window, 128,000 maximum output tokens, and always-on adaptive thinking.
Its official Anthropic API model ID is claude-fable-5-2.
Before switching providers or migrating applications from earlier Claude models, developers should verify the following compatibility requirements.
Model ID and request format. Use the model identifier, authentication format, and request structure published for the chosen provider. An Anthropic model ID should not automatically be assumed to match a third-party provider's identifier.
Adaptive thinking. Fable 5.2 always uses adaptive thinking. Explicit legacy thinking settings that enable thinking with budget_tokens or disable it produce a 400 error on the official API.
Effort settings. The official API supports low, medium, high, xhigh, and max, with high as the default. Feature availability and request syntax should be checked for each provider.
Tool choice. Forced tool selection using any or a named forced tool is unsupported on the official API. Use compatible automatic tool selection and supported structured-output options where appropriate.
Sampling parameters. Anthropic instructs developers to omit temperature, top_p, and top_k for this model. Unsupported combinations can produce 400 errors.
Conversation history and thinking blocks. Preserved thinking blocks have account and model-compatibility constraints. Editing earlier conversation content can invalidate the required history prefix, so applications should test multi-turn requests before migrating production sessions.
Computer-use tools. The supported toolset is computer_toolset_20260801. The older computer_20251124 tool is not accepted on most platforms, with a documented Amazon Bedrock exception.
Advisor and subagent configuration. When Fable 5.2 is the executor, the official advisor tool requires a compatible Fable 5.2 or Mythos 5.2 advisor. Agent applications should also inspect the additional token consumption from delegated work.
Rate limits and data requirements. Check the destination model's rate limits, region, retention requirements, and available request features. Anthropic's official documentation specifies model-specific data-retention restrictions, including a 30-day retention requirement unless expressly authorized otherwise.
The practical migration path is to validate a small request, confirm multi-turn and tool behavior, then compare complete task execution and billed usage under the application's real requirements.
For LinkModel, consult its published configuration and compatibility guidance rather than assuming every Anthropic-specific beta feature or header is passed through identically.
Official source: https://platform.claude.com/docs/en/models/fable-5-2/whats-new-fable-5-2
When Is Fable 5.2 Worth Its Higher Token Price?
Choose Opus 5.5 first when everyday coding and knowledge work can be completed reliably at its lower standard token rates.
Consider Fable 5.2 when complex reasoning, long-running coding, or multi-step research benefits measurably from its stronger task performance.
Use cost per accepted outcome when comparing agent configurations, especially when retries, human review, and tool activity contribute materially to the final expense.
For supported standard Fable 5.2 token workloads, LinkModel's 15% lower published rates provide a direct way to reduce the associated token charges.
Frequently Asked Questions
How much does Claude Fable 5.2 cost per million tokens?
Anthropic charges $8 per million input tokens and $40 per million output tokens at standard API rates. LinkModel lists $6.80 input and $34 output per million tokens, representing 15% lower published rates. Cache reads and writes are billed separately.
Is the Claude Fable 5.2 API free?
Anthropic's developer API uses metered billing, and Claude subscriptions do not automatically include unlimited API calls. LinkModel offers a one-time registration credit for eligible new users, which can be applied to models currently available on the platform.
Are Claude Fable 5.2 thinking tokens charged as output?
Thinking tokens contribute to billed output usage. The reasoning effort setting can change token consumption and total execution cost. If the reported output total already includes reasoning tokens, they should not be counted twice.
What is the difference between Fable 5.2 and Opus 5.5 pricing?
Fable 5.2 costs $8 input and $40 output per million tokens, while Opus 5.5 costs $4 input and $20 output. Fable has twice the standard input and output token rates, although specific benchmarks demonstrate that task-completion efficiency can favor Fable under particular configurations.
How can I reduce Claude Fable 5.2 API costs?
Reuse eligible context through prompt caching, select effort based on observed task requirements, avoid unnecessary repeated execution, and evaluate lower-cost models for routine work. For the listed standard token categories, LinkModel also publishes rates 15% below Anthropic.
Conclusion
Claude Fable 5.2 combines advanced reasoning and agentic capabilities with standard API prices of $8 per million input tokens and $40 per million output tokens. Anthropic's FrontierCode, WANDR, and Chartography evaluations show why developers should compare task outcomes and execution costs instead of relying on unit token prices alone. For production budgeting, the most useful approach is to account for effort, cache reuse, tool activity, and the cost of obtaining an accepted result. Developers who choose Fable 5.2 for supported standard token workloads can use LinkModel's 15% lower published rates, unified model access, and usage-based billing to reduce token spending. Review the Claude Fable 5.2 model page to compare the current rates and plan a workload.
