DEV Community

Cover image for Comment utiliser l'API Claude Fable 5
Antoine Laurent
Antoine Laurent

Posted on • Originally published at apidog.com

Comment utiliser l'API Claude Fable 5

Anthropic a lancé Claude Fable 5 le 9 juin 2026. Si vous développez des applications, l’élément important est l’API Claude Fable 5 : elle utilise la même API Messages que les modèles Claude récents, avec principalement un changement de modèle : claude-fable-5. Ce guide montre comment l’appeler avec curl, Python et TypeScript, puis comment gérer le streaming, les outils, les erreurs et le calcul des coûts. Si vous migrez depuis un modèle plus ancien, la transition ressemble surtout à un remplacement de chaîne, comme pour l’API Claude Opus 4.8.

Essayez Apidog aujourd’hui

En bref

Pour appeler Claude Fable 5 :

  1. Créez une clé API dans la Console Anthropic.
  2. Exportez-la dans votre environnement avec ANTHROPIC_API_KEY.
  3. Envoyez une requête POST vers https://api.anthropic.com/v1/messages.
  4. Utilisez model: "claude-fable-5".
  5. Lisez la réponse dans content, puis surveillez usage pour le coût.

Prix indiqué : 10 $ par million de jetons d’entrée et 50 $ par million de jetons de sortie.

Avant de commencer

Vous avez besoin de quatre éléments.

  1. Un compte Anthropic

    Créez-le sur console.anthropic.com. Vous y gérez les clés API, l’utilisation et la facturation.

  2. Une clé API

    Créez une clé dans la Console, section Clés API. Copiez-la immédiatement : elle ne sera plus affichée ensuite.

  3. Une facturation active ou un plan Entreprise

    Fable 5 est disponible via l’API Claude standard et sur les plans Entreprise basés sur la consommation. Vérifiez que votre compte peut envoyer du trafic avant d’intégrer le modèle. Si vous évaluez encore le modèle, consultez aussi l’article sur ce qu’est Claude Fable 5.

  4. Un SDK, ou un client HTTP

    Les SDK officiels Python et TypeScript simplifient les appels. Vous pouvez aussi utiliser curl ou n’importe quel client HTTP.

Définissez la clé dans votre environnement :

export ANTHROPIC_API_KEY="sk-ant-..."
Enter fullscreen mode Exit fullscreen mode

Les SDK officiels lisent automatiquement ANTHROPIC_API_KEY. Évitez de placer la clé dans votre code, vos logs ou votre dépôt git. Si elle fuit, révoquez-la et régénérez-en une depuis la Console.

À connaître : Fable 5 peut rediriger certaines requêtes sensibles — cybersécurité, biologie, chimie ou tentatives de distillation de modèle — vers Claude Opus 4.8. Cela se produit dans moins de 5 % des sessions. Votre requête peut donc réussir tout en retournant un champ model différent de claude-fable-5.

Premier appel à l’API Claude Fable 5 avec curl

Commencez avec curl pour valider la requête brute avant d’écrire du code applicatif.

Point de terminaison :

POST https://api.anthropic.com/v1/messages
Enter fullscreen mode Exit fullscreen mode

Exemple minimal :

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."
      }
    ]
  }'
Enter fullscreen mode Exit fullscreen mode

Les trois en-têtes importants sont :

  • x-api-key : votre clé API.
  • anthropic-version : la version de l’API, ici 2023-06-01.
  • content-type : application/json.

Le corps minimal contient :

  • model
  • max_tokens
  • messages

Exemple de réponse :

{
  "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
  }
}
Enter fullscreen mode Exit fullscreen mode

Ne traitez pas content comme une simple chaîne. C’est une liste de blocs. Un bloc peut contenir du texte, un appel d’outil ou d’autres types de contenu. Vérifiez toujours type avant de lire text.

Appeler Fable 5 depuis Python

Installez le SDK Python officiel d’Anthropic :

pip install anthropic
Enter fullscreen mode Exit fullscreen mode

Appel minimal :

import anthropic

client = anthropic.Anthropic()  # lit ANTHROPIC_API_KEY depuis l'environnement

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)
Enter fullscreen mode Exit fullscreen mode

Cette structure correspond à l’appel curl :

  • model
  • max_tokens
  • messages
  • puis lecture des blocs dans response.content

Ajouter une invite système

Utilisez system pour définir le rôle, le format attendu et les contraintes globales.

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)
Enter fullscreen mode Exit fullscreen mode

Gardez l’invite système stable si possible. Elle est utile pour imposer un style de réponse, mais la modifier à chaque requête rend le comportement plus difficile à tester.

Diffuser les longues réponses en continu

Pour les réponses longues, activez le streaming. Vous recevez les fragments au fur et à mesure au lieu d’attendre la réponse complète.

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}")
Enter fullscreen mode Exit fullscreen mode

stream.text_stream émet les fragments de texte. flush=True force l’affichage immédiat. À la fin, get_final_message() retourne le message complet, avec usage.

Appeler Fable 5 depuis TypeScript / Node

Installez le SDK Node :

npm install @anthropic-ai/sdk
Enter fullscreen mode Exit fullscreen mode

Appel minimal :

import Anthropic from "@anthropic-ai/sdk";

const client = new Anthropic(); // lit 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);
Enter fullscreen mode Exit fullscreen mode

Pour extraire uniquement le texte :

const text = msg.content
  .filter((block) => block.type === "text")
  .map((block) => block.text)
  .join("");

console.log(text);
Enter fullscreen mode Exit fullscreen mode

Pour un chat ou une interface web, diffusez depuis une route serveur, puis transmettez les fragments au navigateur. Avant d’écrire le client final, vous pouvez valider le contrat de réponse avec Apidog, comme dans ce guide sur le test de l’API ChatGPT avec Apidog.

Utiliser les outils avec Fable 5

L’utilisation d’outils permet au modèle de demander l’exécution d’une fonction que vous contrôlez. Le flux est le suivant :

  1. Vous déclarez un outil avec un schéma JSON.
  2. Le modèle choisit d’appeler cet outil si nécessaire.
  3. Votre application exécute la vraie fonction.
  4. Vous renvoyez le résultat au modèle.
  5. Le modèle produit la réponse finale.

Déclarez un outil :

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"],
        },
    }
]
Enter fullscreen mode Exit fullscreen mode

Envoyez la requête avec tools :

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,
)
Enter fullscreen mode Exit fullscreen mode

Si le modèle veut utiliser un outil, stop_reason vaut tool_use et content contient un bloc tool_use.

Exemple de boucle manuelle :

if response.stop_reason == "tool_use":
    tool_use = next(
        block for block in response.content
        if block.type == "tool_use"
    )

    # Votre fonction réelle
    result = lookup_order(tool_use.input["order_id"])

    messages.append({
        "role": "assistant",
        "content": response.content,
    })

    messages.append({
        "role": "user",
        "content": [
            {
                "type": "tool_result",
                "tool_use_id": tool_use.id,
                "content": result,
            }
        ],
    })

    followup = client.messages.create(
        model="claude-fable-5",
        max_tokens=1024,
        tools=tools,
        messages=messages,
    )
Enter fullscreen mode Exit fullscreen mode

Le champ important est tool_use_id. Il doit correspondre à l’id exact du bloc tool_use. Pour un agent multi-étapes, encapsulez cette logique dans une boucle jusqu’à ce que stop_reason soit end_turn.

Pensée adaptative et effort

Fable 5 prend en charge la pensée adaptative. Le modèle peut décider quand raisonner plus profondément avant de répondre. Activez-la avec thinking, puis ajustez l’effort 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."
        }
    ],
)
Enter fullscreen mode Exit fullscreen mode

Utilisez cette option pour les tâches complexes :

  • planification multi-étapes ;
  • architecture ;
  • raisonnement technique ;
  • analyse de compromis.

Désactivez-la pour les réponses simples, les recherches courtes ou les tâches où le coût et la latence comptent davantage.

Gestion des erreurs

Gérez les exceptions typées du SDK au lieu de comparer des chaînes de caractères.

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 : clé API absente, invalide ou révoquée
    print("Invalid API key. Rotate it in the Console and re-export.")

except anthropic.RateLimitError as e:
    # 429 : limite atteinte
    retry_after = e.response.headers.get("retry-after", "60")
    print(f"Rate limited. Retry after {retry_after}s.")

except anthropic.BadRequestError as e:
    # 400 : corps de requête invalide
    print(f"Bad request: {e.message}")
Enter fullscreen mode Exit fullscreen mode

Erreurs courantes :

  • 401 — AuthenticationError

    Vérifiez que ANTHROPIC_API_KEY est définie dans l’environnement réel d’exécution : shell local, conteneur, CI ou plateforme cloud.

  • 429 — RateLimitError

    Vous avez dépassé une limite de requêtes ou de jetons. Le SDK réessaie déjà certaines erreurs 429 et 5xx avec une attente exponentielle. Si vous ajoutez votre propre logique, lisez retry-after.

  • 400 — BadRequestError

    La requête est mal formée : messages vide, max_tokens absent, mauvais format de rôle ou structure JSON invalide.

Gérer le repli de sécurité vers un autre modèle

Fable 5 peut router certaines requêtes sensibles vers Claude Opus 4.8. Ce n’est pas une erreur. La requête peut réussir, mais response.model peut ne pas être claude-fable-5.

Évitez ce type d’assertion stricte :

assert response.model == "claude-fable-5"
Enter fullscreen mode Exit fullscreen mode

Préférez journaliser le modèle réel :

print(f"Model used: {response.model}")
Enter fullscreen mode Exit fullscreen mode

Si votre application doit afficher ou auditer le modèle utilisé, lisez toujours response.model depuis la réponse.

Estimer le coût par requête

Chaque réponse contient usage, avec les jetons d’entrée et de sortie. Utilisez ces valeurs pour calculer le coût réel.

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}")
Enter fullscreen mode Exit fullscreen mode

Exemple :

2 000 jetons d’entrée × 10 $ / 1M = 0,020 $
500 jetons de sortie × 50 $ / 1M = 0,025 $
Total = 0,045 $
Enter fullscreen mode Exit fullscreen mode

Les jetons de sortie coûtent plus cher. Pour réduire le coût :

  • limitez max_tokens ;
  • demandez des réponses concises dans system ;
  • évitez les sorties verbeuses inutiles ;
  • activez la pensée adaptative uniquement sur les routes qui en ont besoin.

Le calcul est similaire à celui utilisé pour la tarification de Claude Opus 4.8, avec les prix de Fable 5.

Tester et déboguer l’API Claude Fable 5 avec Apidog

Avant d’intégrer l’API dans votre application, envoyez quelques requêtes manuellement. Apidog permet de créer une requête HTTP, de tester https://api.anthropic.com/v1/messages, d’inspecter la réponse et de partager la configuration avec votre équipe.

Procédure :

  1. Créez une requête HTTP

    Méthode : POST

    URL : https://api.anthropic.com/v1/messages

  2. Ajoutez votre clé comme variable d’environnement

    Créez une variable Apidog, par exemple :

   anthropic_api_key
Enter fullscreen mode Exit fullscreen mode

Stockez votre clé comme valeur secrète.

  1. Configurez les en-têtes 
   x-api-key: {{anthropic_api_key}}
   anthropic-version: 2023-06-01
   content-type: application/json
Enter fullscreen mode Exit fullscreen mode
  1. Ajoutez le corps JSON minimal 
   {
     "model": "claude-fable-5",
     "max_tokens": 1024,
     "messages": [
       {
         "role": "user",
         "content": "Explain idempotency keys for payment APIs."
       }
     ]
   }
Enter fullscreen mode Exit fullscreen mode
  1. Envoyez la requête Vérifiez dans la réponse :
  • content
  • stop_reason
  • usage
  • model
  1. Testez le streaming Ajoutez stream: true : 
   {
     "model": "claude-fable-5",
     "max_tokens": 1024,
     "stream": true,
     "messages": [
       {
         "role": "user",
         "content": "Explain idempotency keys for payment APIs."
       }
     ]
   }
Enter fullscreen mode Exit fullscreen mode

Apidog affiche les événements serveur au fil de leur arrivée. C’est utile pour valider votre logique de streaming avant de l’implémenter dans une application.

  1. Enregistrez la requête et générez du code Placez la requête dans une collection, puis exportez un extrait en Python, JavaScript, curl ou dans un autre langage. Vous obtenez ainsi une base testée au lieu de repartir d’un fichier vide.

Ce workflow vous aide à comparer une requête applicative qui échoue avec une requête connue comme fonctionnelle. Quand vous êtes prêt, téléchargez Apidog et testez le corps minimal ci-dessus.

Top comments (0)