Belangrijkste punten
- Model-ID:
claude-fable-5-2. Uitgebracht op 9 november 2026, met een contextvenster van 1M tokens en tot 128K outputtokens per verzoek. - Prijs: $8 / $40 per miljoen input-/outputtokens op de API van Anthropic, 20% onder Fable 5.1. Op PoYo kost het $6.40 / $32.
- Twee manieren om het op PoYo aan te roepen: het Anthropic Messages-formaat via
POST https://api.poyo.ai/v1/messages, of het OpenAI-compatibelePOST https://api.poyo.ai/v1/chat/completions. De officiële Anthropic-SDK's werken zodra je de base-URL ophttps://api.poyo.aizet. - Denkwerk staat altijd aan. Diepgang en kosten regel je met
output_config.effort. De standaard ishigh; gebruikmediumoflowvoor routinewerk. - Denkwerk wordt als output gefactureerd. Ook een kort antwoord kan op
higheffort duizenden outputtokens gebruiken, dus steleffortexpliciet in en kiesmax_tokensruim genoeg voor het denkwerk plus het antwoord. - Lees eerst
stop_reason. Daaraan zie je of het model klaar is, een tool aanriep,max_tokensbereikte of een veiligheidsweigering (refusal) teruggaf. Controleer het dus voordat je de inhoud leest.
Claude Fable 5.2 API in één oogopslag
| Claude Fable 5.2 | |
|---|---|
| Model-ID in de API | claude-fable-5-2 |
| Uitgebracht | 9 november 2026 |
| Contextvenster | 1M tokens |
| Maximale output | 128K tokens per verzoek |
| Input → output | Tekst en afbeeldingen → tekst |
| Denkwerk | Adaptief, altijd aan |
| Effort-niveaus | low, medium, high (standaard), xhigh, max |
| Kennisgrens | juni 2026 |
| Gegevensbewaring | 30 dagen bewaring |
| Officiële prijs (per 1M tokens) | $8 input / $40 output / $0.20 cache lezen |
| Prijs op PoYo (per 1M tokens) | $6.40 input / $32 output / $0.16 cache lezen |
| Endpoints op PoYo | /v1/messages, /v1/chat/completions |
Anthropic positioneert Fable 5.2 voor veeleisend redeneerwerk en agentisch werk met een lange horizon, en raadt Claude Opus 5.5 aan als startpunt voor de meeste werklasten. Twijfel je nog tussen de twee, lees dan eerst Claude Fable 5.2 vs Opus 5.5. Deze gids gaat over de integratie.
Een prototype van een besturingssysteem, gebouwd door agents van Claude Fable 5.2 en draaiend op een laptop. Video uit het lanceringsmateriaal van Anthropic voor Claude Fable 5.2.
Fable 5, 5.1 of 5.2: naar welke prijs kijk je?
Wie zoekt op “Claude Fable 5 pricing”, kan elk van de drie Fable-modellen bedoelen die in 2026 zijn uitgebracht. Ze delen het contextvenster van 1M en de outputlimiet van 128K, en elk heeft een eigen prijs:
| Model | Uitgebracht | Input | Output | Cache lezen | Model-ID in de API |
|---|---|---|---|---|---|
| Claude Fable 5 | 9 juni 2026 | $10 | $50 | $1.00 | claude-fable-5 |
| Claude Fable 5.1 | 1 september 2026 | $10 | $50 | $0.25 | claude-fable-5-1 |
| Claude Fable 5.2 | 9 november 2026 | $8 | $40 | $0.20 | claude-fable-5-2 |
Officiële prijzen in USD per miljoen tokens. Fable 5.2 is de eerste prijsverlaging binnen het Fable-niveau en het actuele model, dus nieuwe projecten beginnen het best daar. De rest van deze gids gaat over Fable 5.2.
Prijzen in het kort
| Kostenpost (per 1M tokens) | Officieel bij Anthropic | PoYo | PoYo-credits |
|---|---|---|---|
| Input | $8.00 | $6.40 | 1.280 |
| Output (inclusief denkwerk) | $40.00 | $32.00 | 6.400 |
| Cache lezen | $0.20 | $0.16 | 32 |
| Cache schrijven, 5 minuten | $10.00 | $8.00 | 1.600 |
| Cache schrijven, 1 uur | $16.00 | $12.80 | 2.560 |
PoYo rekent naar gebruik af in credits, tegen $1 = 200 credits, zonder abonnement. Het volledige contextvenster van 1M wordt tegen het standaardtarief gefactureerd, dus een prompt van 900K tokens kost per token evenveel als een prompt van 9K tokens. Zie onze prijsgids voor de Claude API voor alle andere Claude-modellen.
Snel aan de slag
- Maak een API-sleutel aan in het PoYo-dashboard.
- Stuur verzoeken naar
https://api.poyo.aimet het model ingesteld opclaude-fable-5-2. - Authenticeer op
/v1/messagesmetx-api-key: YOUR_KEY(Authorization: Bearer YOUR_KEYwerkt ook), of op/v1/chat/completionsmetAuthorization: Bearer YOUR_KEY.
curl (Anthropic Messages-formaat)
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": "Zoek de race condition in deze Go-workerpool en stel een oplossing voor: ..."}
]
}'
Het antwoord is een standaard Message-object van Anthropic. De tekst staat in het text-blok van content; daarvoor kan een thinking-blok staan.
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": "Schrijf een migratieplan van REST naar gRPC voor deze 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)
Met streaming blijven lange verzoeken ruim binnen de HTTP-time-outs. Op high effort en hoger kan één moeilijk verzoek minutenlang lopen.
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: "Controleer deze pull request op beveiligingsproblemen: ..." }],
})
.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-compatibele Chat Completions
Gebruikt je stack al de requestvorm van OpenAI, stuur dan hetzelfde model-ID naar /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": "Je bent een ervaren data-engineer."},
{"role": "user", "content": "Ontwerp een schema voor het ontdubbelen van events in ClickHouse."}
],
"stream": true
}'
Zet bij de officiële OpenAI-SDK base_url op https://api.poyo.ai/v1. Kies /v1/messages wanneer je Claude-specifieke instellingen nodig hebt, zoals output_config.effort, de weergave van het denkwerk, cache_control en tooldefinities in Anthropic-stijl.
Effort: de belangrijkste knop voor kwaliteit en kosten
Fable 5.2 denkt bij elk verzoek adaptief na. De instelling effort binnen output_config bepaalt hoeveel:
| Effort | Gebruik het voor | Opmerkingen |
|---|---|---|
low | Snel heen-en-weer, duidelijk omschreven taken, subagents met grote volumes | Het snelst en het goedkoopst. Voeg bij lange taken een instructie toe om “de hele taak af te maken” |
medium | Interactief coderen, chat, dagelijks kenniswerk | Een goede standaard voor het meeste productverkeer |
high (standaard) | Moeilijk codeerwerk, onderzoek, agentisch werk, lange runs zonder toezicht | Volgens Anthropic zit de meeste winst in capaciteit al op high |
xhigh | Het zwaarste langlopende code- en agentwerk | Gebruik het waar je evals een meetbare winst laten zien; verbruikt meer tokens |
max | De bovengrens meten, of zeldzame taken waarbij diepgang zwaarder weegt dan tijd en tokens | Het diepste redeneerwerk en de langste beurten |

Hoe effort op FrontierCode 2.0 score uitruilt tegen kosten per taak. Grafiek uit het lanceringsmateriaal van Anthropic voor Claude Fable 5.2.
Drie praktische regels:
- Stel effort bij elk verzoek in. Code die je van Opus 5.5 overneemt, draaide standaard op
medium. Op Fable 5.2 draait hetzelfde verzoek ophighen verbruikt het meer outputtokens. - Bepaal met effort hoeveel het model denkt. Voor snellere en goedkopere beurten raadt Anthropic een lager effort-niveau aan, in plaats van promptregels als “antwoord direct zonder na te denken”. Op
highen hoger denkt Fable 5.2 voor bijna elk antwoord na, zelfs bij een begroeting. - Bepaal met de prompt hoe lang het antwoord is. Effort stelt de diepgang van het denkwerk in; je prompt bepaalt de lengte van het uiteindelijke antwoord.
Een gemeten voorbeeld van wat effort met de rekening doet, vind je in de praktijkresultaten in Claude Fable 5.2 vs Opus 5.5: bij één codeertaak scoorde Fable 5.2 op medium en high hetzelfde, terwijl medium ongeveer een kwart van de kosten had.
Adaptief denken: wat “altijd aan” betekent voor je code
- Laat
thinkingweg, of stuur{"type": "adaptive"}. Meer hoef je voor het denkwerk niet in te stellen. De diepgang komt vaneffort, dat de oudere instellingenbudget_tokensendisabledvervangt. - Thinking-tokens worden als output gefactureerd en tellen mee voor
max_tokens. Stemmax_tokensaf op het denkwerk plus het antwoord: 16K is een goede ondergrens, en 32K of meer met streaming past bij moeilijke taken. - Samenvattingen van het denkwerk vraag je zelf aan. Standaard komen thinking-blokken binnen met een leeg veld
thinking, zodat streaming snel blijft. Voeg"display": "summarized"toe om een leesbare samenvatting te krijgen. In beide modi wordt het volledige denkwerk gefactureerd. - Laat sampling aan het model over. Stuur verzoeken zonder
temperature,top_pentop_k; Fable 5.2 regelt de sampling zelf. - Lees
usage.output_tokensbevat het denkwerk al, enoutput_tokens_details.thinking_tokenslaat zien welk deel daarvan denkwerk is.
Toolgebruik
Fable 5.2 accepteert tool_choice met auto (de standaard) of none. Noem de tool in je prompt wanneer je wilt dat hij wordt aangeroepen:
{
"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": "Waar is bestelling A-1042? Controleer het met get_order_status."}
]
}
Roept het model een tool aan, dan eindigt het antwoord met stop_reason: "tool_use". Voer de tool uit en stuur een tool_result-blok terug in het volgende gebruikersbericht. Geef de volledige assistentbeurt ongewijzigd terug, inclusief thinking-blokken.
Andere regels die handig zijn om te kennen:
- Gebruik
autoofnonevoortool_choice. Wil je zeker weten dat een tool draait, noem hem dan in de prompt. Heb je gegarandeerd JSON nodig, gebruik dan structured output:output_config.formatmet een JSON-schema. - Computergebruik loopt via de toolset
computer_toolset_20260801. - Parse toolinput met een JSON-parser. Die verwerkt elke escapestijl die het model in toolargumenten gebruikt.
Robotarmen die Claude Fable 5.2 aan de hand van camerabeelden aanstuurt, terwijl ze een puzzelkubus oplossen. Video uit het lanceringsmateriaal van Anthropic voor Claude Fable 5.2.
1M context en prompt caching
In het venster van 1M tokens passen ongeveer 555.000 Engelse woorden, genoeg voor een grote codebase of een stapel contracten in één verzoek. Fable 5.2 gebruikt de tokenizer die met Claude Opus 4.7 werd geïntroduceerd en die voor dezelfde tekst meer tokens oplevert dan modellen van vóór 4.7. Tel dus de tokens van je eigen bestanden voordat je rond de limiet plant.
Bij lange prompts levert caching het meest op. Cache lezen kost op Fable 5.2 2,5% van de inputprijs ($0.20 vs $8 per miljoen tokens). Voeg op PoYo een cache_control op het hoogste niveau toe, dan wordt het laatste cachebare blok automatisch gecachet:
{
"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": "Noem elk opzeggingsrecht met de bijbehorende opzegtermijn."}
]
}
Zet de vaste inhoud vooraan (systeemprompt, tooldefinities, het document) en de veranderende vraag achteraan. In een gesprek met meerdere beurten of een agent-loop leest elke nieuwe beurt het eerdere prefix uit de cache. De cache van 5 minuten kost bij het schrijven 1,25× de inputprijs en verdient zich na één keer lezen terug; de cache van 1 uur kost 2× en verdient zich na twee keer lezen terug.
Twee gewoonten zorgen ervoor dat zowel de cache als het redeneerwerk van het model over meerdere beurten blijft werken:
- Vul de geschiedenis alleen aan. Elk thinking-blok hoort bij de systeemprompt, tools en berichten die eraan voorafgingen. Houd
systementoolsgedurende een gesprek vast en voeg nieuwe beurten toe aan het einde vanmessages. Worden eerdere beurten aangepast en de oude thinking-blokken teruggestuurd, dan markeert de prefixcontrole van de API het verzoek met de meldingThe block is bound to a different conversation. Begin een nieuw gesprek als je de instructies wilt veranderen. - Wissel van model wanneer je wilt. Je kunt
modeltussen verzoeken in hetzelfde gesprek aanpassen. De thinking-blokken van Fable 5.2 worden gelezen door Fable 5.2 en Mythos 5.2; schuift het gesprek door naar een ander model, zoals Opus 5.5, dan laat de API die blokken automatisch weg, slaagt het verzoek en gaat het nieuwe model verder met zijn eigen redeneerwerk. Elk model houdt zijn eigen cache bij.
Omgaan met weigeringen
Fable 5.2 werkt met veiligheidsclassifiers. Houdt een daarvan een verzoek tegen, dan komt het antwoord binnen als HTTP 200 met stop_reason: "refusal" en een stop_details-object dat het beleidsgebied noemt, bijvoorbeeld cyber, bio of reasoning_extraction. Je code moet:
stop_reasoncontroleren voordat jecontentleest, zoals de voorbeelden in Python en TypeScript hierboven doen.stop_details.categoryloggen, zodat je ziet welke prompts het activeren.- Het verzoek naar een ander model sturen, zoals Opus 5.5, of de gebruiker een duidelijke melding tonen.
Wil je zien hoe het model redeneerde, vraag dan denkwerk met "display": "summarized" aan. Zo blijft het redeneerwerk buiten de antwoordtekst, en dat is precies het gebied dat de categorie reasoning_extraction afdekt.
Overstappen van Fable 5.1 of Opus 5.5
| Je komt van | Wat er verandert |
|---|---|
| Claude Fable 5.1 | Vervang het model-ID. De prijzen dalen van $10 / $50 naar $8 / $40. De prefixcontrole geldt nu voor elk account, dus vul geschiedenissen alleen aan. Gebruik computer_toolset_20260801 voor computergebruik. Zet bij de advisor-tool de advisor op claude-fable-5-2. Herhaal je effort-test vanaf high |
| Claude Opus 5.5 | De tokenprijs gaat van $4 / $20 naar $8 / $40; cache lezen blijft $0.20. De standaard-effort gaat van medium naar high, dus stel die expliciet in. Fable 5.2 werkt met 30 dagen gegevensbewaring. De regels voor denkwerk en tool_choice zijn hetzelfde |
| Claude Opus 5 of ouder | Laat het denkwerk adaptief lopen en stuur het bij met effort in plaats van disabled en budget_tokens. Gebruik tool_choice auto met een instructie, of structured output voor JSON. Laat het model de sampling regelen in plaats van temperature, top_p en top_k. Stem max_tokens af op het denkwerk plus het antwoord |
Prompts die je van eerdere modellen overneemt, zijn een controle waard. Voor lange taken met meerdere stappen raadt Anthropic aan om in de systeemprompt een instructie op te nemen om “de hele taak af te maken”, vooral op low en medium effort. Fable 5.2 volgt stijlregels nauwkeurig, dus versoepel strikte limieten voor zinslengte die voor oudere modellen zijn geschreven, zodat de tekst natuurlijk blijft. Begin een nieuw gesprek wanneer je de prompt aanpast.
Wat een verzoek kost
De outputtokens hieronder zijn inclusief denkwerk. Alle prijzen per miljoen tokens.
| Scenario | Tokens | Officieel ($8 / $40) | PoYo ($6.40 / $32) |
|---|---|---|---|
| Chatantwoord | 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) |
| Agentsessie | 2M uit de cache gelezen + 300K nieuwe 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 |
| Document van 800K tokens, eerste vraag | 800K naar de cache van 5 minuten geschreven + 10K output | 0.8×10 + 0.01×40 = $8.40 | 0.8×8 + 0.01×32 = $6.72 |
| Hetzelfde document, vervolgvraag | 800K uit de cache gelezen + 10K output | 0.8×0.2 + 0.01×40 = $0.56 | 0.8×0.16 + 0.01×32 = $0.45 |
De documentrijen laten zien waarom caching ertoe doet: na de eerste vraag kost elke vervolgvraag ongeveer een vijftiende. In de agentsessie is output ongeveer twee derde van de rekening; daarom is effort de eerste instelling om bij te stellen.
Claude Fable 5.2 gebruiken op PoYo
Op PoYo krijg je Fable 5.2 voor 20% onder de officiële tokentarieven van Anthropic, met een paar praktische extra's:
- Eén API-sleutel voor elk model. Fable 5.2, Opus 5.5, Sonnet 5.5, GPT-modellen en modellen voor beeld, video en audio delen dezelfde sleutel en hetzelfde dashboard.
- Betalen naar gebruik. Credits worden per token gefactureerd, zonder abonnement.
- Beide requestformaten. Roep Fable 5.2 aan in het Anthropic Messages-formaat of het OpenAI Chat Completions-formaat, met hetzelfde model-ID.
Test prompts in de Playground op de modelpagina van Claude Fable 5.2 en zet daarna hetzelfde model-ID in productie. Om het te vergelijken met de standaard voor dagelijks gebruik, zet je "model" op claude-opus-5-5 via de pagina van Claude Opus 5.5, met dezelfde sleutel.
Veelgestelde vragen
Wat kost de Claude Fable 5.2 API?
$8 per miljoen inputtokens en $40 per miljoen outputtokens op de API van Anthropic, met cache lezen voor $0.20. Op PoYo kost hetzelfde model $6.40 voor input, $32 voor output en $0.16 voor cache lezen per miljoen tokens. Thinking-tokens worden tegen het outputtarief gefactureerd.
Wat is de prijs van Claude Fable 5?
Claude Fable 5 (juni 2026) kost $10 / $50 per miljoen input-/outputtokens, met cache lezen voor $1. Fable 5.1 hield de prijs van $10 / $50 aan en verlaagde cache lezen naar $0.25. Fable 5.2 brengt de prijs omlaag naar $8 / $40, met cache lezen voor $0.20.
Wat is het model-ID van Claude Fable 5.2?
claude-fable-5-2, precies zo geschreven. Gebruik het op /v1/messages of /v1/chat/completions.
Kan ik de Anthropic-SDK met PoYo gebruiken?
Ja. Zet de base-URL op https://api.poyo.ai en geef je PoYo-sleutel mee als API-sleutel. De SDK stuurt x-api-key en anthropic-version voor je mee, en streaming werkt met de streamhelpers van de SDK.
Hoe laat ik Fable 5.2 minder nadenken?
Zet output_config.effort op low of medium. Adaptief denken draait bij elk verzoek en schaalt mee met het effort-niveau, dus een lager niveau geeft snellere en goedkopere antwoorden.
Welk effort-niveau moet ik gebruiken?
Begin op medium voor interactief werk en routinematig coderen, en op high voor moeilijke, langlopende agenttaken. Stap over op xhigh waar je evals winst laten zien, en gebruik low voor eenvoudige aanroepen in grote volumes.
Hoe wordt lange context gefactureerd?
Het volledige venster van 1M tokens wordt tegen het standaardtarief gefactureerd, dus lange prompts kosten per token evenveel als korte. Prompt caching verlaagt de kosten van het opnieuw inlezen van lange context nog verder.
Kan ik midden in een gesprek van model wisselen of berichten aanpassen?
Van model wisselen kan op elk moment: stuur het volgende verzoek met een ander model, en de API laat eerdere thinking-blokken waar nodig automatisch weg, zodat het verzoek slaagt. Voor aanpassingen geldt: houd system en tools vast, voeg nieuwe berichten toe en stuur elke assistentbeurt precies zo terug als je hem ontving. De prefixcontrole markeert geschiedenissen waarvan eerdere beurten zijn veranderd nadat er een thinking-blok was gemaakt. Begin een nieuw gesprek als je de instructies wilt veranderen.
Wat is het verschil tussen Fable 5.2 en Mythos 5.2?
Ze hebben dezelfde capaciteiten, specificaties en prijzen. Mythos 5.2 wordt aangeboden aan organisaties die via de programma's van Anthropic zijn geverifieerd, zoals het Cyber Verification Program, terwijl Fable 5.2 voor alle ontwikkelaars beschikbaar is.