Claude Fable 5.1 a été livré le 1er septembre 2026, et l'ID du modèle API est la chaîne exacte claude-fable-5-1, sans suffixe de date. Il coûte les mêmes 10 $ par million de tokens d'entrée et 50 $ par million de tokens de sortie que Fable 5, avec des lectures de cache réduites à 0,25 $ par million, et il apporte trois changements majeurs que Fable 5 n'avait pas.
Ce guide parcourt tout le chemin à suivre : obtenir une clé, envoyer une première requête, contrôler l'effort, le streaming, l'utilisation d'outils sans tool_choice forcé, les replis en cas de refus, les mises à jour de progression, et la lecture de l'objet usage pour confirmer que votre cache fonctionne au nouveau tarif. Chaque requête est en HTTP simple avec JSON, vous pouvez donc la construire et la déboguer dans Apidog avant qu'elle n'entre dans le code de l'application.
Si vous migrez un service Fable 5 ou Opus 5 existant plutôt que de partir de zéro, lisez le guide de migration complet en parallèle de celui-ci. Pour un aperçu du modèle, commencez par ce qu'est Claude Fable 5.1.
Avant votre premier appel : trois choses qui renvoient un 400
1. La réflexion ne peut pas être configurée, seulement orientée. Fable 5.1 exécute une réflexion adaptative sur chaque requête. Omettez le champ thinking, ou envoyez {"type": "adaptive"}. Les deux {"type": "disabled"} et {"type": "enabled", "budget_tokens": N} renvoient un 400. Si vous venez d'Opus 5, où disabled était accepté à un effort high ou inférieur, supprimez-le et contrôlez les dépenses avec output_config.effort à la place.
2. L'utilisation forcée d'outils a disparu. tool_choice: {"type": "any"} et {"type": "tool", "name": "..."} renvoient tool_choice: type "tool" and "any" are not supported for this model. La solution est dans l'étape d'utilisation d'outils ci-dessous.
3. Votre organisation nécessite une rétention des données de 30 jours. Fable 5.1 est un modèle couvert. Une requête d'une organisation ou d'un espace de travail avec une rétention des données nulle renvoie 400 invalid_request_error sans autre indice. Si votre premier appel échoue et que le corps semble correct, vérifiez la rétention avant toute autre chose.
Ces trois points sont documentés dans le document d'Anthropic Nouveautés de Claude Fable 5.1.
Étape 1 : Obtenir une clé API
Connectez-vous à la console Claude, ouvrez la section des clés API dans les paramètres de votre organisation et créez une clé. Copiez-la une seule fois ; vous ne pourrez pas la relire plus tard. Exportez-la plutôt que de la coller dans le code :
export ANTHROPIC_API_KEY="sk-ant-..."
Dans Apidog, stockez-la comme variable d'environnement nommée ANTHROPIC_API_KEY et référencez-la comme {{ANTHROPIC_API_KEY}} dans l'en-tête, afin que la clé ne finisse jamais dans le corps d'une requête enregistrée.
Étape 2 : Envoyer votre première requête
Créez une requête POST vers https://api.anthropic.com/v1/messages avec trois en-têtes : x-api-key, anthropic-version: 2023-06-01 et content-type: application/json.
curl https://api.anthropic.com/v1/messages \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2023-06-01" \
-H "content-type: application/json" \
-d '{
"model": "claude-fable-5-1",
"max_tokens": 16000,
"messages": [
{"role": "user", "content": "Explain the difference between idempotent and safe HTTP methods, with one example each."}
]
}'
Le même appel en Python avec le SDK officiel :
import anthropic
client = anthropic.Anthropic()
response = client.messages.create(
model="claude-fable-5-1",
max_tokens=16000,
messages=[{"role": "user", "content": "Explain the difference between idempotent and safe HTTP methods, with one example each."}],
)
if response.stop_reason == "refusal":
print("declined:", response.stop_details.category if response.stop_details else None)
else:
for block in response.content:
if block.type == "text":
print(block.text)
Deux habitudes à prendre dès le premier appel. Vérifiez stop_reason avant de lire content, car un refus classifié est un HTTP 200 avec un tableau de contenu vide. Et donnez à max_tokens une vraie marge. Cela plafonne les tokens de réflexion plus les tokens de réponse ensemble, et la réflexion est toujours active, donc une valeur serrée réglée pour un modèle sans réflexion sera tronquée ici.
La réponse contient un bloc thinking dont le texte est vide sous le display par défaut de "omitted". C'est normal. Renvoyez-le inchangé au tour suivant.
Étape 3 : Contrôler le coût et la profondeur avec l'effort
Le paramètre d'effort est le levier principal sur Fable 5.1. Il se trouve à l'intérieur de output_config, et non au niveau supérieur, et accepte low, medium, high, xhigh et max. La valeur par défaut est high.
{
"model": "claude-fable-5-1",
"max_tokens": 16000,
"output_config": {"effort": "medium"},
"messages": [{"role": "user", "content": "Summarize this changelog in five bullets."}]
}
Les recommandations d'Anthropic : commencez par high, puis testez les autres avec vos propres évaluations, et recommencez le test même si vous l'avez fait sur Fable 5, car les noms de niveau ne correspondent pas à la même quantité de réflexion d'un modèle à l'autre. Ils affirment que medium correspond à peu près à Fable 5 à un coût inférieur et que low est souvent compétitif avec Opus et Sonnet sur le coût par tâche. Deux comportements spécifiques à l'effort à connaître : à low, Fable 5.1 appelle moins souvent les outils de recherche et de récupération et répond davantage de mémoire, et à xhigh et max, il peut rédiger un long document dans sa phase de réflexion, puis le réécrire, donc réglez max_tokens en conséquence pour les deux.
Changer l'effort en cours de conversation (bêta). Sur Fable 5, changer l'effort de haut niveau entre les requêtes supprimait le préfixe mis en cache. Sur Fable 5.1, un message role: "system" avec un contenu vide et un output_config modifie l'effort à partir du prochain tour de l'utilisateur sans invalider le cache. Cela nécessite l'en-tête bêta mid-conversation-output-config-2026-07-01 et l'espace de noms client.beta.messages.
response = client.beta.messages.create(
model="claude-fable-5-1",
max_tokens=16000,
output_config={"effort": "high"},
betas=["mid-conversation-output-config-2026-07-01"],
messages=[
{"role": "user", "content": "Plan a migration from SQLite to PostgreSQL in three short steps."},
{"role": "assistant", "content": "1. Export the SQLite data. 2. Create the PostgreSQL schema. 3. Import the data and verify row counts."},
{"role": "system", "content": [], "output_config": {"effort": "low"}},
{"role": "user", "content": "Summarize the plan in one sentence."},
],
)
Baisser l'effort de cette manière est fiable. L'augmenter fonctionne mieux pour les grands sauts, comme de low à xhigh. Le guide du paramètre d'effort pour Opus 5 couvre les cinq niveaux en profondeur, et la même sémantique s'applique ici.
Étape 4 : Diffuser la réponse en continu
Les tâches difficiles de Fable 5.1 peuvent prendre plusieurs minutes à un effort plus élevé, donc diffusez en continu tout ce qui pourrait être long. Le SDK exige le streaming pour les valeurs de max_tokens proches du plafond de 128 000 pour éviter les délais d'attente HTTP.
with client.messages.stream(
model="claude-fable-5-1",
max_tokens=64000,
messages=[{"role": "user", "content": "Write a test plan for a rate-limited public API."}],
) as stream:
for text in stream.text_stream:
print(text, end="", flush=True)
final = stream.get_final_message()
print(final.stop_reason, final.usage.output_tokens)
Dans Apidog, les réponses en streaming s'affichent au fur et à mesure de leur arrivée, ce qui est le moyen le plus rapide de voir combien de temps un tour à effort high passe à réfléchir avant le premier token de texte.
Étape 5 : Ajouter l'utilisation d'outils sans la forcer
Définissez les outils de la même manière que sur Fable 5. Ce qui change, c'est la façon dont vous garantissez un appel. Sur Fable 5, vous pouviez le forcer avec tool_choice: {"type": "tool", ...}. Sur Fable 5.1, cela renvoie un 400, car un appel forcé ignorerait la réflexion et le modèle écrirait son raisonnement dans les arguments.
Le remplacement comporte trois parties : garder tool_choice à auto, nommer l'outil dans l'instruction, et définir strict: true (utilisation stricte des outils) sur l'outil avec additionalProperties: false dans le schéma pour que les arguments soient toujours validés.
record_summary_tool = {
"name": "record_summary",
"description": "Record the structured summary of the document.",
"strict": True,
"input_schema": {
"type": "object",
"properties": {"summary": {"type": "string"}},
"required": ["summary"],
"additionalProperties": False,
},
}
response = client.messages.create(
model="claude-fable-5-1",
max_tokens=16000,
tools=[record_summary_tool],
tool_choice={"type": "auto"},
messages=[{"role": "user", "content": "Summarize: The meeting moved to Thursday. Call the record_summary tool with your result."}],
)
Si l'appel forcé n'existait que pour récupérer du JSON, utilisez les sorties structurées (output_config.format) au lieu d'un outil. Si votre application, et non l'utilisateur, requiert un appel spécifique sur le tour actuel d'une conversation à plusieurs tours, ajoutez un message role: "system" après le dernier tour de l'utilisateur qui nomme l'outil et indique que l'appel est requis, et conservez ce message dans l'historique par la suite. tool_choice: {"type": "none"} fonctionne toujours pour un tour qui ne doit pas appeler d'outils.
La boucle agentique elle-même est inchangée : lorsque stop_reason est tool_use, exécutez chaque bloc tool_use, retournez tous les blocs tool_result dans un seul message utilisateur, et ajoutez le tour de l'assistant exactement tel qu'il a été retourné, blocs de réflexion inclus. Cette dernière clause est plus importante sur Fable 5.1 que sur tout modèle précédent, pour les raisons expliquées dans le guide de la réflexion préservée.
Un comportement à surveiller : dans les boucles longues où les prochaines lectures indépendantes ne sont qu'implicites par la tâche, Fable 5.1 peut émettre un appel d'outil par tour là où Fable 5 en regroupait plusieurs. La solution d'Anthropic est une incitation d'une phrase ajoutée après chaque message de résultat d'outil : « Listez d'abord en privé ce dont vous avez besoin ensuite ; puis demandez chaque élément qui ne dépend pas du résultat d'un autre dans cette seule réponse. » Envoyez-le comme message système limité au tour (clear_at: "next_user_message", en-tête bêta mid-conversation-system-clear-at-2026-08-21) et laissez toutes les copies précédentes en place.
Étape 6 : Gérer les refus avec des solutions de repli
Fable 5.1 exécute des classificateurs de sécurité. Une requête refusée revient en HTTP 200 avec stop_reason: "refusal" et un objet stop_details nommant la catégorie : cyber, bio, frontier_llm, reasoning_extraction, ou general_harms. Un refus avant toute sortie n'est pas facturé.
Optez pour les solutions de repli par défaut. La forme la plus simple est fallbacks: "default" avec l'en-tête bêta server-side-fallback-2026-07-01, qui relance une requête refusée sur le modèle qu'Anthropic recommande pour cette catégorie. Pour Fable 5.1, les cibles autorisées sont claude-opus-4-8 et claude-opus-5.
response = client.beta.messages.create(
model="claude-fable-5-1",
max_tokens=16000,
fallbacks="default",
betas=["server-side-fallback-2026-07-01"],
messages=[{"role": "user", "content": "Audit this authentication middleware for logic bugs."}],
)
fallback_ran = any(
entry.type == "fallback_message" for entry in (response.usage.iterations or [])
)
if fallback_ran and response.stop_reason != "refusal":
print("served by", response.model)
La réponse nomme le modèle de service dans son champ model de niveau supérieur, et un bloc de contenu fallback marque le transfert. Gardez ce bloc là où il est apparu lorsque vous renvoyez le tour. Deux limites : fallbacks est rejeté sur l'API Batches, et il n'est pas disponible sur Bedrock, Google Cloud ou Foundry, où vous enregistrez plutôt le BetaRefusalFallbackMiddleware du SDK sur le client. Le guide de gestion des refus couvre la facturation, le routage persistant et la nouvelle tentative manuelle avec crédit de repli.
Étape 7 : Obtenir des mises à jour de progression pendant les longs tours
Entre les appels d'outils, Fable 5.1 écrit de courtes notes sur ce qu'il a trouvé et ce qu'il fera ensuite. Chacune arrive sous la forme de son propre bloc thinking immédiatement avant l'appel d'outil, et sous le display par défaut, ces blocs sont vides. Définissez display: "updates" avec l'en-tête bêta thinking-display-updates-2026-08-18 pour les recevoir sous forme de texte tandis que le raisonnement lui-même reste masqué.
{
"model": "claude-fable-5-1",
"max_tokens": 16000,
"thinking": {"type": "adaptive", "display": "updates"},
"tools": [...],
"messages": [{"role": "user", "content": "Review the PRs open against our billing service."}]
}
Tout bloc thinking avec un texte non vide est alors une ligne d'état que vous pouvez afficher. Fable 5.1 en écrit moins que Fable 5, donc si votre interface utilisateur dépend de la narration, supprimez également toute ligne d'invite qui dit au modèle de conserver les résultats pour la réponse finale.
Étape 8 : Lire l'objet usage pour le taux de cache de 0,25 $
Le mise en cache des invites est l'endroit où le changement de prix de Fable 5.1 se manifeste. Placez cache_control sur le préfixe stable et confirmez les hits dans usage :
response = client.messages.create(
model="claude-fable-5-1",
max_tokens=16000,
system=[{"type": "text", "text": LONG_STABLE_SYSTEM_PROMPT, "cache_control": {"type": "ephemeral"}}],
messages=[{"role": "user", "content": "Which endpoints in the spec lack an error schema?"}],
)
u = response.usage
print(u.input_tokens, u.cache_creation_input_tokens, u.cache_read_input_tokens)
Lors du premier envoi, cache_creation_input_tokens est non nul (facturé à 12,50 $ par million pour un TTL de 5 minutes). Lors du deuxième envoi dans les cinq minutes, cache_read_input_tokens devrait être non nul, facturé à 0,25 $ par million. S'il reste à zéro pour des requêtes identiques, quelque chose dans le préfixe change à chaque fois : un horodatage dans l'invite système, du JSON non trié, un tableau d'outils variable. L'invite minimale pouvant être mise en cache est de 512 tokens.
Deux faits sur le cache spécifiques à ce modèle. Puisqu'un échec coûte 40 fois plus cher qu'une réussite, garder le cache chaud est plus important que sur Fable 5, et l'effort par message et les messages système limités au tour existent en partie pour que vous puissiez modifier des choses en cours de session sans réinitialisation. Et les mêmes modifications qui réinitialisent le cache (reconstruction de system, édition des tours précédents) invalident désormais également les blocs de réflexion, de sorte que la discipline d'ajout seulement est doublement payante.
Testez et déboguez tout le flux dans Apidog
Enregistrez chaque étape ci-dessus comme une requête dans une collection Apidog : premier appel, variantes d'effort, streaming, boucle d'outils, repli, vérification du cache. Utilisez des variables d'environnement pour la clé et pour model, afin de pouvoir basculer toute une collection entre claude-fable-5 et claude-fable-5-1 en une seule modification. Ensuite, ajoutez des assertions : stop_reason n'est pas refusal sur vos invites de test bénignes, usage.cache_read_input_tokens est supérieur à zéro sur la deuxième requête de cache, et aucune entrée input_transformations n'a reason: "prefix_binding_mismatch" lorsque vous exécutez avec l'en-tête de liaison de la réflexion. Exécutez la collection avant et après tout changement de harnais. Téléchargez Apidog pour le configurer ; la même collection fonctionne comme une vérification CI via l'interface CLI d'Apidog.
Erreurs et pièges que vous rencontrerez
- 400
tool_choice: type "tool" and "any" are not supported for this model.Passez àautoplus une instruction etstrict: true. - 400 sur
thinking: {"type": "disabled"}. Supprimez le champ. Réduisez plutôt l'effort. - 400
invalid_request_erroravec un corps valide. Vérifiez que l'organisation ou l'espace de travail a une rétention de 30 jours. - 400
Invalid signature in thinking block. The block is bound to a different conversation.Votre code a modifié un tour précédent, l'invite système ou le tableau d'outils. Voir le guide de la réflexion préservée. - Texte de réflexion vide et silencieux. Attendu sous
display: "omitted". Utilisez"summarized"ou"updates"si vous le rendez. - Lectures du cache à zéro. Un préfixe volatil. Vérifiez les horodatages et les objets non triés.
- La requête Tier Prioritaire échoue à la validation. Fable 5.1 ne prend pas en charge le Tier Prioritaire. Fable 5 le fait.
FAQ
Quel est l'ID de modèle pour l'API Claude Fable 5.1 ? claude-fable-5-1. Sur Amazon Bedrock, c'est anthropic.claude-fable-5-1 ; Google Cloud, Microsoft Foundry et Claude Platform sur AWS utilisent claude-fable-5-1.
Ai-je besoin d'un en-tête bêta pour utiliser Claude Fable 5.1 ? Non. Le modèle de base, la réflexion adaptative, l'effort, les outils et la mise en cache fonctionnent tous avec l'en-tête standard anthropic-version: 2023-06-01. Les en-têtes bêta ne sont nécessaires que pour l'effort par message, les messages système limités au tour, les mises à jour de progression, les replis côté serveur et les contrôles de liaison de réflexion.
Puis-je forcer un appel d'outil sur Claude Fable 5.1 ? Non. tool_choice any et tool renvoient un 400. Utilisez auto, nommez l'outil dans l'invite, et définissez strict: true pour des arguments valides par rapport au schéma, ou utilisez des sorties structurées pour l'extraction JSON.
Quelle est la sortie maximale sur l'API Claude Fable 5.1 ? 128 000 tokens sur l'API Messages. Diffusez en continu pour tout ce qui est volumineux. La version bêta de l'API Batch de 300 000 tokens n'est pas listée pour Fable 5.1.
Comment puis-je voir les lectures de cache moins chères ? Regardez usage.cache_read_input_tokens lors d'une requête répétée. Ces tokens sont facturés à 0,25 $ par million sur Fable 5.1, contre 1 $ sur Fable 5 et 0,50 $ sur Opus 5. L'analyse des prix détaille les chiffres.
Le guide de l'API Fable 5 s'applique-t-il toujours ? Principalement. Le guide de l'API Fable 5 couvre le même point d'accès, mais ses exemples d'utilisation forcée d'outils renvoient désormais un 400 et il est antérieur à l'effort par message et aux mises à jour de progression.