Coût en tokens de Claude Code : ce qu'une session brûle vraiment

Réponse rapide : attendez-vous à des dollars par session, pas des centimes.

Claude Code est un outil agentique, pas une fenêtre de chat. Une seule requête de votre part peut déclencher des dizaines d'appels de modèle, et chaque appel renvoie l'intégralité de la conversation grandissante comme tokens d'entrée. C'est le volume d'entrée, pas la sortie, qui pilote le coût. Les tokens de sortie sont généralement une erreur d'arrondi à côté de l'entrée. Des chiffres approximatifs rapportés par la communauté situent une session sérieuse d'une heure sur un dépôt de taille moyenne à environ 5 à 20 millions de tokens. Aux tarifs directs Anthropic pour Sonnet 4.6 ($3 par million en entrée, $15 par million en sortie), la plupart des sessions se situent entre environ $2 et $40 avant les remises de mise en cache, et les journées intensives sur Opus dépassent largement ce chiffre. La mise en cache de prompt fait baisser les factures réelles sous ce calcul naïf, mais la tendance reste la même : les longues sessions sur de gros dépôts coûtent réellement de l'argent. Vous avez trois leviers. Réduire ce qui entre dans la fenêtre de contexte, router le travail routinier vers des modèles moins chers, et baisser le tarif par token en changeant où les requêtes sont facturées. Le reste de cette page détaille chacun avec des chiffres concrets.

Où partent réellement les tokens.

Deux mécaniques atténuent cela. Premièrement, la mise en cache de prompt Anthropic : Claude Code marque les préfixes stables comme pouvant être mis en cache, les écritures de cache coûtent une prime, et les lectures de cache sont facturées à environ un dixième du tarif d'entrée normal. Deuxièmement, la compaction de contexte : la commande /compact résume l'historique et supprime la transcription brute. Les deux aident beaucoup, et aucune ne change la règle fondamentale : tout ce qui se trouve dans la fenêtre est payé à chaque appel qui l'inclut. C'est pourquoi la même question coûte des montants radicalement différents selon les dépôts. Une question posée dans une session fraîche avec un CLAUDE.md léger est bon marché. La même question posée 30 tours après le début d'une session qui a lu une douzaine de gros fichiers repose sur une fenêtre de tokens à six chiffres.

• Prompt système et définitions d'outils : environ 15 à 20K tokens, renvoyés à chaque appel de modèle.
• CLAUDE.md, fichiers de règles et schémas d'outils MCP : chargés au démarrage de la session et portés dans chaque appel suivant.
• Lectures de fichiers : un fichier source de 500 lignes fait environ 5 à 7K tokens, et il reste dans la fenêtre après avoir été lu une fois.
• Résultats d'outils : sorties de tests, résultats de grep et journaux de terminal sont ajoutés à la conversation et refacturés comme entrée à chaque tour ultérieur.
• La boucle agentique elle-même : un simple « corrige ce test qui échoue » peut produire 10 à 40 appels de modèle avant que Claude Code ne rende la main.

Calcul de coût de session réaliste.

Modélisez tour par tour plutôt que de deviner. Une session typique de taille moyenne compte environ 40 appels de modèle. Une fois que quelques fichiers et des sorties de tests se sont accumulés, la fenêtre complète moyenne environ 90K tokens par appel. Quarante appels à 90K, cela fait 3,6M tokens d'entrée. La sortie reste petite : 40 appels à environ 1 000 tokens chacun, cela fait environ 40K tokens de sortie. Le tableau ci-dessous tarife trois profils de session aux tarifs officiels directs Anthropic. Considérez ces chiffres comme des plafonds : la mise en cache de prompt réduit fortement le préfixe répété, donc les sessions mises en cache reviennent généralement moins cher. Le schéma correspond toujours à ce que rapportent les développeurs. Des après-midis occasionnels coûtent quelques dollars ; faire tourner Opus comme pilote quotidien sur l'API peut atteindre plusieurs centaines de dollars par mois.

Plan vs API : quelle voie rend Claude Code moins cher ?

Anthropic vend Claude Code de deux façons : intégré dans des plans d'abonnement à tarif fixe avec des plafonds d'usage appliqués sur des fenêtres glissantes, ou mesuré par token sur l'API. La tarification API de Claude Code applique simplement les tarifs de modèle ci-dessus à ce que vos sessions brûlent, sans plafond et sans coupure. Le seuil de rentabilité est une simple arithmétique. Si votre session typique coûte environ $11 sur Sonnet aux tarifs directs, un plan à $20 s'amortit en environ deux sessions par mois, à condition de rester sous ses plafonds. Le piège, ce sont justement les plafonds : un usage agentique intensif est exactement le schéma qui déclenche les limites glissantes, et un tarif fixe cesse d'être avantageux dès que vous êtes bloqué en plein milieu d'une session. La facturation API inverse ce compromis. Vous n'êtes jamais coupé, et vous payez exactement ce que vous brûlez. Beaucoup d'utilisateurs intensifs finissent en hybride : un plan pour le travail interactif, une clé API pour les tâches CI et le débordement.

Comment réduire le coût en tokens de Claude Code.

Les deux derniers leviers se cumulent. Router un modèle bon marché via un endpoint réduit peut transformer une session à $10 en bien moins d'un dollar pour du travail routinier. Une option de passerelle est APIsRouter, une API compatible OpenAI en facturation à la consommation et sans abonnement : les modèles globaux sont tarifés en dessous du tarif de liste officiel, les modèles chinois se situent en dessous de leurs tarifs officiels, la première recharge ajoute +100% de solde, et le paiement sans inscription sur /topup encaisse d'abord le paiement puis envoie la clé par e-mail. Le tableau ci-dessous montre à quoi ressemble une échelle de routage en pratique. Kimi K2.6 (kimi-k2.6) est aussi disponible si vous le préférez comme palier économique.

• Gardez CLAUDE.md léger. Chaque ligne est un coût récurrent sur chaque appel de modèle de chaque session.
• Démarrez une session fraîche par tâche et lancez /compact quand une longue session dérive. Une fenêtre de 150K tokens facture 150K à chaque appel.
• Cadrez les lectures. Pointez Claude Code vers des fichiers spécifiques plutôt que de le laisser explorer librement, et excluez les sorties de build et les répertoires vendored.
• Désactivez les serveurs MCP que vous n'utilisez pas. Leurs schémas d'outils circulent dans le prompt système à chaque appel.
• Routez par modèle. Gardez Opus pour l'architecture et le débogage difficile, faites tourner Sonnet par défaut, et poussez le code répétitif, l'échafaudage de tests et les messages de commit vers des modèles moins chers.
• Baissez le tarif par token lui-même en pointant la base URL vers une passerelle au lieu de facturer aux prix de liste directs.

Exemple de configuration : rediriger Claude Code et vérifier.

Claude Code lit ANTHROPIC_BASE_URL au démarrage, donc changer où les tokens sont facturés est un changement de configuration, pas de flux de travail. Placez le endpoint et la clé dans ~/.claude/settings.json et chaque session les récupère. Les identifiants de modèle restent les mêmes, l'exécution des outils reste locale sur votre machine, et le retour en arrière consiste à commenter une seule ligne. Pour les outils et scripts compatibles OpenAI, la base URL se termine par /v1 (https://api.apisrouter.com/v1). Vérifiez la clé avec un curl ponctuel avant de pointer votre pilote quotidien vers elle :

{
  "env": {
    "ANTHROPIC_BASE_URL": "https://api.apisrouter.com",
    "ANTHROPIC_AUTH_TOKEN": "sk-APIsRouter-...",
    "ANTHROPIC_MODEL": "claude-sonnet-4-6",
    "ANTHROPIC_DEFAULT_OPUS_MODEL": "claude-opus-4-7",
    "ANTHROPIC_DEFAULT_SONNET_MODEL": "claude-sonnet-4-6"
  }
}

Questions fréquentes