Claude Fable 5 API Guide: Model ID, Pricing, Refusals, and Fallback Strategy

Alongside Claude Sonnet 5, another model API users should track closely is Claude Fable 5.

Fable 5 is not a routine minor model update. Anthropic positions it as its strongest broadly available model for difficult reasoning, long-running agents, complex code engineering, knowledge work, and visual understanding. Claude Mythos 5 appears in the same generation, with similar capability, but under limited availability.

For ClaudeAPI users, the practical question is not simply whether Fable 5 is “unlocked.” The production questions are more concrete:

• Is the model available in your actual account and client path?
• Does the price make sense for your workload?
• Do you handle refusals correctly?
• Do you have fallback behavior?
• Does your team have high-value tasks that justify the model?

Timeline: separate model release from access status

This topic needs careful wording because it includes both model release details and access-state changes.

So this article does not describe Fable 5 as universally “unrestricted” for everyone. A better production-safe statement is:

Fable 5's public model specs are documented, and access restoration has been reported,
but ClaudeAPI users should verify availability, pricing, and limits in the console.

Fable 5's public model specs are documented, and access restoration has been reported,
but ClaudeAPI users should verify availability, pricing, and limits in the console.

The short version

The API model ID is:

claude-fable-5

claude-fable-5

Anthropic’s public documentation lists Fable 5 with a 1M-token context window, up to 128k output tokens, and reference pricing of:

$10 / MTok input
$50 / MTok output

$10 / MTok input
$50 / MTok output

Fable 5 is best suited for the hardest, longest, and highest-value tasks. It should not replace every short daily request by default.

Fable 5 vs Sonnet 5

If Sonnet 5 is the main production workhorse, Fable 5 is the specialist you call for the difficult cases.

Fable 5 should not be treated as a simple Sonnet 5 upgrade. It is stronger, more expensive, and comes with more important safety, refusal, and fallback considerations.

Five facts to check before integration

1. Model ID

Use the exact model ID:

claude-fable-5

claude-fable-5

If you use ClaudeAPI, Claude Code, Codex-style tools, OpenCode, Cline, Cursor, LibreChat, Dify, or Open WebUI, confirm whether the platform exposes this exact model ID or uses a provider-side mapping.

Do not assume a model exists just because a client lets you type the string.

2. Specs and pricing

Anthropic’s public model and pricing documentation lists:

For ClaudeAPI publication and production usage, treat Anthropic public pricing as a reference. The actual price, balance deduction, cache billing, concurrency, and access policy should come from the ClaudeAPI console or pricing page.

3. Refusals are successful responses, not transport errors

Fable 5 has stronger safety behavior. Anthropic documentation says that when Fable 5 refuses a request through the Messages API, the response can return:

{
  "stop_reason": "refusal"
}

{
  "stop_reason": "refusal"
}

That is an HTTP 200 response, not a 4xx or 5xx error.

This matters. Code that only checks HTTP status will treat a refusal as a normal completion. Your application should inspect stop_reason.

Example:

response = client.messages.create(
    model="claude-fable-5",
    max_tokens=2048,
    messages=[
        {
            "role": "user",
            "content": "Analyze this repository and propose a migration plan.",
        }
    ],
)

if response.stop_reason == "refusal":
    # Do not treat this as a network failure.
    # Show a clear message or route to a safer fallback path.
    handle_refusal(response)
else:
    print(response.content[0].text)

response = client.messages.create(
    model="claude-fable-5",
    max_tokens=2048,
    messages=[
        {
            "role": "user",
            "content": "Analyze this repository and propose a migration plan.",
        }
    ],
)

if response.stop_reason == "refusal":
    # Do not treat this as a network failure.
    # Show a clear message or route to a safer fallback path.
    handle_refusal(response)
else:
    print(response.content[0].text)

4. Fallback is not optional for user-facing products

Anthropic documentation recommends fallback behavior for Fable 5. A refused request may be routed to another Claude model when appropriate.

There are several ways to implement fallback:

• server-side fallback
• SDK middleware
• manual retry with a different model
• application-level routing based on task type and refusal reason

For real products, start with two layers:

1. If Fable 5 returns stop_reason: "refusal", explain the result clearly to the user.
2. For ordinary safe requests, route to Sonnet 5 or another approved model when fallback is appropriate.

Example:

def choose_fallback_model(task_type: str) -> str:
    if task_type in {"code_review", "migration_plan", "long_document"}:
        return "claude-sonnet-5"
    return "claude-sonnet-4-6"

def choose_fallback_model(task_type: str) -> str:
    if task_type in {"code_review", "migration_plan", "long_document"}:
        return "claude-sonnet-5"
    return "claude-sonnet-4-6"

The fallback should not blindly retry the same request forever. Refusals are policy outcomes, not transient network failures.

5. Fable 5 is not for low-value high-frequency work

Fable 5’s price and capability profile point to high-value work:

• large code migrations
• multi-file refactors
• complex data analysis
• legal, financial, or research documents
• multi-stage agent workflows
• vision + code + file reasoning tasks

For simple classification, short summaries, fixed-format extraction, or routine support replies, use lower-cost models first.

How ClaudeAPI users should roll out Fable 5

Use a conservative rollout path:

1. Confirm whether Fable 5 is available in the ClaudeAPI console.
2. Do not replace production defaults immediately.
3. Create a test key or staging environment.
4. Select only high-value tasks for A/B testing.
5. Log token usage, latency, refusal rate, retry rate, and human rework.
6. Set a separate budget and concurrency limit for Fable 5.
7. Handle stop_reason: "refusal".
8. Configure fallback to Sonnet 5, Sonnet 4.6, or another approved model.

The right role for Fable 5 is not “site-wide default.” It is “critical-task specialist.”

Suggested model routing

If a task is not expensive to get wrong, it probably does not need Fable 5. If a task is expensive to get wrong and requires long context or deep reasoning, Fable 5 becomes more interesting.

Production logging checklist

Before enabling Fable 5 for real users, log:

Without these fields, you will not know whether Fable 5 improved quality, increased refusal rate, or simply raised cost.

Common mistakes

Mistake 1: Calling it a universal unlock

Access status depends on provider path, account, geography, policy, and console availability. Write and operate as if availability must be verified.

Mistake 2: Treating refusals as errors

stop_reason: "refusal" is not a broken HTTP request. It is a successful response with a refusal outcome. Handle it explicitly.

Mistake 3: Replacing Sonnet for every task

Fable 5 is stronger, but it is not a default cost-control model. Keep routine traffic on cheaper models unless tests prove a meaningful quality gain.

Mistake 4: No fallback path

User-facing systems need predictable behavior. Fable 5 should sit inside a routing and fallback system, not at the end of a single fragile API call.

Mistake 5: No budget cap

Long context, long output, and agent loops can multiply cost quickly. Set max tokens, max rounds, concurrency limits, and per-task budgets.

Example: Fable 5 with refusal-aware fallback

import os
import anthropic

client = anthropic.Anthropic(
    api_key=os.environ["CLAUDE_API_KEY"],
    base_url="https://gw.claudeapi.com",
)

def call_model(model: str, prompt: str):
    return client.messages.create(
        model=model,
        max_tokens=2048,
        messages=[{"role": "user", "content": prompt}],
    )

def run_high_value_task(prompt: str):
    primary = call_model("claude-fable-5", prompt)

    if primary.stop_reason != "refusal":
        return primary

    # Fallback only when your product policy says fallback is appropriate.
    fallback = call_model("claude-sonnet-5", prompt)
    return fallback

import os
import anthropic

client = anthropic.Anthropic(
    api_key=os.environ["CLAUDE_API_KEY"],
    base_url="https://gw.claudeapi.com",
)

def call_model(model: str, prompt: str):
    return client.messages.create(
        model=model,
        max_tokens=2048,
        messages=[{"role": "user", "content": prompt}],
    )

def run_high_value_task(prompt: str):
    primary = call_model("claude-fable-5", prompt)

    if primary.stop_reason != "refusal":
        return primary

    # Fallback only when your product policy says fallback is appropriate.
    fallback = call_model("claude-sonnet-5", prompt)
    return fallback

This example is intentionally simple. In production, also log stop_reason, model choice, token usage, latency, and whether fallback was used.

Conclusion

Fable 5 is worth covering, but it should be described carefully.

It is not a model for making every request cheaper or faster. It is a model for the hardest tasks, longest chains, and highest-value workflows. For ClaudeAPI users, the important questions are availability, pricing, refusal handling, fallback, and task fit.

If those checks are missing, Fable 5 can create higher costs and less predictable behavior. If it is placed inside model routing, budget controls, and safety-aware fallback, it can become a powerful tool for the work that actually needs it.

Sources

• Anthropic Claude Fable page
• Introducing Claude Fable 5 and Claude Mythos 5
• Prompting Claude Fable 5
• Anthropic news: Claude Fable 5 and Mythos 5
• Original Chinese ClaudeAPI article