Anthropic a lancé Claude Fable 5 le 9 juin 2026, et si vous développez du code pour gagner votre vie, l'API Claude Fable 5 est la partie qui vous intéresse. Elle fonctionne sur la même API Messages que vous connaissez déjà, donc la chaîne de modèle est la seule chose qui change vraiment : claude-fable-5. Ce guide vous explique chaque appel nécessaire pour obtenir un code fonctionnel et une réponse réelle, d'une simple requête curl en une ligne à la diffusion en continu, l'utilisation d'outils, la gestion des erreurs et le calcul des coûts. Si vous avez déjà développé avec Claude, la structure vous sera familière. Si vous avez migré depuis un modèle plus ancien, la transition est principalement un échange de chaîne, de la même manière que pour l'API Claude Opus 4.8.
En bref
Obtenez une clé API depuis la Console Anthropic, définissez-la comme ANTHROPIC_API_KEY, puis effectuez une requête POST vers l'API Messages avec model: "claude-fable-5", une valeur max_tokens et un tableau messages. Utilisez le SDK officiel d'Anthropic pour Python ou TypeScript, ou du HTTP brut. Diffusez les longues sorties en continu pour éviter les délais d'attente des requêtes. Le prix est de 10 $ par million de jetons d'entrée et de 50 $ par million de jetons de sortie.
Avant de commencer
Quatre éléments sont nécessaires avant votre première requête :
- Un compte Anthropic. Inscrivez-vous sur console.anthropic.com. La Console est l'endroit où vous gérez les clés, l'utilisation et la facturation.
- Une clé API. Créez-en une dans la Console, sous Clés API. Copiez-la une seule fois ; vous ne la reverrez plus. Traitez-la comme un mot de passe.
- Facturation ou plan Entreprise. Fable 5 est disponible sur l'API Claude standard et est entièrement accessible sur les plans Entreprise basés sur la consommation. Ajoutez un mode de paiement ou confirmez que votre plan le couvre avant d'envoyer du trafic. Si vous n'êtes pas encore sûr que Fable 5 corresponde à votre cas d'utilisation, l'aperçu de ce qu'est Claude Fable 5 décrit les atouts du modèle en termes simples.
- Un SDK (facultatif mais recommandé). Installez le SDK Anthropic officiel pour votre langage. Vous pouvez également appeler le point de terminaison HTTP brut avec curl ou n'importe quel client HTTP si vous préférez.
Définissez la clé comme une variable d'environnement afin qu'elle n'atterrisse jamais dans votre code source :
export ANTHROPIC_API_KEY="sk-ant-..."
Les deux SDK lisent automatiquement ANTHROPIC_API_KEY depuis l'environnement, vous la transmettez donc rarement dans le code. Gardez les clés hors de git. Si une clé fuit, changez-la immédiatement dans la Console.
Une particularité à connaître d'emblée : Fable 5 est livré avec des mécanismes de sécurité qui redirigent une petite partie des requêtes sensibles (cybersécurité, biologie et chimie, et tentatives de distillation de modèle) vers Claude Opus 4.8 au lieu d'y répondre directement. Cela se produit dans moins de 5 % des sessions. Vous n'avez rien à configurer pour cela, mais cela explique la réponse occasionnelle qui est étiquetée comme un modèle différent. Plus de détails à ce sujet dans la section sur la gestion des erreurs.
Votre premier appel à l'API Claude Fable 5
Commencez par curl pour pouvoir voir la requête et la réponse brutes sans interférence. Le point de terminaison est POST https://api.anthropic.com/v1/messages, documenté dans la référence de l'API Messages d'Anthropic, et il nécessite trois en-têtes plus un corps 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","max_tokens":1024,"messages":[{"role":"user","content":"Summarize what makes a good REST API in 3 bullet points."}]}'
Trois en-têtes sont importants ici. x-api-key contient votre clé. anthropic-version spécifie la version de l'API (2023-06-01 est la valeur stable actuelle). content-type indique au serveur que vous envoyez du JSON. Le corps a trois champs obligatoires : model, max_tokens et messages. C'est l'ensemble du contrat.
La réponse est un objet JSON. La partie qui vous intéresse est content, qui est une liste de blocs :
{
"id": "msg_01ABC...",
"type": "message",
"role": "assistant",
"model": "claude-fable-5",
"content": [
{ "type": "text", "text": "- Predictable, resource-oriented URLs..." }
],
"stop_reason": "end_turn",
"usage": { "input_tokens": 18, "output_tokens": 96 }
}
content est une liste, pas une chaîne de caractères, car une seule réponse peut mélanger du texte, des blocs d'utilisation d'outils et des blocs de réflexion. Parcourez toujours la liste et vérifiez le type de chaque bloc avant de lire text. Le stop_reason vous indique pourquoi le modèle s'est arrêté (end_turn signifie une fin propre), et usage vous donne le nombre de jetons que vous utiliserez plus tard pour le calcul des coûts.
Appeler Fable 5 depuis Python
Le SDK Python officiel d'Anthropic supprime les en-têtes et le code répétitif JSON. Installez-le d'abord :
pip install anthropic
Voici l'appel de base. Le client lit votre clé depuis l'environnement, vous n'avez donc pas à la transmettre :
import anthropic
client = anthropic.Anthropic() # reads ANTHROPIC_API_KEY from env
response = client.messages.create(
model="claude-fable-5",
max_tokens=1024,
messages=[{"role": "user", "content": "Summarize what makes a good REST API."}],
)
for block in response.content:
if block.type == "text":
print(block.text)
Le modèle reproduit l'appel curl. Vous passez model, max_tokens et messages, et vous obtenez en retour une réponse dont le content est une liste de blocs. La boucle vérifie block.type == "text" pour ne jamais rencontrer un bloc non textuel.
Ajouter une invite système
Une invite système définit le rôle du modèle et les règles de base pour l'ensemble de la conversation. Transmettez-la comme champ system, séparément des messages :
response = client.messages.create(
model="claude-fable-5",
max_tokens=2048,
system="You are a senior backend engineer. Be concise and use code examples.",
messages=[{"role": "user", "content": "Write a Flask route that validates a JSON body."}],
)
for block in response.content:
if block.type == "text":
print(block.text)
L'invite système est l'endroit idéal pour la persona, les règles de format de sortie et les contraintes que vous souhaitez maintenir à chaque tour de conversation. Gardez-la stable, car la modifier à chaque requête annulerait la mise en cache des invites si vous l'ajoutiez ultérieurement.
Diffusion en continu de longues sorties
Pour tout ce qui produit une longue réponse, diffusez-la en continu. La diffusion en continu envoie les jetons au fur et à mesure de leur génération, ce qui vous permet de montrer immédiatement la progression et d'éviter les délais d'attente des requêtes qui affectent les grandes réponses non diffusées. Le travail à long terme de Fable 5 en fait le choix par défaut pour les charges de travail réelles :
with client.messages.stream(
model="claude-fable-5",
max_tokens=4096,
messages=[{"role": "user", "content": "Explain idempotency keys for payment APIs."}],
) as stream:
for text in stream.text_stream:
print(text, end="", flush=True)
final = stream.get_final_message()
print(f"\n\nTokens: {final.usage.output_tokens}")
stream.text_stream génère des fragments de texte au fur et à mesure de leur arrivée. Le flush=True est important afin que chaque fragment s'affiche immédiatement au lieu d'être mis en tampon. Lorsque le flux se termine, stream.get_final_message() vous remet le message assemblé complet, y compris les nombres usage finaux, afin que vous obteniez l'expérience utilisateur de diffusion en continu et l'objet complet sans seconde requête.
Appeler Fable 5 depuis TypeScript / Node
Le SDK Node suit la même structure. Installez-le :
npm install @anthropic-ai/sdk
Ensuite, effectuez l'appel. Le client lit ANTHROPIC_API_KEY depuis l'environnement, comme en Python :
import Anthropic from "@anthropic-ai/sdk";
const client = new Anthropic(); // reads ANTHROPIC_API_KEY
const msg = await client.messages.create({
model: "claude-fable-5",
max_tokens: 1024,
messages: [{ role: "user", content: "List 3 common API security mistakes." }],
});
console.log(msg.content);
msg.content est la même liste de blocs que vous avez vue en Python et avec curl. Pour extraire uniquement le texte, filtrez sur le type de bloc :
const text = msg.content
.filter((block) => block.type === "text")
.map((block) => block.text)
.join("");
console.log(text);
La diffusion en continu fonctionne de la même manière qu'en Python. Utilisez client.messages.stream({...}) et itérez sur les événements, ou attendez finalMessage() pour le résultat assemblé. Si vous intégrez cela dans un chat frontal, diffusez depuis une route serveur et transférez les fragments au navigateur. Les mêmes habitudes de test s'appliquent, que vous développiez en Node ou en Python, et un outil comme Apidog facilite la vérification du contrat avant d'écrire tout code client, ce qui est le même flux de travail couvert dans le test de l'API ChatGPT avec Apidog.
Utilisation d'outils (appel de fonctions) avec Fable 5
L'utilisation d'outils permet à Fable 5 d'appeler des fonctions que vous définissez. Vous décrivez un outil avec un schéma JSON, le modèle décide quand l'appeler, et vous exécutez la fonction réelle et renvoyez le résultat. Fable 5 est très performant en matière d'utilisation d'outils, c'est pourquoi il s'intègre bien aux boucles d'agents.
Définissez un outil avec un nom, une description et un input_schema :
tools = [
{
"name": "get_order_status",
"description": "Look up the status of a customer order by ID.",
"input_schema": {
"type": "object",
"properties": {"order_id": {"type": "string"}},
"required": ["order_id"],
},
}
]
Passez tools à la requête de la même manière que vous passez messages :
messages = [{"role": "user", "content": "What's the status of order A1855?"}]
response = client.messages.create(
model="claude-fable-5",
max_tokens=1024,
tools=tools,
messages=messages,
)
Lorsque le modèle souhaite utiliser un outil, la réponse revient avec stop_reason == "tool_use" et un bloc tool_use contenant le nom de l'outil et l'entrée qu'il a choisie. La boucle est simple : ajoutez la réponse de l'assistant, exécutez l'outil, puis renvoyez le résultat sous forme de bloc tool_result dans un nouveau tour utilisateur :
if response.stop_reason == "tool_use":
tool_use = next(b for b in response.content if b.type == "tool_use")
# Run your real function with the model's chosen input
result = lookup_order(tool_use.input["order_id"]) # your code
messages.append({"role": "assistant", "content": response.content})
messages.append({
"role": "user",
"content": [{
"type": "tool_result",
"tool_use_id": tool_use.id,
"content": result,
}],
})
# Send the result back; the model now answers using it
followup = client.messages.create(
model="claude-fable-5",
max_tokens=1024,
tools=tools,
messages=messages,
)
Le détail clé est tool_use_id : le bloc tool_result doit faire référence à l'id exact du bloc tool_use afin que le modèle sache à quel appel votre résultat répond. Pour les agents multi-étapes, vous encapsulez cela dans une boucle qui continue jusqu'à ce que stop_reason soit end_turn. Le SDK Python inclut également un exécuteur d'outils qui gère la boucle pour vous, mais la version manuelle ci-dessus montre ce qui se passe en coulisses et vous donne un endroit pour ajouter des validations ou de la journalisation.
Pensée adaptative et effort
Fable 5 prend en charge la pensée adaptative, où le modèle décide de lui-même quand et avec quelle profondeur raisonner avant de répondre. C'est facultatif. Activez-le en passant thinking, et ajustez la profondeur globale et la dépense de jetons avec output_config :
response = client.messages.create(
model="claude-fable-5",
max_tokens=4096,
thinking={"type": "adaptive"},
output_config={"effort": "high"}, # low | medium | high
messages=[{"role": "user", "content": "Design a retry strategy for a flaky webhook receiver."}],
)
L'effort contrôle la quantité de réflexion et de travail du modèle : un effort moindre signifie des réponses plus concises et plus rapides, un effort plus élevé signifie un raisonnement plus approfondi pour un coût en jetons plus élevé. Désactivez les deux pour les recherches simples et les réponses courtes, où le raisonnement supplémentaire ne vaut pas les jetons. Utilisez-les pour les problèmes difficiles et multi-étapes, le genre de planification à long terme pour lequel Fable 5 est conçu. Restez simple au début ; vous pourrez ajouter thinking plus tard une fois que vous saurez qu'une route en a besoin.
Gestion des erreurs et le repli de sécurité
Les intégrations réelles doivent gérer les échecs proprement. Le SDK lève des exceptions typées, il faut donc intercepter la classe spécifique plutôt que de faire correspondre des chaînes d'erreur. Les trois que vous rencontrerez le plus souvent correspondent aux codes HTTP 401, 429 et 400 :
import anthropic
client = anthropic.Anthropic()
try:
response = client.messages.create(
model="claude-fable-5",
max_tokens=1024,
messages=[{"role": "user", "content": "Explain CORS preflight requests."}],
)
except anthropic.AuthenticationError:
# 401: bad or missing API key. Check ANTHROPIC_API_KEY.
print("Invalid API key. Rotate it in the Console and re-export.")
except anthropic.RateLimitError as e:
# 429: too many requests. Back off and retry.
retry_after = e.response.headers.get("retry-after", "60")
print(f"Rate limited. Retry after {retry_after}s.")
except anthropic.BadRequestError as e:
# 400: malformed request (bad params, empty messages, wrong shape).
print(f"Bad request: {e.message}")
Voici ce que chacun signifie et comment le résoudre :
- 401 (
AuthenticationError) : la clé est manquante, mal formée ou révoquée. Confirmez queANTHROPIC_API_KEYest définie dans l'environnement dans lequel votre code s'exécute réellement et que la clé est toujours active dans la Console. - 429 (
RateLimitError) : vous avez dépassé votre limite de requêtes par minute ou de jetons par minute. Le SDK réessaye déjà les erreurs 429 et 5xx avec une stratégie d'attente exponentielle (deux réessais par défaut). Lisez l'en-têteretry-aftersi vous ajoutez une stratégie d'attente personnalisée. - 400 (
BadRequestError) : la requête est mal formée. Les causes courantes sont un tableaumessagesvide, unmax_tokensmanquant, ou des messages qui n'alternent pas correctement les rôles. Le message d'erreur nomme généralement le champ.
Passons maintenant au repli de sécurité. Fable 5 achemine un petit ensemble de requêtes sensibles (cybersécurité, biologie et chimie, et tentatives de distillation) vers Claude Opus 4.8 au lieu d'y répondre directement. Cela se produit dans moins de 5 % des sessions. Ce n'est pas une erreur, et votre requête réussit toujours, mais la réponse peut revenir étiquetée avec un modèle différent. Si vous journalisez ou effectuez une assertion sur response.model, ne provoquez pas d'échec irrémédiable si ce n'est pas claude-fable-5 ; la requête a été traitée, juste par un modèle différent en coulisses. Si votre application a strictement besoin de savoir quel modèle a répondu, lisez response.model de l'objet retourné plutôt que de supposer qu'il correspond à ce que vous avez envoyé.
Estimer le coût par requête
La tarification est de 10 $ par million de jetons d'entrée et de 50 $ par million de jetons de sortie. Chaque réponse contient les décomptes exacts dans usage, vous pouvez donc calculer le coût par requête avec précision au lieu de deviner :
response = client.messages.create(
model="claude-fable-5",
max_tokens=1024,
messages=[{"role": "user", "content": "Write a SQL query to find duplicate emails."}],
)
input_tokens = response.usage.input_tokens
output_tokens = response.usage.output_tokens
input_cost = input_tokens / 1_000_000 * 10
output_cost = output_tokens / 1_000_000 * 50
total = input_cost + output_cost
print(f"Input: {input_tokens} tokens = ${input_cost:.6f}")
print(f"Output: {output_tokens} tokens = ${output_cost:.6f}")
print(f"Total: ${total:.6f}")
Les jetons de sortie coûtent cinq fois plus cher que les jetons d'entrée, donc le levier le moins cher que vous avez est de maintenir des réponses concises. Une requête avec 2 000 jetons d'entrée et 500 jetons de sortie coûte `2000 / 1M * 10 $ + 500 / 1M * 50 $`, soit `0,02 $ + 0,025 $ = 0,045 $`. Multipliez par votre volume de requêtes pour établir un budget. Si le coût des sorties domine votre facture, plafonnez `max_tokens` et demandez des réponses concises dans l'invite système. La tarification des sorties est le même calcul que vous effectueriez pour le modèle de tarification de Claude Opus 4.8, juste avec les chiffres de Fable 5.
Tester et déboguer l'API Claude Fable 5 avec Apidog
Avant d'écrire du code client, il est utile d'envoyer quelques requêtes manuellement et d'observer exactement ce qui est renvoyé. Apidog est un client API conçu pour cela : vous envoyez de vraies requêtes à `https://api.anthropic.com/v1/messages`, inspectez la réponse diffusée en continu et enregistrez la requête afin que toute votre équipe travaille à partir de la même définition. Voici un chemin clair pour passer de zéro à une requête fonctionnelle et enregistrée.
- Créez la requête. Dans Apidog, créez une nouvelle requête HTTP, définissez la méthode sur `POST` et collez l'URL `https://api.anthropic.com/v1/messages`. C'est le même point de terminaison que tous les exemples de ce guide utilisent.
- Stockez votre clé comme variable d'environnement. Créez une variable d'environnement Apidog, nommez-la par exemple `anthropic_api_key`, et collez votre clé comme valeur secrète. Garder la clé dans l'environnement signifie qu'elle reste en dehors de la requête enregistrée et de toute exportation que vous partagez.
- Définissez les en-têtes. Ajoutez `x-api-key` avec la valeur `{{anthropic_api_key}}`, puis `anthropic-version: 2023-06-01` et `content-type: application/json`. Si vous préférez une variable secrète de type Bearer, stockez le jeton de la même manière et référencez-le avec la syntaxe `{{...}}` afin que la valeur brute n'apparaisse jamais dans la requête.
- Ajoutez le corps JSON. Insérez la charge utile minimale : `{"model": "claude-fable-5", "max_tokens": 1024, "messages": [{"role": "user", "content": "Explain idempotency keys for payment APIs."}]}`. Envoyez-la et lisez la réponse. Vous devriez voir les blocs `content`, `stop_reason` et `usage` directement dans le panneau de réponse.
- Visualisez les réponses diffusées en continu. Définissez `"stream": true` dans le corps et envoyez à nouveau. Apidog affiche les événements envoyés par le serveur au fur et à mesure de leur arrivée, afin que vous puissiez observer les jetons être diffusés et confirmer que votre logique de diffusion correspond à ce que l'API envoie réellement avant de l'intégrer à une application.
- Enregistrez et générez du code. Enregistrez la requête dans une collection afin que les membres de l'équipe puissent la réutiliser, puis utilisez la génération de code d'Apidog pour exporter un extrait fonctionnel en Python, JavaScript, curl ou un autre langage. Cela vous donne un point de départ testé au lieu d'un fichier vide.
Ce flux est le moyen le plus rapide d'apprendre la forme exacte de la réponse de l'API et de déboguer une requête qui se comporte mal dans votre application, car vous pouvez comparer la requête de votre code avec une requête connue et fonctionnelle côte à côte. Lorsque vous êtes prêt à le configurer, téléchargez Apidog et commencez avec le corps minimal ci-dessus.