guides

API Claude Fable 5.2 : prix, intégration et exemples de code

Poyo.ai Team
19 min read
Share:

À retenir

  • ID du modèle : claude-fable-5-2. Sorti le 9 novembre 2026, avec une fenêtre de contexte de 1M tokens et jusqu’à 128K tokens de sortie par requête.
  • Prix : $8 / $40 par million de tokens en entrée/sortie sur l’API d’Anthropic, soit 20% de moins que Fable 5.1. Sur PoYo, il coûte $6.40 / $32.
  • Deux façons de l’appeler sur PoYo : le format Messages d’Anthropic sur POST https://api.poyo.ai/v1/messages, ou le point de terminaison compatible OpenAI POST https://api.poyo.ai/v1/chat/completions. Les SDK officiels d’Anthropic fonctionnent en définissant l’URL de base sur https://api.poyo.ai.
  • La réflexion est toujours activée. Vous en réglez la profondeur et le coût avec output_config.effort. La valeur par défaut est high ; utilisez medium ou low pour les tâches courantes.
  • La réflexion est facturée comme de la sortie. Une réponse courte peut tout de même consommer des milliers de tokens de sortie en effort high : définissez donc effort explicitement et dimensionnez max_tokens pour la réflexion et la réponse.
  • Lisez d’abord stop_reason. Il indique si le modèle a terminé, appelé un outil, atteint max_tokens ou renvoyé un refusal de sécurité : vérifiez-le avant de lire le contenu.

L’API Claude Fable 5.2 en un coup d’œil

Claude Fable 5.2
ID du modèle dans l’APIclaude-fable-5-2
Sortie9 novembre 2026
Fenêtre de contexte1M tokens
Sortie maximale128K tokens par requête
Entrée → sortieTexte et images → texte
RéflexionAdaptative, toujours activée
Niveaux d’effortlow, medium, high (par défaut), xhigh, max
Date limite des connaissancesJuin 2026
Conservation des donnéesConservation de 30 jours
Prix officiel (par 1M de tokens)$8 en entrée / $40 en sortie / $0.20 en lecture du cache
Prix sur PoYo (par 1M de tokens)$6.40 en entrée / $32 en sortie / $0.16 en lecture du cache
Points de terminaison PoYo/v1/messages, /v1/chat/completions

Anthropic destine Fable 5.2 au raisonnement exigeant et au travail agentique à long horizon, et recommande Claude Opus 5.5 comme point de départ pour la plupart des charges de travail. Si vous hésitez encore entre les deux, lisez d’abord Claude Fable 5.2 ou Opus 5.5. Ce guide porte sur l’intégration.

Un prototype de système d’exploitation conçu par des agents Claude Fable 5.2, exécuté sur un ordinateur portable. Vidéo issue des supports de lancement de Claude Fable 5.2 publiés par Anthropic.

Fable 5, 5.1 ou 5.2 : de quel prix parle-t-on ?

Une recherche sur « Claude Fable 5 pricing » peut viser n’importe lequel des trois modèles Fable sortis en 2026. Ils partagent la fenêtre de contexte de 1M tokens et la limite de 128K tokens de sortie, et chacun a son propre prix :

ModèleSortieEntréeSortieLecture du cacheID du modèle dans l’API
Claude Fable 59 juin 2026$10$50$1.00claude-fable-5
Claude Fable 5.11er septembre 2026$10$50$0.25claude-fable-5-1
Claude Fable 5.29 novembre 2026$8$40$0.20claude-fable-5-2

Prix officiels en USD par million de tokens. Fable 5.2 marque la première baisse de prix de la gamme Fable et c’est le modèle actuel : les nouveaux projets ont donc intérêt à démarrer avec lui. La suite de ce guide porte sur Fable 5.2.

Les tarifs en bref

Facturation (par 1M de tokens)Tarif officiel d’AnthropicPoYoCrédits PoYo
Entrée$8.00$6.401 280
Sortie (réflexion comprise)$40.00$32.006 400
Lecture du cache$0.20$0.1632
Écriture dans le cache (5 minutes)$10.00$8.001 600
Écriture dans le cache (1 heure)$16.00$12.802 560

PoYo facture à l’usage en crédits, au taux de $1 = 200 crédits, sans abonnement. Toute la fenêtre de contexte de 1M tokens est facturée au tarif standard : un prompt de 900K tokens coûte donc autant par token qu’un prompt de 9K tokens. Pour tous les autres modèles Claude, consultez notre guide des tarifs de l’API Claude.

Démarrage rapide

  1. Créez une clé d’API dans le tableau de bord PoYo.
  2. Envoyez vos requêtes à https://api.poyo.ai en indiquant le modèle claude-fable-5-2.
  3. Authentifiez-vous avec x-api-key: YOUR_KEY sur /v1/messages (Authorization: Bearer YOUR_KEY fonctionne aussi), ou avec Authorization: Bearer YOUR_KEY sur /v1/chat/completions.

curl (format Messages d’Anthropic)

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": "Trouve la condition de concurrence dans ce pool de workers Go et propose un correctif : ..."}
    ]
  }'

La réponse est un objet Message standard d’Anthropic. La réponse du modèle se trouve dans le bloc text de content ; un bloc thinking peut la précéder.

Python (SDK d’Anthropic)

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": "Rédige un plan de migration de REST vers gRPC pour ce 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)

Le streaming met les longues requêtes à l’abri des délais d’expiration HTTP. En effort high et au-delà, une seule requête difficile peut durer plusieurs minutes.

TypeScript (SDK d’Anthropic)

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: "Examine cette pull request à la recherche de failles de sécurité : ..." }],
  })
  .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);
  }
}

Chat Completions compatible OpenAI

Si votre stack utilise déjà le format de requête d’OpenAI, envoyez le même ID de modèle à /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": "Tu es un data engineer senior."},
      {"role": "user", "content": "Conçois un schéma de déduplication d’événements dans ClickHouse."}
    ],
    "stream": true
  }'

Avec le SDK officiel d’OpenAI, définissez base_url sur https://api.poyo.ai/v1. Utilisez /v1/messages lorsque vous avez besoin de réglages propres à Claude, comme output_config.effort, l’affichage de la réflexion, cache_control et les définitions d’outils au format Anthropic.

L’effort : le principal levier de qualité et de coût

Fable 5.2 réfléchit de façon adaptative à chaque requête. Le réglage effort, placé dans output_config, détermine l’ampleur de cette réflexion :

EffortÀ utiliser pourRemarques
lowÉchanges rapides, tâches bien spécifiées, sous-agents à grand volumeLe plus rapide et le moins cher. Pour les tâches longues, ajoutez une consigne du type « termine la tâche entière »
mediumProgrammation interactive, chat, travail intellectuel du quotidienUn bon réglage par défaut pour l’essentiel du trafic d’un produit
high (par défaut)Programmation difficile, recherche, travail agentique, longues exécutions sans supervisionSelon Anthropic, l’essentiel du gain de capacité est déjà atteint en high
xhighLes tâches de programmation et d’agent les plus longues et les plus difficilesÀ utiliser là où vos évaluations mesurent un gain ; consomme davantage de tokens
maxMesurer le plafond, ou de rares tâches où la profondeur compte plus que le temps et les tokensLe raisonnement le plus approfondi et les tours les plus longs

Graphique FrontierCode 2.0 d’Anthropic représentant le score en fonction du coût par tâche, avec Claude Fable 5.2 en effort low, medium, high, xhigh et max aux côtés d’autres modèles

Comment l’effort arbitre entre score et coût par tâche sur FrontierCode 2.0. Graphique issu des supports de lancement de Claude Fable 5.2 publiés par Anthropic.

Trois règles pratiques :

  • Définissez l’effort sur chaque requête. Le code repris d’Opus 5.5 tournait en medium par défaut. Sur Fable 5.2, la même requête tourne en high et consomme davantage de tokens de sortie.
  • Réglez la quantité de réflexion avec l’effort. Pour des tours plus rapides et moins chers, Anthropic recommande un niveau d’effort plus bas plutôt que des consignes du type « réponds directement sans délibérer ». En high et au-delà, Fable 5.2 réfléchit avant presque chaque réponse, même pour une simple salutation.
  • Réglez la longueur de la réponse avec le prompt. L’effort fixe la profondeur de la réflexion ; votre prompt fixe la longueur de la réponse finale.

Pour un exemple chiffré de l’effet de l’effort sur la facture, consultez les résultats des tests pratiques dans Claude Fable 5.2 ou Opus 5.5 : sur une tâche de programmation, Fable 5.2 a obtenu le même score en medium et en high, pour environ un quart du coût en medium.

Réflexion adaptative : ce que « toujours activée » implique pour votre code

  • Omettez thinking, ou envoyez {"type": "adaptive"}. C’est toute la configuration de la réflexion. La profondeur dépend d’effort, qui remplace les anciens réglages budget_tokens et disabled.
  • Les tokens de réflexion sont facturés comme de la sortie et comptent dans max_tokens. Dimensionnez max_tokens pour la réflexion et la réponse : 16K est un bon minimum, et 32K ou plus avec le streaming convient aux tâches difficiles.
  • Les résumés de réflexion s’activent à la demande. Par défaut, les blocs de réflexion arrivent avec un champ thinking vide, ce qui garde un streaming rapide. Ajoutez "display": "summarized" pour recevoir un résumé lisible. Dans les deux modes, la facturation couvre l’intégralité de la réflexion.
  • Laissez le modèle gérer l’échantillonnage. Envoyez vos requêtes sans temperature, top_p ni top_k ; Fable 5.2 gère lui-même l’échantillonnage.
  • Lisez usage. output_tokens inclut déjà la réflexion, et output_tokens_details.thinking_tokens en indique la part.

Utilisation d’outils

Fable 5.2 accepte tool_choice avec la valeur auto (par défaut) ou none. Nommez l’outil dans votre prompt lorsque vous voulez qu’il soit appelé :

{
  "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": "Où en est la commande A-1042 ? Vérifie-le avec get_order_status."}
  ]
}

Lorsque le modèle appelle un outil, la réponse se termine par stop_reason: "tool_use". Exécutez l’outil, puis renvoyez un bloc tool_result dans le message utilisateur suivant. Renvoyez le tour complet de l’assistant tel quel, blocs de réflexion compris.

Autres règles utiles :

  • Utilisez auto ou none pour tool_choice. Pour vous assurer qu’un outil est exécuté, nommez-le dans le prompt. Lorsque vous avez besoin d’un JSON garanti, utilisez la sortie structurée : output_config.format avec un schéma JSON.
  • L’utilisation d’un ordinateur passe par l’ensemble d’outils computer_toolset_20260801.
  • Analysez les entrées des outils avec un parseur JSON. Il gère tous les styles d’échappement que le modèle emploie dans les arguments des outils.

Des bras robotiques pilotés par Claude Fable 5.2 à partir d’images de caméra résolvent un casse-tête cubique. Vidéo issue des supports de lancement de Claude Fable 5.2 publiés par Anthropic.

Contexte de 1M tokens et mise en cache des prompts

La fenêtre de 1M tokens contient environ 555 000 mots anglais, de quoi loger une grande base de code ou une pile de contrats dans une seule requête. Fable 5.2 utilise le tokenizer introduit avec Claude Opus 4.7, qui produit plus de tokens pour un même texte que les modèles antérieurs à 4.7 : comptez donc les tokens de vos propres fichiers avant de planifier en fonction de la limite.

C’est sur les prompts longs que le cache est rentable. Une lecture du cache sur Fable 5.2 coûte 2.5% du prix d’entrée ($0.20 contre $8 par million de tokens). Sur PoYo, ajoutez un cache_control au premier niveau de la requête, et le dernier bloc pouvant être mis en cache l’est automatiquement :

{
  "model": "claude-fable-5-2",
  "max_tokens": 16000,
  "cache_control": {"type": "ephemeral", "ttl": "1h"},
  "output_config": {"effort": "medium"},
  "system": "Tu réponds aux questions sur le contrat ci-dessous. Cite les numéros des clauses.\n\n<contract>...</contract>",
  "messages": [
    {"role": "user", "content": "Liste chaque droit de résiliation et son délai de préavis."}
  ]
}

Placez le contenu stable en premier (prompt système, définitions d’outils, document) et la question qui change en dernier. Dans une conversation à plusieurs tours ou une boucle d’agent, chaque nouveau tour relit le préfixe précédent depuis le cache. Le cache de 5 minutes coûte 1.25× le prix d’entrée à l’écriture et devient rentable dès une lecture ; le cache d’une heure coûte 2× et devient rentable après deux lectures.

Deux habitudes permettent au cache comme au raisonnement du modèle de fonctionner d’un tour à l’autre :

  • Gardez un historique en ajout seul. Chaque bloc de réflexion est lié au prompt système, aux outils et aux messages qui le précèdent. Gardez system et tools identiques pendant toute une conversation et ajoutez les nouveaux tours à la fin de messages. Si des tours précédents sont modifiés et que les anciens blocs de réflexion sont renvoyés, la vérification de préfixe de l’API signale la requête avec le message The block is bound to a different conversation. Pour changer de consignes, démarrez une nouvelle conversation.
  • Changez de modèle quand vous le souhaitez. Vous pouvez modifier model d’une requête à l’autre dans une même conversation. Les blocs de réflexion de Fable 5.2 sont lus par Fable 5.2 et Mythos 5.2 ; lorsque la conversation passe à un autre modèle, comme Opus 5.5, l’API écarte automatiquement ces blocs, la requête aboutit et le nouveau modèle poursuit avec son propre raisonnement. Chaque modèle conserve son propre cache.

Gérer les refus

Fable 5.2 s’appuie sur des classifieurs de sécurité. Lorsque l’un d’eux interrompt une requête, la réponse arrive en HTTP 200 avec stop_reason: "refusal" et un objet stop_details qui nomme le domaine concerné, par exemple cyber, bio ou reasoning_extraction. Votre code doit :

  1. Vérifier stop_reason avant de lire content, comme le font les exemples Python et TypeScript ci-dessus.
  2. Journaliser stop_details.category pour repérer les prompts qui le déclenchent.
  3. Envoyer la requête à un autre modèle, comme Opus 5.5, ou afficher un message clair à l’utilisateur.

Pour voir comment le modèle a raisonné, demandez une réflexion "display": "summarized". Le raisonnement reste ainsi en dehors du texte de la réponse, qui est précisément le domaine couvert par la catégorie reasoning_extraction.

Migrer depuis Fable 5.1 ou Opus 5.5

Vous venez deCe qui change
Claude Fable 5.1Remplacez l’ID du modèle. Les prix passent de $10 / $50 à $8 / $40. La vérification de préfixe s’applique désormais à tous les comptes : gardez donc des historiques en ajout seul. Utilisez computer_toolset_20260801 pour l’utilisation d’un ordinateur. Avec l’outil advisor, définissez l’advisor sur claude-fable-5-2. Refaites votre balayage des niveaux d’effort en partant de high
Claude Opus 5.5Le prix au token passe de $4 / $20 à $8 / $40 ; les lectures du cache restent à $0.20. L’effort par défaut passe de medium à high : définissez-le donc explicitement. Fable 5.2 fonctionne avec une conservation des données de 30 jours. Les règles de réflexion et de tool_choice sont identiques
Claude Opus 5 ou antérieurLaissez la réflexion fonctionner de façon adaptative et pilotez-la avec effort à la place de disabled et budget_tokens. Utilisez tool_choice auto avec une consigne, ou la sortie structurée pour le JSON. Laissez le modèle gérer l’échantillonnage à la place de temperature, top_p et top_k. Dimensionnez max_tokens pour la réflexion et la réponse

Les prompts repris de modèles plus anciens méritent une relecture. Pour les tâches longues en plusieurs étapes, Anthropic recommande d’ajouter au prompt système une consigne du type « termine la tâche entière », en particulier en effort low et medium. Fable 5.2 suit de près les règles de style : assouplissez les limites strictes de longueur de phrase écrites pour les anciens modèles afin de garder une prose naturelle. Démarrez une nouvelle conversation lorsque vous modifiez le prompt.

Ce que coûte une requête

Les tokens de sortie ci-dessous incluent la réflexion. Tous les prix sont exprimés par million de tokens.

ScénarioTokensOfficiel ($8 / $40)PoYo ($6.40 / $32)
Réponse de chat5K en entrée + 1K en sortie0.005×8 + 0.001×40 = $0.0800.005×6.4 + 0.001×32 = $0.064 (12.8 crédits)
Revue de code50K en entrée + 8K en sortie0.05×8 + 0.008×40 = $0.720.05×6.4 + 0.008×32 = $0.576 (115.2 crédits)
Session d’agent2M de lectures en cache + 300K de nouvelle entrée + 150K en sortie2×0.2 + 0.3×8 + 0.15×40 = $8.802×0.16 + 0.3×6.4 + 0.15×32 = $7.04
Document de 800K tokens, première question800K écrits dans le cache de 5 minutes + 10K en sortie0.8×10 + 0.01×40 = $8.400.8×8 + 0.01×32 = $6.72
Même document, question suivante800K en lecture du cache + 10K en sortie0.8×0.2 + 0.01×40 = $0.560.8×0.16 + 0.01×32 = $0.45

Les lignes consacrées au document montrent l’intérêt du cache : après la première question, chaque question suivante coûte environ quinze fois moins. Dans la session d’agent, la sortie représente environ les deux tiers de la facture, et c’est pourquoi l’effort est le premier réglage à ajuster.

Utiliser Claude Fable 5.2 sur PoYo

PoYo vous donne accès à Fable 5.2 à des tarifs au token inférieurs de 20% aux tarifs officiels d’Anthropic, avec quelques avantages pratiques :

  • Une seule clé d’API pour tous les modèles. Fable 5.2, Opus 5.5, Sonnet 5.5, les modèles GPT et les modèles d’image, de vidéo et d’audio partagent la même clé et le même tableau de bord.
  • Paiement à l’usage. Les crédits sont facturés au token, sans abonnement.
  • Les deux formats de requête. Appelez Fable 5.2 au format Messages d’Anthropic ou au format Chat Completions d’OpenAI, avec le même ID de modèle.

Testez vos prompts dans le Playground de la page du modèle Claude Fable 5.2, puis passez le même ID de modèle en production. Pour le comparer au choix par défaut du quotidien, remplacez "model" par claude-opus-5-5 sur la page de Claude Opus 5.5, avec la même clé.

FAQ

Combien coûte l’API Claude Fable 5.2 ?

$8 par million de tokens d’entrée et $40 par million de tokens de sortie sur l’API d’Anthropic, avec des lectures du cache à $0.20. Sur PoYo, le même modèle coûte $6.40 en entrée, $32 en sortie et $0.16 en lecture du cache par million de tokens. Les tokens de réflexion sont facturés au tarif de sortie.

Quel est le prix de Claude Fable 5 ?

Claude Fable 5 (juin 2026) coûte $10 / $50 par million de tokens en entrée/sortie, avec des lectures du cache à $1. Fable 5.1 a conservé le prix de $10 / $50 et ramené les lectures du cache à $0.25. Fable 5.2 le baisse à $8 / $40, avec des lectures du cache à $0.20.

Quel est l’ID du modèle Claude Fable 5.2 ?

claude-fable-5-2, exactement sous cette forme. Utilisez-le sur /v1/messages ou /v1/chat/completions.

Peut-on utiliser le SDK d’Anthropic avec PoYo ?

Oui. Définissez l’URL de base sur https://api.poyo.ai et transmettez votre clé PoYo comme clé d’API. Le SDK envoie x-api-key et anthropic-version pour vous, et le streaming fonctionne avec les utilitaires de stream du SDK.

Comment faire réfléchir Fable 5.2 moins longtemps ?

Définissez output_config.effort sur low ou medium. La réflexion adaptative s’exécute à chaque requête et s’ajuste au niveau d’effort : un niveau plus bas donne des réponses plus rapides et moins chères.

Quel niveau d’effort utiliser ?

Commencez par medium pour le travail interactif et la programmation courante, et par high pour les tâches d’agent difficiles et de longue durée. Passez à xhigh là où vos évaluations montrent un gain, et utilisez low pour les appels simples à grand volume.

Comment le contexte long est-il facturé ?

Toute la fenêtre de 1M tokens est facturée au tarif standard : les prompts longs coûtent donc autant par token que les prompts courts. La mise en cache des prompts réduit encore le coût de relecture d’un contexte long.

Peut-on changer de modèle ou modifier des messages en cours de conversation ?

Le changement de modèle fonctionne à tout moment : envoyez la requête suivante avec un autre model, et l’API écarte automatiquement les blocs de réflexion précédents lorsque c’est nécessaire, si bien que la requête aboutit. Pour les modifications, gardez system et tools identiques, ajoutez les nouveaux messages à la suite et renvoyez chaque tour de l’assistant exactement tel que vous l’avez reçu ; la vérification de préfixe signale les historiques dont des tours précédents ont changé après la production d’un bloc de réflexion. Pour changer de consignes, démarrez une nouvelle conversation.

En quoi Fable 5.2 diffère-t-il de Mythos 5.2 ?

Ils partagent les mêmes capacités, caractéristiques et prix. Mythos 5.2 est proposé aux organisations vérifiées via les programmes d’Anthropic, comme le Cyber Verification Program, tandis que Fable 5.2 est ouvert à tous les développeurs.

Share: