Pourquoi Claude coûte si cher : le calcul des tokens

Pourquoi Claude est-il coûteux ? Réponse courte

Claude est coûteux pour quatre raisons qui se cumulent. Les tokens de sortie sont facturés cinq fois plus cher que les tokens d’entrée. L’API ne conserve pas la mémoire de votre conversation : l’historique complet est donc renvoyé et refacturé à chaque échange. Un agent transforme une question en des dizaines d’appels d’API, et chaque appel inclut cet historique qui s’allonge. À cela s’ajoute le fait que le modèle de pointe est tarifé en fonction de la difficulté du travail qu’il effectue, et non du coût d’exécution d’un petit modèle.

Un token est un fragment de texte. À titre indicatif, un token correspond à environ quatre caractères, ou à environ 0.75 mot en anglais. Les tarifs sont indiqués par million de tokens, sous l’abréviation MTok (million de tokens). Tous les tarifs ci-dessous correspondent aux tarifs publiés de l’API Claude en août 2026.

La plupart des factures inattendues s’expliquent par les deuxième et troisième raisons de cette liste. On pense généralement que ce sont les réponses rédigées par Claude qui coûtent cher. Dans une session avec un agent, la rédaction représente souvent moins d’un dixième de la facture.

Les tarifs publiés, pour nous accorder sur les chiffres

[
  {
    "label": "Haiku 4.5",
    "input_usd": 1,
    "output_usd": 5,
    "cache_read_usd": "0.10"
  },
  {
    "label": "Sonnet 5, to Aug 31 2026",
    "input_usd": 2,
    "output_usd": 10,
    "cache_read_usd": "0.20"
  },
  {
    "label": "Sonnet 5, from Sep 1 2026",
    "input_usd": 3,
    "output_usd": 15,
    "cache_read_usd": "0.30"
  },
  {
    "label": "Opus 5",
    "input_usd": 5,
    "output_usd": 25,
    "cache_read_usd": "0.50"
  }
]

Regardez la structure plutôt que les chiffres absolus. Chaque modèle facture exactement cinq fois plus la sortie que l’entrée. Opus 5 coûte 5 dollars par million de tokens d’entrée et 25 dollars par million de tokens de sortie. Haiku 4.5 coûte 1 et 5. L’écart entre le modèle le moins cher et le plus cher est donc de cinq fois, et l’écart entre la lecture et l’écriture est également de cinq fois.

Sonnet 5 bénéficie d’un tarif de lancement de 2 et 10 dollars par million jusqu’au 31 août 2026. À partir du 1 septembre 2026, il passe à 3 et 15. Les tarifs évoluent avec les nouvelles versions des modèles. Vérifiez donc les tarifs en vigueur avant d’établir un budget.

La dernière colonne correspond au tarif de lecture du cache. Elle détermine la plupart des factures. Nous y reviendrons après les calculs.

Pourquoi les tokens de sortie coûtent-ils cinq fois plus cher que les tokens d’entrée ?

La lecture et l’écriture ne demandent pas la même quantité de travail. Les tokens d’entrée sont traités en une seule passe. Le modèle lit l’ensemble du prompt à la fois et le traitement s’exécute en parallèle sur celui-ci. C’est pourquoi un prompt de 60,000 tokens ne demande pas 60,000 fois plus de temps à lire qu’un prompt de 1,000 tokens.

Les tokens de sortie sont produits un par un. Chaque nouveau token nécessite sa propre passe dans le modèle et doit utiliser comme contexte tous les tokens qui le précèdent. Écrire 1,000 tokens signifie donc effectuer 1,000 passes, l’une après l’autre. Ce travail séquentiel ne peut pas être réparti comme la lecture. Chaque token de sortie mobilise donc le matériel plus longtemps.

C’est pourquoi « raccourcir la réponse » est un levier moins efficace qu’on ne le pense. Cette mesure agit sur la moitié la moins importante de la facture d’un agent.

Pourquoi l’intégralité de ma conversation est-elle facturée à chaque tour ?

L’API Claude est sans état. Anthropic ne conserve pas une conversation à laquelle vous ajoutez un message. Chaque requête contient l’historique complet des messages, que le modèle lit en totalité avant de générer sa réponse. Le tour 30 est donc facturé pour les tours 1 à 29 également.

Le coût d’une conversation augmente donc plus vite que sa longueur. Le tour 1 porte sur un petit contexte. Le tour 40 porte sur un contexte important. En additionnant les 40 tours, vous avez payé plusieurs fois le nombre total de tokens effectivement écrits.

[
  {
    "turn": 1,
    "context_tokens": "20,000"
  },
  {
    "turn": 5,
    "context_tokens": "32,000"
  },
  {
    "turn": 10,
    "context_tokens": "45,000"
  },
  {
    "turn": 15,
    "context_tokens": "55,000"
  },
  {
    "turn": 20,
    "context_tokens": "64,000"
  },
  {
    "turn": 25,
    "context_tokens": "74,000"
  },
  {
    "turn": 30,
    "context_tokens": "84,000"
  },
  {
    "turn": 35,
    "context_tokens": "92,000"
  },
  {
    "turn": 40,
    "context_tokens": "100,000"
  }
]

La session ci-dessus commence avec 20,000 tokens. Cela correspond au prompt système, aux définitions des outils et aux premiers fichiers ouverts par l’agent. Au tour 40, le contexte contient 100,000 tokens. Si vous faites la moyenne sur les 40 tours, vous obtenez environ 60 000 tokens lus par requête.

Pourquoi un agent coûte-t-il beaucoup plus cher qu’un chat ?

Un chat correspond à une requête par question. Un agent correspond à une requête par étape. Lire un fichier est une étape. Exécuter un test est une étape. Lire la sortie du test est une étape. Modifier le fichier est une étape. Quarante étapes pour terminer une tâche sont courantes avec un agent de développement.

L’utilisation d’outils entraîne deux coûts supplémentaires. Les définitions des outils sont des tokens d’entrée à chaque requête, car le modèle doit recevoir la liste des outils disponibles à chaque fois. Anthropic publie ce surcoût : le prompt système d’utilisation des outils représente 286 tokens avec Opus 5 lorsque tool_choice est défini sur auto, auxquels s’ajoutent les tokens de vos propres schémas d’outils. Certains outils côté serveur sont également facturés séparément. La recherche web est facturée 10 $ pour 1 000 recherches, en plus des tokens consommés par les résultats.

Chaque résultat d’outil reste aussi dans le contexte. Une commande qui affiche 3 000 lignes ajoute ces 3 000 lignes à chaque requête jusqu’à la fin de la session. L’utilisation des tokens par session affichée par Claude Code permet de le constater : surveillez le compteur d’entrée augmenter juste après une commande très verbeuse.

L’arithmétique d’une session réelle

Voici une heure réaliste de coding agentique avec Opus 5. Quarante requêtes API. Le contexte passe de 20,000 à 100,000 tokens, soit une moyenne d’environ 60,000 tokens par requête. Le modèle écrit environ 700 tokens par requête, avec un mélange de courts appels d’outils et de quelques blocs de code plus longs.

Requests in the session:      40
Average context per request:  60,000 tokens

Total input tokens billed:    40 x 60,000                    = 2,400,000
Input cost on Opus 5:         2,400,000 x $5 / 1,000,000     = $12.00

Total output tokens:          40 x 700                       =    28,000
Output cost on Opus 5:        28,000 x $25 / 1,000,000       =  $0.70

Session total                                                = $12.70

[
  {
    "label": "Input, context re-read",
    "billed_tokens": "2,400,000",
    "cost_usd": "12.00"
  },
  {
    "label": "Output, code and tool calls",
    "billed_tokens": "28,000",
    "cost_usd": "0.70"
  }
]

Regardez la répartition. La lecture coûte 12.00 dollars et l’écriture coûte 0.70 dollars. La sortie que vous lisez réellement représente donc environ cinq pour cent de la facture. Le modèle a écrit 28,000 tokens, tandis que la lecture a été facturée pour 2,400,000 tokens. Personne n’a saisi 2.4 millions de tokens. Les mêmes 100,000 tokens ont été lus encore et encore.

Levier 1 : la mise en cache des prompts, le plus important

La mise en cache des prompts enregistre la forme traitée d’un préfixe stable de votre prompt. Lors de la requête suivante, ce préfixe est lu depuis le cache au lieu d’être traité à nouveau. L’écriture dans le cache coûte 1.25 fois le tarif d’entrée pour le cache de cinq minutes, ou 2 fois ce tarif pour le cache d’une heure. La lecture coûte 0.1 fois le tarif d’entrée. Avec Opus 5, cela représente 0.50 dollars par million, au lieu de 5 dollars.

Appliquez cela à la session précédente. Chacun des 100,000 tokens est écrit une fois dans le cache à mesure que la conversation s’allonge. Les 2,300,000 autres tokens d’entrée deviennent des lectures du cache.

Tokens written to cache:      100,000
Cache write at 1.25x input:   100,000 x $6.25 / 1,000,000    = $0.63

Tokens read from cache:       2,300,000
Cache read at 0.1x input:     2,300,000 x $0.50 / 1,000,000  = $1.15

Output cost, unchanged                                       = $0.70

Session total                                                = $2.48

Vous marquez la partie pouvant être mise en cache avec un champ cache_control. Placez le point d’arrêt après le contenu qui ne change pas d’un tour à l’autre : le system prompt et les définitions des outils. Un document volumineux auquel vous faites régulièrement référence doit se trouver dans ce même bloc stable.

{
  "model": "claude-opus-5",
  "system": [
    {
      "type": "text",
      "text": "<long, stable instructions>",
      "cache_control": {"type": "ephemeral"}
    }
  ],
  "messages": [{"role": "user", "content": "..."}]
}

L’ordre de votre prompt détermine désormais le coût. Pour obtenir un cache hit, il faut une correspondance exacte depuis le tout début du prompt. Tout ce qui change à chaque requête doit donc se trouver après tout ce qui reste inchangé. Si vous placez un timestamp au début de votre system prompt, vous invalidez le cache à chaque tour : tout le préfixe devient un cache miss et vous payez 1.25 fois le tarif d’entrée pour le réécrire.

La réponse vous indique si cela a fonctionné. Envoyez une requête et consultez le bloc d’utilisation.

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-opus-5",
    "max_tokens": 256,
    "messages": [{"role": "user", "content": "Hello"}]
  }'

Chaque réponse contient un objet usage semblable à celui-ci :

{
  "usage": {
    "input_tokens": 105,
    "cache_creation_input_tokens": 7345,
    "cache_read_input_tokens": 7123,
    "output_tokens": 239
  }
}

Une requête répétée qui affiche toujours 0 dans cache_read_input_tokens signifie que le cache n’est pas utilisé. La cause habituelle est une modification avant votre point d’arrêt. Le cache de cinq minutes expire également. Une requête envoyée six minutes plus tard provoque donc un cache miss, suivi d’une nouvelle écriture.

Levier 2 : confier les tâches simples à un modèle plus petit

La plupart des tours d’une session avec un agent ne sont pas complexes. Ouvrir un fichier, exécuter un formatter, consulter un diff. Ces tâches ne nécessitent pas le modèle frontier. Les router vers Haiku 4.5 fait passer le tarif d’entrée de 5 dollars par million à 1.

[
  {
    "label": "Opus 5, no caching",
    "session_cost_usd": "12.70"
  },
  {
    "label": "Opus 5, cached",
    "session_cost_usd": "2.48"
  },
  {
    "label": "Sonnet 5, cached",
    "session_cost_usd": "0.99"
  },
  {
    "label": "Haiku 4.5, cached",
    "session_cost_usd": "0.50"
  }
]

La même session coûte 12.70 dollars avec Opus 5 sans mise en cache, 2.48 avec la mise en cache, 0.99 avec Sonnet 5 et la mise en cache, et 0.50 avec Haiku 4.5 et la mise en cache. La mise en cache seule supprime environ 80 % de la facture. Le choix du modèle élimine la majeure partie du reste.

Voici la réserve importante. Un modèle moins cher qui se trompe vous coûte à nouveau toute la session, ainsi que votre propre temps. Choisissez le modèle selon la difficulté de la tâche, pas selon son prix. Choisir entre Opus, Sonnet et Haiku explique dans quels cas chacun reste fiable.

Hygiène du contexte

Chaque token laissé dans le contexte est facturé à chaque tour restant. Supprimer un token tôt est donc bien plus avantageux que le supprimer tard. Un fichier de 5,000 tokens injecté au tour 5 d’une session de 40 tours est relu 35 fois. Cela représente 175,000 tokens d’entrée supplémentaires, soit presque un dollar avec Opus 5 pour un simple collage imprudent.

Quatre habitudes permettent de réduire ce nombre :

• Démarrez une nouvelle session pour chaque nouvelle tâche au lieu de poursuivre celle d’hier.
• Filtrez les commandes verbeuses avant que leur sortie n’atteigne le modèle, avec un outil comme head -50, plutôt qu’après.
• Demandez uniquement la fonction qui vous intéresse, pas le fichier entier.
• Lorsqu’une longue session ne progresse plus, demandez un résumé, puis repartez de ce résumé. Le résumé contient quelques centaines de tokens. La transcription en contient une centaine de milliers.

Levier 4 : regroupez tout ce qui n’est pas interactif

L’API Batch traite les requêtes de manière asynchrone et réduit de 50 percent le coût des entrées et des sorties. Si un traitement n’a pas besoin d’une réponse dans la seconde, regroupez-le. Cela concerne notamment la classification, l’extraction, la synthèse d’un backlog et les exécutions d’évaluation. La remise Batch se cumule avec la mise en cache des prompts. Elle ne s’applique pas à une session interactive, puisqu’il n’y a rien à attendre.

Est-ce que je paie trop cher ?

C’est la vraie question qui se cache derrière « pourquoi Claude est-il cher ? ». Voici donc une réponse directe. Les tarifs sont publiés, ils sont identiques pour tout le monde sur les niveaux standard et sont facturés au token. Aucun élément de la facture n’est laissé à la discrétion du fournisseur. La grille tarifaire ne peut toutefois pas vous dire si le service est rentable pour vous : elle facture des tokens, tandis que vous vous intéressez aux résultats.

Évaluez donc le résultat obtenu. La session ci-dessus a coûté 12.70 dollars sans cache. Si elle a livré une fonctionnalité qui vous aurait demandé une heure de travail, c’est peu cher. Si elle a consacré quarante tours à tourner en rond, ces mêmes 12.70 dollars n’ont rien produit, et le tarif n’a jamais été le problème.

Voici ce qu’il faut retenir. Votre facture évolue avec le nombre de tokens, pas avec la valeur produite. Une session productive et une session inutile de même longueur coûtent la même chose. C’est pourquoi les quatre leviers comptent davantage que la grille tarifaire : vous ne pouvez pas négocier le prix par token, mais vous décidez du nombre de tokens nécessaires à la tâche.

Suivez donc le coût en dollars par tâche terminée, et non le coût mensuel. Si ce montant diminue pendant que vous optimisez le cache et le routage, votre configuration s’améliore, même si le total mensuel augmente, car cette hausse provient d’un volume de travail plus important.

Ce qui ne réduit pas votre facture

Certaines recommandations courantes ont très peu d’effet. Demander au modèle d’« être concis » réduit la longueur de la réponse, alors que celle-ci représentait 5 % de la facture de l’exemple. Raccourcir votre propre question économise quelques centaines de tokens sur un contexte de 60,000 tokens. Désactiver la réflexion approfondie n’est utile que lorsque les tokens de réflexion représentaient une part importante de votre sortie. Le bloc d’utilisation vous permet de le vérifier au lieu de vous laisser deviner.

Une fenêtre de contexte plus grande n’augmente pas à elle seule le coût. Avec Claude 4.6 et les versions ultérieures, la fenêtre complète d’un million de tokens est facturée au tarif standard par token. Une requête de 900,000 tokens coûte donc le même prix par token qu’une requête de 9,000 tokens. La taille de la fenêtre ne détermine pas le prix. C’est le contenu que vous y placez qui le détermine.

Deux autres points relèvent de la planification plutôt que d’une session unique. Si votre utilisation est quotidienne et interactive, comparez la facturation à l’usage avec un forfait fixe : la comparaison des coûts de l’API et d’un abonnement effectue ce calcul. Si un agent s’exécute sans surveillance sur un serveur, définissez un plafond de dépenses strict avant toute autre optimisation. C’est le sujet de la maîtrise des coûts d’un agent IA sur un VPS. Pour avoir une idée simple de l’échelle, ce qu’un million de tokens Claude permet réellement d’obtenir convertit le tarif en pages de texte.

FAQ

Pourquoi ma facture Claude a-t-elle augmenté lorsque j’ai commencé à utiliser un agent ?

Parce qu’un agent envoie de nombreuses requêtes par question, et que chaque requête contient l’intégralité de la conversation à ce stade. Un chat envoie une requête par question. Un agent de codage envoie une requête par étape, et quarante étapes pour une tâche sont courantes. Chacune de ces requêtes est facturée avec l’intégralité du contexte. Une session qui se termine à 100,000 tokens peut donc représenter plus de deux millions de tokens d’entrée facturés au total. Consultez input_tokens et cache_read_input_tokens dans la réponse de l’API pour le voir directement.

Le prompt caching réduit-il vraiment la facture à ce point ?

Dans l’exemple détaillé, il a fait passer le coût de la session de 12.70 dollars à 2.48 dollars, car une lecture du cache coûte un dixième du tarif d’entrée. L’économie dépend entièrement de votre taux de réussite du cache. Avec le cache de cinq minutes, il devient rentable après une seule lecture : l’écriture coûte 1.25 fois le tarif d’entrée, tandis que la lecture coûte 0.1 fois ce tarif. Si votre prompt est modifié près du début à chaque requête, vous n’obtenez aucun hit et vous payez inutilement le surcoût d’écriture. Confirmez le résultat avec cache_read_input_tokens avant de considérer que le mécanisme fonctionne.

Dois-je simplement utiliser Haiku pour tout ?

Non. Haiku 4.5 coûte 1 dollars par million de tokens d’entrée, contre 5 pour Opus 5. L’économie est donc réelle pour les tâches simples et à fort volume, comme la classification et le routage. Une mauvaise réponse sur une tâche complexe coûte plus cher que l’économie réalisée sur le modèle, car vous payez la nouvelle tentative et votre propre temps en plus. Le schéma le plus robuste est mixte : le petit modèle pour les étapes mécaniques, le modèle frontier pour l’étape qui nécessite du jugement.

L’API est-elle moins chère qu’un abonnement Claude ?

Cela dépend de la régularité de votre utilisation. Un abonnement correspond à un prix mensuel fixe avec des limites d’utilisation. L’API est facturée au token, sans plafond. Elle coûte moins cher lorsque votre utilisation est faible ou concentrée sur des périodes courtes, et plus cher lorsque vous l’utilisez beaucoup chaque jour ouvré. Relevez votre nombre moyen de tokens par jour dans le bloc d’utilisation, appliquez le tarif de votre modèle, puis comparez le résultat au prix de l’offre.