# API Claude Fable 5.2 (https://wanapi.app/fr/docs/claude-fable-5-2)





Cette référence présente **Claude Fable 5.2** et ses paramètres Messages spécifiques. Utilisez `claude-fable-5-2` avec `POST https://api.wanapi.app/v1/messages`. [Comparer les modèles Claude](/fr/docs/claude-api).

## Paramètres du modèle [#paramètres-du-modèle]

| Paramètre                               | Claude Fable 5.2                  |
| --------------------------------------- | --------------------------------- |
| Identifiant du modèle                   | `claude-fable-5-2`                |
| Fenêtre de contexte                     | 1M tokens                         |
| Sortie synchrone maximale               | 128000 tokens, réflexion comprise |
| Modes de réflexion                      | Adaptative, toujours active       |
| Effort par défaut                       | `high`                            |
| Appels d’outils forcés (`any` / `tool`) | Non pris en charge                |

## Connexion et envoi d’une requête [#connexion-et-envoi-dune-requête]

Créez une clé dans les [paramètres des clés API](/fr/settings/apikeys). Une seule clé API donne accès à tous les modèles et groupes. Conservez-la dans l’environnement de votre serveur sous `WAN_API_KEY`. Envoyez `anthropic-version: 2023-06-01` ; ajoutez `anthropic-beta` uniquement pour les fonctionnalités qui le nécessitent.

```bash
curl https://api.wanapi.app/v1/messages \
  -H "x-api-key: $WAN_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "claude-fable-5-2",
    "max_tokens": 1024,
    "messages": [{"role": "user", "content": "Explain the purpose of a database index in three sentences."}]
  }'
```

```python
import os
import anthropic

client = anthropic.Anthropic(
    api_key=os.environ["WAN_API_KEY"],
    base_url="https://api.wanapi.app",
)
message = client.messages.create(
    model="claude-fable-5-2",
    max_tokens=1024,
    messages=[{"role": "user", "content": "Explain the purpose of a database index in three sentences."}],
)
print("".join(block.text for block in message.content if block.type == "text"))
```

## Prise en charge actuelle de l’API [#prise-en-charge-actuelle-de-lapi]

Le tableau ci-dessous décrit le contrat natif de ce modèle. Wan API transmet actuellement les requêtes par une couche de compatibilité. **Utilisez une valeur `max_tokens` strictement positive** : la passerelle remplace actuellement `0` par un budget de génération ; cette valeur ne permet donc pas ici de précharger uniquement le cache.

La passerelle actuelle ne transmet pas `diagnostics`, `compaction`, `fallbacks`, `fallback_credit_token` ni `thread`. Elle filtre également `speed`, `service_tier` et `inference_geo` dans la configuration actuelle du canal. Ces champs sont documentés ci-dessous pour expliquer le contrat du modèle, mais ils ne sont pas encore disponibles via cette connexion. Une réponse réussie ne signifie pas qu’un champ ignoré a été appliqué. Les fonctionnalités bêta qui nécessitent ces champs ont la même limite.

## Paramètres [#paramètres]

| Champ                   | Type / valeur par défaut            | Contrainte                                                                                                                |
| ----------------------- | ----------------------------------- | ------------------------------------------------------------------------------------------------------------------------- |
| `model`                 | Chaîne obligatoire                  | `claude-fable-5-2`. Utilisez l’identifiant exact ; le choix du groupe est automatique.                                    |
| `max_tokens`            | Entier obligatoire                  | 0–128000, réflexion comprise. Zéro ne peut pas être combiné avec stream true, une sortie structurée ou des outils forcés. |
| `messages`              | Tableau obligatoire                 | 1–100000 tours officiels ; vide uniquement pour poursuivre un thread après pause\_turn.                                   |
| `system`                | Chaîne ou tableau de blocs de texte | À omettre entièrement lors de la poursuite d’un thread.                                                                   |
| `thinking`              | Objet, adaptatif par défaut         | Uniquement adaptive. display : omitted (par défaut), summarized, updates ou null.                                         |
| `output_config`         | Objet                               | effort : low, medium, high (par défaut), xhigh, max ou null. format et task\_budget facultatifs.                          |
| `output_format`         | Objet ou null                       | Ancien alias de sortie structurée ; préférez output\_config.format.                                                       |
| `stop_sequences`        | Tableau de chaînes                  | Ne peut pas être null ; incompatible avec la compaction à la demande.                                                     |
| `stream`                | Booléen, false                      | SSE avec true ; ne peut pas être null.                                                                                    |
| `tools`                 | Tableau                             | Outils client officiels et outils/ensembles d’outils serveur. Les outils client sont exécutés par votre application.      |
| `tool_choice`           | Objet                               | auto ou none ; les appels d’outils forcés sont refusés.                                                                   |
| `metadata`              | Objet                               | user\_id : chaîne ou null, jusqu’à 512 caractères.                                                                        |
| `cache_control`         | Objet ou null                       | type ephemeral, ttl 5m ou 1h.                                                                                             |
| `container`             | Chaîne, objet ou null               | id facultatif et jusqu’à 20 skills.                                                                                       |
| `context_management`    | Objet ou null                       | Modifications officielles du contexte ; nécessite la bêta appropriée.                                                     |
| `mcp_servers`           | Tableau                             | Jusqu’à 20 serveurs HTTPS ; nécessite la bêta MCP appropriée.                                                             |
| `diagnostics`           | Objet ou null                       | previous\_message\_id : chaîne ou null, jusqu’à 256 caractères.                                                           |
| `service_tier`          | auto ou standard\_only              | Facultatif ; ne peut pas être null.                                                                                       |
| `inference_geo`         | Chaîne ou null                      | global ou us, selon la disponibilité du compte.                                                                           |
| `speed`                 | Chaîne ou null                      | standard, fast ou null ; fast ne nécessite pas de bêta.                                                                   |
| `compaction`            | Objet ou null                       | type summarize, instructions facultatives jusqu’à 16384 caractères Unicode.                                               |
| `fallbacks`             | default, tableau ou null            | Jusqu’à trois cibles distinctes ; bêta officielle server-side-fallback requise.                                           |
| `fallback_credit_token` | Chaîne, objet ou null               | Jeton de 2048 caractères au maximum ; bêta officielle de crédit requise ; incompatible avec fallbacks.                    |
| `thread`                | Objet ou null                       | create, ou continue avec previous\_message\_id ; message-threads-2026-08-12 requis.                                       |

## Réflexion et outils [#réflexion-et-outils]

Claude Fable 5.2 utilise la réflexion adaptative avec un effort high par défaut. Il ne prend pas en charge les modes de réflexion enabled, disabled ou between\_tools, ni budget\_tokens. `thinking.display: updates` nécessite `thinking-display-updates-2026-08-18`. `thinking.block_binding` autorise prefix\_mismatch\_behavior error, drop\_block ou null avec `thinking-binding-controls-2026-08-01`.

`output_config.task_budget` nécessite `task-budgets-2026-03-13`, le type tokens, un total entier d’au moins 20000 et, en option, remaining sous forme d’entier non négatif. Omettez remaining lors d’une compaction ou lorsque vous renvoyez un bloc de compaction signé. La compaction à la demande nécessite `compact-2026-09-04` et ne peut pas être combinée avec context\_management, stop\_sequences, une sortie structurée ou des outils forcés. La compaction par seuil utilise `compact-2026-01-12`, avec un déclencheur input\_tokens d’au moins 50000.

L’effort par message sur les messages système nécessite mid-conversation-output-config-2026-07-01. Le préremplissage final de l’assistant est refusé ; les continuations officielles de pause\_turn et de compaction restent valides.

Utilisez computer\_toolset\_20260801 pour l’utilisation d’un ordinateur. Les outils Advisor nécessitent advisor-tool-2026-03-01 et une cible prise en charge. Votre application contrôle l’exécution des outils et leurs autorisations.

La poursuite d’un thread envoie uniquement les nouveaux messages et doit omettre system et tools. Elle ne peut pas être combinée avec une compaction ni avec des modifications du contexte autres que la conservation de toute la réflexion. L’état expire après cinq minutes sans requête ; conservez la conversation localement. Les contraintes dépendant de l’état sont vérifiées lors de la continuation.

Les cibles de repli de Fable 5.2 sont Claude Opus 4.8 et Claude Opus 5. L’exécution des fonctions bêta avancées et la facturation du mode rapide nécessitent une vérification en conditions réelles ; le schéma de requête ne garantit pas des capacités mesurées.

## Entrées multimédias [#entrées-multimédias]

Pour les images et les PDF, utilisez des URL HTTP(S) accessibles publiquement dans les blocs `content` d’un message utilisateur. Hébergez vos fichiers vous-même ; cette intégration ne fournit ni API Files ni téléversement. Exemple d’entrée image :

```json
{"role":"user","content":[
  {"type":"image","source":{"type":"url","url":"https://example.com/chart.png"}},
  {"type":"text","text":"What does this chart show?"}
]}
```

Utilisez un bloc `document` pour un PDF. Conservez les identifiants d’appels d’outils, les blocs de réflexion complets et les signatures à l’identique lorsque vous poursuivez une conversation. Votre application exécute les outils client et renvoie leurs résultats ; déclarer un outil ne l’exécute pas.

## Tarifs [#tarifs]

USD par million de tokens

Les tarifs actuels incluent le coefficient de chaque groupe. Ils sont mis en cache pendant 2 minutes au maximum.

Une seule clé API donne accès à tous les modèles et groupes. La mention « Par défaut » désigne le premier groupe éligible dans l’ordre du routage automatique ; la requête est facturée aux tarifs du groupe effectivement sélectionné.

### Claude Fable 5.2

`claude-fable-5-2`

| Tokens facturables | claude · Par défaut · Toutes les longueurs d’entrée |
| --- | ---: |
| Entrée (hors cache) | 4 $US |
| Sortie | 20 $US |
| Lecture du cache | 0,1 $US |
| Écriture du cache · 5 minutes | 5 $US |
| Écriture du cache · 1 heure | 8 $US |

— signifie qu’aucun tarif vérifié n’est disponible ; cela ne signifie pas que le service est gratuit.

Les tarifs du cache s’appliquent uniquement lorsque la réponse indique l’usage correspondant. Ne comptez pas à nouveau les tokens en cache comme des tokens d’entrée hors cache.

Multipliez chaque nombre de tokens facturables par son tarif et divisez le total par 1 000 000. Les tokens de réflexion sont inclus dans les tokens de sortie, sans être facturés une seconde fois. Les lectures du cache, les écritures de 5 minutes et celles d’1 heure ont des tarifs distincts. Pour une tarification selon la longueur, choisissez le palier applicable avant de calculer le coût de la requête.

## Réponse et flux [#réponse-et-flux]

Un message terminé comprend `id`, `type`, `role`, `model`, `content`, `stop_reason` et `usage`. Lisez les blocs de texte dans `content` ; le premier bloc peut être un bloc de réflexion ou un appel d’outil. Cet exemple est fourni à titre indicatif :

```json
{
  "id": "msg_example",
  "type": "message",
  "role": "assistant",
  "model": "claude-fable-5-2",
  "content": [{"type": "text", "text": "A database index helps locate rows without scanning the whole table."}],
  "stop_reason": "end_turn",
  "usage": {"input_tokens": 24, "output_tokens": 18}
}
```

Définissez `stream: true` pour SSE et utilisez `curl -N`. Traitez `message_start`, `content_block_start`, `content_block_delta`, `content_block_stop`, `message_delta` et `message_stop`, ainsi que `ping` et les erreurs de flux. Lisez l’usage final au lieu de considérer chaque fragment comme une réponse complète.

## Formats compatibles OpenAI [#formats-compatibles-openai]

Le même identifiant de modèle fonctionne avec `POST /v1/chat/completions` et `POST /v1/responses`. Utilisez `Authorization: Bearer YOUR_API_KEY` et l’URL de base du SDK OpenAI `https://api.wanapi.app/v1`. Chat Completions utilise `messages` ; Responses utilise `input`. Leurs champs sont convertis vers Messages : utilisez donc `/v1/messages` pour les paramètres natifs documentés ci-dessus.

```bash
curl https://api.wanapi.app/v1/chat/completions \
  -H "Authorization: Bearer $WAN_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model":"claude-fable-5-2","max_tokens":256,"messages":[{"role":"user","content":"Reply with OK."}]}'
```

## Journaux d’utilisation et erreurs [#journaux-dutilisation-et-erreurs]

Les [journaux LLM](/fr/usage) affichent les appels terminés des 7 derniers jours, avec le modèle, les tokens d’entrée et de sortie et le coût. Actualisez après un appel et filtrez par `claude-fable-5-2`. Utilisez les [journaux des tâches](/fr/tasks) pour les images et les vidéos.

En cas d’échec, examinez le statut HTTP et l’objet `error`. Vérifiez la clé, le [solde](/fr/docs/balance), l’identifiant du modèle et les combinaisons de paramètres prises en charge. Un refus ou un arrêt à la limite de sortie est différent d’une erreur HTTP. Si une requête ou un flux est interrompu, consultez les journaux avant de réessayer : une nouvelle requête peut entraîner de nouveaux frais.

## Références du modèle [#références-du-modèle]

* [Présentation du modèle](https://platform.claude.com/docs/en/models/fable-5-2/overview)
* [Référence Messages](https://platform.claude.com/docs/en/api/beta/messages/create)
* [Réflexion](https://platform.claude.com/docs/en/build-with-claude/thinking)
