Key takeaways
- Model ID:
claude-fable-5-2. Released November 9, 2026, with a 1M-token context window and up to 128K output tokens per request. - Price: $8 / $40 per million input/output tokens on Anthropic's API, 20% below Fable 5.1. On PoYo it costs $6.40 / $32.
- Two ways to call it on PoYo: the Anthropic Messages format at
POST https://api.poyo.ai/v1/messages, or the OpenAI-compatiblePOST https://api.poyo.ai/v1/chat/completions. The official Anthropic SDKs work with the base URL set tohttps://api.poyo.ai. - Thinking is always on. You control depth and cost with
output_config.effort. The default ishigh; usemediumorlowfor routine work. - Thinking is billed as output. A short answer can still use thousands of output tokens at
higheffort, so seteffortexplicitly and sizemax_tokensfor thinking plus the reply. - Read
stop_reasonfirst. It tells you whether the model finished, called a tool, hitmax_tokensor returned a safetyrefusal, so check it before you read the content.
Claude Fable 5.2 API at a glance
| Claude Fable 5.2 | |
|---|---|
| API model ID | claude-fable-5-2 |
| Released | November 9, 2026 |
| Context window | 1M tokens |
| Max output | 128K tokens per request |
| Input → output | Text and images → text |
| Thinking | Adaptive, always on |
| Effort levels | low, medium, high (default), xhigh, max |
| Knowledge cutoff | June 2026 |
| Data retention | 30-day retention |
| Official price (per 1M tokens) | $8 input / $40 output / $0.20 cache read |
| PoYo price (per 1M tokens) | $6.40 input / $32 output / $0.16 cache read |
| PoYo endpoints | /v1/messages, /v1/chat/completions |
Anthropic positions Fable 5.2 for demanding reasoning and long-horizon agentic work, and recommends Claude Opus 5.5 as the starting point for most workloads. If you are still deciding between the two, read Claude Fable 5.2 vs Opus 5.5 first. This guide is about integration.
A prototype operating system built by Claude Fable 5.2 agents, running on a laptop. Video from Anthropic's Claude Fable 5.2 launch materials.
Fable 5, 5.1 or 5.2: which price are you looking at?
Searches for "Claude Fable 5 pricing" can mean any of the three Fable models released in 2026. They share the 1M context window and 128K output limit, and each has its own price:
| Model | Released | Input | Output | Cache read | API model ID |
|---|---|---|---|---|---|
| Claude Fable 5 | June 9, 2026 | $10 | $50 | $1.00 | claude-fable-5 |
| Claude Fable 5.1 | September 1, 2026 | $10 | $50 | $0.25 | claude-fable-5-1 |
| Claude Fable 5.2 | November 9, 2026 | $8 | $40 | $0.20 | claude-fable-5-2 |
Official prices in USD per million tokens. Fable 5.2 is the first price cut in the Fable tier and the current model, so new projects should start there. The rest of this guide covers Fable 5.2.
Pricing in short
| Charge (per 1M tokens) | Anthropic official | PoYo | PoYo credits |
|---|---|---|---|
| Input | $8.00 | $6.40 | 1,280 |
| Output (includes thinking) | $40.00 | $32.00 | 6,400 |
| Cache read | $0.20 | $0.16 | 32 |
| Cache write, 5 minutes | $10.00 | $8.00 | 1,600 |
| Cache write, 1 hour | $16.00 | $12.80 | 2,560 |
PoYo bills pay-as-you-go in credits at $1 = 200 credits, with no subscription. The full 1M context window is billed at standard rates, so a 900K-token prompt costs the same per token as a 9K-token prompt. For every other Claude model, see our Claude API pricing guide.
Quick start
- Create an API key in the PoYo dashboard.
- Send requests to
https://api.poyo.aiwith the model set toclaude-fable-5-2. - Authenticate with
x-api-key: YOUR_KEYon/v1/messages(Authorization: Bearer YOUR_KEYalso works), or withAuthorization: Bearer YOUR_KEYon/v1/chat/completions.
curl (Anthropic Messages format)
curl https://api.poyo.ai/v1/messages \
-H "x-api-key: $POYO_API_KEY" \
-H "anthropic-version: 2023-06-01" \
-H "content-type: application/json" \
-d '{
"model": "claude-fable-5-2",
"max_tokens": 16000,
"output_config": {"effort": "medium"},
"messages": [
{"role": "user", "content": "Find the race condition in this Go worker pool and propose a fix: ..."}
]
}'
The response is a standard Anthropic Message object. The answer is in the text block of content; a thinking block may come first.
Python (Anthropic SDK)
import os
import anthropic
client = anthropic.Anthropic(
base_url="https://api.poyo.ai",
api_key=os.environ["POYO_API_KEY"],
)
with client.messages.stream(
model="claude-fable-5-2",
max_tokens=32000,
output_config={"effort": "medium"},
thinking={"type": "adaptive", "display": "summarized"},
messages=[{"role": "user", "content": "Write a migration plan from REST to gRPC for this service: ..."}],
) as stream:
message = stream.get_final_message()
if message.stop_reason == "refusal":
print("Request declined:", message.stop_details)
else:
for block in message.content:
if block.type == "thinking":
print("Thinking summary:", block.thinking)
elif block.type == "text":
print(block.text)
print(message.usage)
Streaming keeps long requests clear of HTTP timeouts. At high effort and above, a single hard request can run for minutes.
TypeScript (Anthropic SDK)
import Anthropic from "@anthropic-ai/sdk";
const client = new Anthropic({
baseURL: "https://api.poyo.ai",
apiKey: process.env.POYO_API_KEY,
});
const message = await client.messages
.stream({
model: "claude-fable-5-2",
max_tokens: 32000,
output_config: { effort: "medium" },
messages: [{ role: "user", content: "Review this pull request for security issues: ..." }],
})
.finalMessage();
if (message.stop_reason === "refusal") {
console.log("Request declined:", message.stop_details);
} else {
for (const block of message.content) {
if (block.type === "text") console.log(block.text);
}
}
OpenAI-compatible Chat Completions
If your stack already uses the OpenAI request shape, send the same model ID to /v1/chat/completions:
curl https://api.poyo.ai/v1/chat/completions \
-H "Authorization: Bearer $POYO_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"model": "claude-fable-5-2",
"messages": [
{"role": "system", "content": "You are a senior data engineer."},
{"role": "user", "content": "Design a schema for event deduplication in ClickHouse."}
],
"stream": true
}'
With the official OpenAI SDK, set base_url to https://api.poyo.ai/v1. Use /v1/messages when you need Claude-specific controls such as output_config.effort, thinking display, cache_control and Anthropic-style tool definitions.
Effort: the main lever for quality and cost
Fable 5.2 thinks adaptively on every request. The effort setting inside output_config decides how much:
| Effort | Use it for | Notes |
|---|---|---|
low | Quick back-and-forth, well-specified tasks, high-volume subagents | Fastest and cheapest. For long tasks, add a "finish the whole task" instruction |
medium | Interactive coding, chat, everyday knowledge work | A good default for most product traffic |
high (default) | Hard coding, research, agentic work, long unattended runs | Anthropic: most of the capability gain is already present at high |
xhigh | The hardest long-running coding and agent work | Use where your evals show a measured gain; uses more tokens |
max | Measuring the ceiling, or rare tasks where depth matters more than time and tokens | The deepest reasoning and the longest turns |

How effort trades score for cost per task on FrontierCode 2.0. Chart from Anthropic's Claude Fable 5.2 launch materials.
Three practical rules:
- Set effort on every request. Code copied from Opus 5.5 ran at
mediumby default. On Fable 5.2 the same request runs athighand uses more output tokens. - Use effort to set how much it thinks. Anthropic recommends a lower effort level, rather than prompt lines such as "answer directly without deliberating", for faster and cheaper turns. At
highand above, Fable 5.2 thinks before almost every reply, even a greeting. - Use the prompt for answer length. Effort sets the thinking depth; your prompt sets how long the final reply is.
For a measured example of what effort does to the bill, see the hands-on results in Claude Fable 5.2 vs Opus 5.5: on one coding task Fable 5.2 scored the same at medium and high, for roughly a quarter of the cost at medium.
Adaptive thinking: what "always on" means for your code
- Omit
thinking, or send{"type": "adaptive"}. That is the whole thinking setup. Depth comes fromeffort, which replaces the olderbudget_tokensanddisabledsettings. - Thinking tokens are billed as output and count toward
max_tokens. Sizemax_tokensfor thinking plus the reply: 16K is a good floor, and 32K or more with streaming suits hard tasks. - Thinking summaries are opt-in. By default, thinking blocks arrive with an empty
thinkingfield, which keeps streaming fast. Add"display": "summarized"to receive a readable summary. Billing covers the full thinking in both modes. - Let the model handle sampling. Send requests without
temperature,top_pandtop_k; Fable 5.2 manages sampling itself. - Read
usage.output_tokensalready includes thinking, andoutput_tokens_details.thinking_tokensshows the thinking share.
Tool use
Fable 5.2 accepts tool_choice of auto (the default) or none. Name the tool in your prompt when you want it called:
{
"model": "claude-fable-5-2",
"max_tokens": 16000,
"output_config": {"effort": "medium"},
"tools": [
{
"name": "get_order_status",
"description": "Look up an order by its ID and return the shipping status and carrier.",
"input_schema": {
"type": "object",
"properties": {"order_id": {"type": "string"}},
"required": ["order_id"]
}
}
],
"tool_choice": {"type": "auto"},
"messages": [
{"role": "user", "content": "Where is order A-1042? Check it with get_order_status."}
]
}
When the model calls a tool, the response ends with stop_reason: "tool_use". Run the tool, then send a tool_result block back in the next user message. Pass the full assistant turn back unchanged, thinking blocks included.
Other rules worth knowing:
- Use
autoornonefortool_choice. To make sure a tool runs, name it in the prompt. When you need guaranteed JSON, use structured output:output_config.formatwith a JSON schema. - Computer use runs through the
computer_toolset_20260801toolset. - Parse tool inputs with a JSON parser. It handles any escaping style the model uses inside tool arguments.
Robot arms controlled by Claude Fable 5.2 from camera images, solving a puzzle cube. Video from Anthropic's Claude Fable 5.2 launch materials.
1M context and prompt caching
The 1M-token window holds roughly 555,000 English words, enough for a large codebase or a stack of contracts in one request. Fable 5.2 uses the tokenizer introduced with Claude Opus 4.7, which produces more tokens for the same text than pre-4.7 models, so count tokens on your own files before you plan around the limit.
Long prompts are where caching pays off. A cache read on Fable 5.2 costs 2.5% of the input price ($0.20 vs $8 per million tokens). On PoYo, add a top-level cache_control and the last cacheable block is cached automatically:
{
"model": "claude-fable-5-2",
"max_tokens": 16000,
"cache_control": {"type": "ephemeral", "ttl": "1h"},
"output_config": {"effort": "medium"},
"system": "You answer questions about the contract below. Quote clause numbers.\n\n<contract>...</contract>",
"messages": [
{"role": "user", "content": "List every termination right and its notice period."}
]
}
Keep the stable content first (system prompt, tool definitions, the document) and the changing question last. In a multi-turn conversation or an agent loop, each new turn re-reads the earlier prefix from cache. The 5-minute cache costs 1.25× the input price to write and pays off after one read; the 1-hour cache costs 2× and pays off after two.
Two habits keep both the cache and the model's reasoning working across turns:
- Keep the history append-only. Each thinking block is tied to the system prompt, tools and messages that came before it. Keep
systemandtoolsfixed for a conversation and add new turns to the end ofmessages. If earlier turns are edited and the old thinking blocks are sent back, the API's prefix check flags the request with the messageThe block is bound to a different conversation. To change instructions, start a new conversation. - Switch models whenever you like. You can change
modelbetween requests in the same conversation. Fable 5.2's thinking blocks are read by Fable 5.2 and Mythos 5.2; when the conversation moves to another model such as Opus 5.5, the API drops those blocks automatically, the request succeeds, and the new model continues with its own reasoning. Each model keeps its own cache.
Handling refusals
Fable 5.2 runs safety classifiers. When one of them stops a request, the response arrives as HTTP 200 with stop_reason: "refusal" and a stop_details object naming the policy area, for example cyber, bio or reasoning_extraction. Your code should:
- Check
stop_reasonbefore readingcontent, as the Python and TypeScript examples above do. - Log
stop_details.categoryso you can see which prompts trigger it. - Send the request to another model, such as Opus 5.5, or show the user a clear message.
To see how the model reasoned, request "display": "summarized" thinking. That keeps reasoning out of the reply text, which is the area the reasoning_extraction category covers.
Migrating from Fable 5.1 or Opus 5.5
| Coming from | What changes |
|---|---|
| Claude Fable 5.1 | Swap the model ID. Prices fall from $10 / $50 to $8 / $40. The prefix check now applies to every account, so keep histories append-only. Use computer_toolset_20260801 for computer use. With the advisor tool, set the advisor to claude-fable-5-2. Re-run your effort sweep from high |
| Claude Opus 5.5 | Token price moves from $4 / $20 to $8 / $40; cache reads stay at $0.20. Default effort moves from medium to high, so set it explicitly. Fable 5.2 runs with 30-day data retention. Thinking and tool_choice rules are the same |
| Claude Opus 5 or earlier | Let thinking run adaptively and steer it with effort in place of disabled and budget_tokens. Use tool_choice auto with an instruction, or structured output for JSON. Let the model manage sampling in place of temperature, top_p and top_k. Size max_tokens for thinking plus the reply |
Prompts carried over from earlier models are worth a review. For long, multistep tasks, Anthropic recommends adding a "finish the whole task" instruction to the system prompt, especially at low and medium effort. Fable 5.2 follows style rules closely, so loosen hard sentence-length limits written for older models to keep its prose natural. Start a new conversation when you change the prompt.
What a request costs
Output tokens below include thinking. All prices per million tokens.
| Scenario | Tokens | Official ($8 / $40) | PoYo ($6.40 / $32) |
|---|---|---|---|
| Chat reply | 5K input + 1K output | 0.005×8 + 0.001×40 = $0.080 | 0.005×6.4 + 0.001×32 = $0.064 (12.8 credits) |
| Code review | 50K input + 8K output | 0.05×8 + 0.008×40 = $0.72 | 0.05×6.4 + 0.008×32 = $0.576 (115.2 credits) |
| Agent session | 2M cache reads + 300K fresh input + 150K output | 2×0.2 + 0.3×8 + 0.15×40 = $8.80 | 2×0.16 + 0.3×6.4 + 0.15×32 = $7.04 |
| 800K-token document, first question | 800K written to 5-minute cache + 10K output | 0.8×10 + 0.01×40 = $8.40 | 0.8×8 + 0.01×32 = $6.72 |
| Same document, follow-up question | 800K cache read + 10K output | 0.8×0.2 + 0.01×40 = $0.56 | 0.8×0.16 + 0.01×32 = $0.45 |
The document rows show why caching matters: after the first question, each follow-up costs about one-fifteenth as much. In the agent session, output is about two-thirds of the bill, which is why effort is the first setting to tune.
Use Claude Fable 5.2 on PoYo
PoYo gives you Fable 5.2 at 20% below Anthropic's official token rates, with a few practical extras:
- One API key for every model. Fable 5.2, Opus 5.5, Sonnet 5.5, GPT models and image, video and audio models share the same key and dashboard.
- Pay as you go. Credits are billed per token, with no subscription.
- Both request formats. Call Fable 5.2 in the Anthropic Messages format or the OpenAI Chat Completions format with the same model ID.
Test prompts in the Playground on the Claude Fable 5.2 model page, then move the same model ID into production. To compare it with the everyday default, switch "model" to claude-opus-5-5 on the Claude Opus 5.5 page with the same key.
FAQ
How much does the Claude Fable 5.2 API cost?
$8 per million input tokens and $40 per million output tokens on Anthropic's API, with cache reads at $0.20. On PoYo the same model costs $6.40 input, $32 output and $0.16 for cache reads per million tokens. Thinking tokens are billed at the output rate.
What is the Claude Fable 5 price?
Claude Fable 5 (June 2026) costs $10 / $50 per million input/output tokens, with cache reads at $1. Fable 5.1 kept the $10 / $50 price and cut cache reads to $0.25. Fable 5.2 lowers it to $8 / $40 with $0.20 cache reads.
What is the Claude Fable 5.2 model ID?
claude-fable-5-2, exactly as written. Use it on /v1/messages or /v1/chat/completions.
Can I use the Anthropic SDK with PoYo?
Yes. Set the base URL to https://api.poyo.ai and pass your PoYo key as the API key. The SDK sends x-api-key and anthropic-version for you, and streaming works with the SDK's stream helpers.
How do I make Fable 5.2 think less?
Set output_config.effort to low or medium. Adaptive thinking runs on every request and scales with the effort level, so a lower level gives faster, cheaper replies.
Which effort level should I use?
Start at medium for interactive work and routine coding, and at high for hard, long-running agent tasks. Move to xhigh where your evals show a gain, and use low for simple, high-volume calls.
How is long context billed?
The full 1M-token window is billed at the standard rate, so long prompts cost the same per token as short ones. Prompt caching cuts the cost of re-reading long context further.
Can I switch models or edit messages mid-conversation?
Switching models works at any point: send the next request with a different model, and the API automatically drops earlier thinking blocks where needed, so the request succeeds. For edits, keep system and tools fixed, append new messages, and return each assistant turn exactly as you received it; the prefix check flags histories whose earlier turns changed after a thinking block was produced. To change instructions, start a new conversation.
How is Fable 5.2 different from Mythos 5.2?
They share the same capabilities, specifications and prices. Mythos 5.2 is offered to organizations verified through Anthropic's programs, such as the Cyber Verification Program, while Fable 5.2 is open to all developers.