Comment réduire les coûts de tokens de Claude Code : le guide pratique d'Anthropic pour des sessions efficaces

Introduction

Anthropic a publié un guide pratique destiné aux développeurs qui souhaitent tirer le meilleur parti de chaque session Claude Code.

Le message central est simple : la même tâche de codage peut coûter des montants très différents selon la manière dont vous gérez la session.

Claude Code n'est pas comme un éditeur traditionnel avec un coût fixe par tâche. Chaque requête au modèle engendre un coût d'inférence, et les conversations longues transportent de manière répétée des fichiers, des résultats d'outils, des sorties de commandes, des instructions système et des messages antérieurs. Si ce contexte est mal géré, une simple correction de bug peut finir par consommer beaucoup plus de tokens que nécessaire.

L'article source a distillé les conseils en six habitudes pratiques :

1. Exécuter /clear lorsqu'une tâche est terminée et que vous passez à une autre.
2. Choisir le modèle et le niveau d'effort de raisonnement au début de la session plutôt que de changer de manière répétée en cours de route.
3. Utiliser @ pour référencer directement les fichiers plutôt que de faire chercher Claude.
4. Ajouter des indicateurs silencieux aux commandes qui produisent sinon de grandes quantités de sortie.
5. Exécuter /compact avant une longue pause pendant que le cache de prompt existant est encore chaud.
6. Envoyer les travaux d'investigation volumineux et bruyants à un sous-agent afin que son contexte intermédiaire ne s'accumule pas dans la conversation principale.

Le propre TL;DR d'Anthropic recommande également d'exécuter /context dans une nouvelle session pour voir ce qui est déjà chargé, y compris CLAUDE.md et les définitions d'outils MCP.

Ces suggestions prennent tout leur sens une fois que vous comprenez ce qui arrive à un token à l'intérieur d'une session Claude Code.

Le cycle de vie d'un token

Claude Code peut être utilisé via les plans Claude payants ou via une utilisation API facturée à l'usage. Pour les utilisateurs individuels, Claude Pro coûte actuellement 20 $ par mois en facturation mensuelle, tandis que Claude Max démarre à 100 $ par mois et propose également un palier d'utilisation supérieur. L'utilisation API est facturée séparément selon le modèle et le volume de tokens.

La documentation sur les coûts de Claude Code d'Anthropic indique que sur les déploiements en entreprise, l'utilisation moyenne est d'environ 13 $ par développeur et par jour actif** et d'environ 150 à 250 $ par développeur et par mois, bien que les coûts réels varient considérablement selon le modèle, la base de code, le flux de travail et le niveau d'automatisation.

La même tâche peut coûter plusieurs fois plus cher si Claude doit rechercher dans des fichiers inutiles, exécuter des commandes verbeuses ou transporter de manière répétée un contexte non pertinent.

Pour comprendre pourquoi, il est utile de séparer

chaque requête en deux phases.

Préremplissage : lecture de l’entrée

Pendant le préremplissage, le modèle lit la requête et son contexte en une seule passe.

Cette entrée peut inclure :

• Les définitions d’outils
• Le prompt système
• CLAUDE.md
• Votre message actuel
• L’historique de conversation antérieur
• Les fichiers que Claude a lus
• Les sorties de commandes et d’outils déjà ajoutées à la session

Tous ces éléments comptent comme des jetons d’entrée.

Décodage : production de la sortie

Pendant le décodage, le modèle génère sa réponse jeton par jeton.

Cela inclut les jetons de raisonnement, les appels d’outils et le texte que vous voyez finalement. Contrairement au préremplissage, le décodage est séquentiel : une réponse de 200 jetons oblige le modèle à générer 200 jetons un après l’autre.

C’est pourquoi les jetons de sortie sont généralement beaucoup plus chers que les jetons d’entrée. Pour les modèles Claude actuels évoqués ici, le prix de la sortie est cinq fois supérieur au prix de base de l’entrée.

Les prix actuels de l’API standard sont les suivants :

MTok signifie un million de jetons.

L’autre variable principale est le niveau d’effort. Une grande partie de la sortie générée lors d’une session de codage agentique peut être du raisonnement. Un effort plus élevé permet au modèle de consacrer plus de jetons à la réflexion sur un problème difficile, tandis qu’un effort plus faible peut être plus adapté aux tâches routinières.

La règle pratique est simple : utilisez un modèle plus puissant et un effort plus élevé lorsque le problème est vraiment difficile ou ambigu, et pas automatiquement pour chaque petite tâche.

La mise en cache du prompt est le principal levier de coût

La mise en cache du prompt est l’un des éléments les plus importants du modèle de coût de Claude Code.

Chaque requête de Claude Code commence par une grande quantité de contenu répété : définitions d’outils, prompt système, CLAUDE.md et l’historique de conversation accumulé jusqu’à présent.

Si le début d’une nouvelle requête correspond exactement à une requête récente, le serveur peut réutiliser l’état précédemment calculé au lieu de traiter à nouveau tout le préfixe partagé.

Une lecture de cache ne coûte que 0,1× le prix normal d’un jeton d’entrée.

Les écritures en cache sont plus chères que l’entrée normale car le serveur doit stocker l’état calculé. Une écriture de cache standard de cinq minutes coûte 1,25× le prix d’entrée de base, tandis qu’une écriture de cache d’une heure coûte 2×. Le point important est que l’écriture a lieu une seule fois, tandis que les hits de cache ultérieurs peuvent réutiliser le préfixe à un dixième du coût d’entrée normal.

Imaginez qu’une conversation contienne déjà 50 000 jetons d’historique. Sans hit de cache, le modèle devrait préremplir tout cet historique au tarif d’entrée normal lors de la requête suivante. Avec un cache valide, le préfixe partagé est lu à 0,1× le tarif de base et seuls les nouveaux

le matériel ajouté doit être traité au prix d'entrée complet.

Sur une longue boucle d'agent, cette différence peut devenir substantielle.

Qu'est-ce qui casse le cache ?

Le cache doit correspondre en continu depuis le début de la requête. Si quelque chose change près du début de ce préfixe—ou modifie une partie de la clé de cache—l'historique restant ne peut plus être réutilisé de la même manière.

L'article source met en évidence six cas courants.

1. Changer de modèle avec /model
2. Chaque modèle dispose d'un cache distinct. Passer d'un modèle à un autre signifie que le tour suivant doit préremplir à nouveau la conversation existante pour le nouveau modèle.
3. Modifier l'effort de raisonnement avec /effort
4. Le niveau d'effort fait partie de la clé de cache. Le modifier en cours de session peut forcer la conversation à être traitée à nouveau.
5. Activer le mode rapide
6. Le mode rapide modifie également la clé de cache. Anthropic recommande de l'activer au début si vous prévoyez de l'utiliser. Désactiver le mode rapide n'entraîne pas la même pénalité de cache.
7. Exécuter /compact
8. La compaction réécrit la conversation en un résumé plus court. L'ancienne conversation ne correspond plus, donc le cache de conversation précédent ne peut pas simplement continuer.
9. Laisser le cache expirer
10. Dans les abonnements Claude Code, Anthropic indique que le cache d'invite expire après une heure d'inactivité. Avec une clé API, la TTL par défaut est de cinq minutes, sauf si le cache d'une heure est explicitement activé.
11. Reprendre une ancienne session
12. Une ancienne session n'a généralement plus de cache actif, et l'invite système est reconstruite au lancement de Claude Code. La requête suivante nécessite donc souvent un nouveau préremplissage.

Cela ne signifie pas que vous ne devriez jamais changer de modèle, d'effort ou compacter une conversation. Cela signifie qu'il existe des moments moins coûteux pour le faire : au début d'une session ou juste après /clear, plutôt qu'au milieu d'un contexte long et coûteux.

Il existe également un cas moins évident en mode opusplan. Anthropic note qu'entrer ou sortir du mode plan peut changer de modèle, donc chaque transition peut invalider le cache du modèle concerné.

Pourquoi /compact est moins coûteux avant une pause

/compact résume la conversation actuelle en une version beaucoup plus courte.

Comme la production de ce résumé nécessite de lire le contexte existant, il est moins coûteux de compacter pendant que la conversation est encore disponible via le cache d'invite. Si vous attendez après une longue pause et que le cache a expiré, Claude peut devoir lire la conversation complète au coût d'entrée normal avant de pouvoir la résumer.

C'est pourquoi Anthropic recommande de compacter avant de vous éloigner du clavier pour une période prolongée.

Votre session grandit discrètement

La mise en cache d'invite rend le contexte répété moins coûteux, mais elle n'empêche pas le contexte lui-même de croître.

Chaque fois que Claude lit un fichier, le contenu du fichier est ajouté à la conversation. Chaque fois qu'il exécute une commande, la sortie peut également être ajoutée. À partir de ce moment, les tours suivants continuent de transporter ce matériel.

Le tour 40 n'est pas seulement la dernière requête. Il transporte également une grande partie de ce qui s'est passé dans les tours 1 à 39.

C'est pourquoi les longues sessions peuvent accumuler des coûts beaucoup plus rapidement que ce que les développeurs attendent. Même lorsque l'ancien historique est

mis en cache, le fait de transporter à plusieurs reprises un contexte non pertinent n'est pas gratuit, et cela occupe également de l'espace dans la fenêtre de contexte.

Claude Code dispose néanmoins d'un garde-fou pour les sorties Bash extrêmement volumineuses. La documentation actuelle d'Anthropic précise que lorsque la sortie d'une commande dépasse 30 000 caractères, Claude Code écrit la sortie dans un fichier et ne conserve qu'un aperçu court et le chemin d'accès dans la conversation.

Le cas délicat est celui d'une sortie verbeuse mais qui reste en dessous de ce seuil.

Une suite de tests qui affiche des centaines de lignes de tests réussis peut rester sous la barre des 30 000 caractères. Dans ce cas, ces lignes peuvent rester dans la conversation et continuer d'être envoyées lors des tours suivants.

Anthropic recommande donc de maintenir activement un contexte de travail allégé.

1. Référencer les fichiers avec @

Si vous savez de quel fichier Claude a besoin, référencez-le directement.

Au lieu de demander à Claude de localiser un fichier par son nom, utilisez une mention @ afin que le fichier soit attaché au message dès le début.

Comparez ces invites sur le plan conceptuel :

Les tests échouent.

Claude devra peut-être rechercher dans le dépôt, inspecter plusieurs fichiers et collecter plusieurs résultats d'outils avant d'atteindre le problème réel.

Une demande plus spécifique élimine une partie de cette exploration :

Corrige le test qui échoue dans utils.test.ts.

Et une référence @ peut éviter l'appel de lecture séparé :

Corrige le test qui échoue dans @utils.test.ts.

Le fichier occupe de toute façon le contexte. L'économie provient de l'évitement des tours de recherche et de lecture inutiles.

Évitez également de joindre le même fichier de manière répétée dans une même conversation. Une fois qu'un fichier est entré dans le contexte, le mentionner à nouveau peut ajouter une copie supplémentaire.

1. Ajouter des drapeaux silencieux aux commandes verbeuses

Les sorties de commande répétées peuvent silencieusement dominer une session.

Pour les commandes que vous exécutez constamment, placez une version concise dans CLAUDE.md afin que Claude connaisse dès le départ l'invocation moins bruyante.

Par exemple :

exécuter un seul fichier de test avec npx vitest run  --reporter=dot

Un rapporteur "dot" peut renvoyer un résultat compact au lieu de centaines de lignes de sortie détaillée.

C'est un petit changement de configuration, mais sur de nombreux tours, cela peut économiser une grande quantité de contexte répété.

1. Isoler le travail à forte sortie dans un sous-agent

Un sous-agent dispose de sa propre fenêtre de contexte.

Il possède son propre prompt système, ses outils et son propre CLAUDE.md, mais il n'hérite pas de la conversation principale complète. Il peut inspecter des journaux, exécuter des commandes, rechercher dans l'historique ou lire un fichier volumineux, puis ne renvoyer que la réponse à la session parente.

Cela est utile pour des tâches telles que :

• « Parcours ce journal de build et dis-moi ce qui ne va pas. »

• « Recherche dans ce fichier volumineux et rapporte la section pertinente. »

• « Exécutez la suite de tests complète et signalez les échecs importants. »

• « Inspectez l'historique Git et résumez le changement qui a introduit ce comportement. »

Les lectures de fichiers intermédiaires et les sorties de commande disparaissent lorsque le sous-agent termine. Seule sa réponse renvoyée entre dans la session principale.

Il y a un compromis : comme le sous-agent n'hérite pas de la conversation parente, il peut avoir besoin de relire des éléments que la session principale connaît déjà. Pour les petites tâches, cette surcharge peut rendre un sous-agent moins efficace. Cela en vaut la peine lorsque la tâche isolée est suffisamment bruyante pour que vous ne vouliez pas que son processus reste dans le contexte principal.

1. Utilisez /clear lorsque la tâche change

C'est l'une des habitudes les plus simples et les plus précieuses.

Une fois que vous avez terminé une correction de bug et que vous commencez une tâche différente, exécutez :

/clear

Les lectures de fichiers, les sorties de commande, les approches échouées et le contexte temporaire de la tâche précédente n'ont plus besoin de suivre chaque tour suivant.

La propre comparaison d'Anthropic montre que conserver trois tâches distinctes dans une seule session continue peut envoyer considérablement plus de jetons que d'effacer entre les tâches.

Si vous devez conserver l'ancienne session pour plus tard, Anthropic recommande d'utiliser /rename avant /clear.

Si vous travaillez toujours sur la même tâche et que vous avez seulement besoin de compresser la partie plus ancienne de la conversation, /compact est le meilleur outil.

Utilisez /rewind lorsque seuls les derniers tours ont mal tourné

Il existe une autre option utile qui est facile à négliger :

/rewind

Si la session n'a déraillé que pendant les derniers tours, le retour en arrière peut supprimer ces tours sans réécrire toute la conversation antérieure.

Cela compte pour la mise en cache. Anthropic affirme que la partie précédant le point de retour peut rester en cache, tandis que /compact réécrit la conversation et a donc son propre coût.

Les trois commandes servent donc à des fins différentes :

La gestion des jetons devient une compétence de développeur

Une fois ces mécanismes clairs, un schéma plus large émerge.

La programmation assistée par IA efficace exige désormais un nouveau type de jugement opérationnel. Les développeurs doivent savoir non seulement comment écrire et déboguer du code, mais aussi :

• Quel modèle est approprié pour la tâche
• Combien d'effort de raisonnement est justifié
• Ce qui doit être dans le contexte actif
• Quand une session doit être effacée ou compactée
• Quelles tâches doivent être déplacées vers des sous-agents
• Quelles commandes produisent une sortie inutile
• Quels changements invalideront un cache de prompt

Il y a un an, ces décisions existaient à peine dans le développement logiciel quotidien. Maintenant, elles peuvent déterminer si deux développeurs paient des montants très différents pour accomplir essentiellement le même travail.

Anthropic lui-même illustre à quel point cela est important à grande échelle.

L'entreprise a rapporté en 2026 que plus de 80 % du code fusionné dans le codebase d'Anthropic a été écrit par Claude, et que l'ingénieur type

fusionnait environ 8 fois plus de code par jour qu’en 2024. Dans un benchmark d’optimisation interne distinct, un système basé sur Claude est passé d’une accélération d’environ 3× en 2025 à environ 52× d’ici avril 2026.

À ce niveau d’utilisation de l’IA, l’efficacité de l’inférence n’est pas un petit détail comptable.

La leçon plus profonde du guide d’Anthropic n’est donc pas simplement « dépenser moins de jetons ». Il s’agit de comprendre où vont les jetons et de s’assurer qu’ils sont dépensés pour un raisonnement utile, des modifications de code et du travail sur les outils, plutôt que pour un historique obsolète et une sortie évitable.

Foire aux questions

Pourquoi Claude Code devient-il plus coûteux lors des longues sessions ?

Chaque nouveau tour reprend l’historique de conversation pertinent, y compris les messages, les fichiers, les appels d’outils et la sortie des commandes. La mise en cache des invites rend les préfixes répétés beaucoup moins chers, mais le contexte croissant consomme toujours des jetons et de la capacité de fenêtre de contexte.

Combien la mise en cache des invites de Claude peut-elle faire économiser ?

Une requête avec cache d’invite est facturée à 0,1× le prix normal du jeton d’entrée de base, soit une réduction de 90 % pour cette portion d’entrée mise en cache. Les écritures en cache coûtent plus cher que les entrées normales, mais les lectures répétées du cache peuvent rapidement compenser ce coût d’écriture initial.

Dois-je utiliser /clear ou /compact dans Claude Code ?

Utilisez /clear lorsque vous passez à une tâche différente et que vous n’avez plus besoin du contexte actuel. Utilisez /compact lorsque vous restez sur la même tâche mais que vous souhaitez que Claude résume l’historique de conversation plus ancien dans un contexte de travail plus réduit.

Que fait /rewind dans Claude Code ?

/rewind vous permet de revenir à un message antérieur et de supprimer les tours suivants du contexte actif. Cela est utile lorsque seule la dernière partie d’une conversation a pris une mauvaise direction et que vous n’avez pas besoin de compacter ou de vider toute la session.

Changer le modèle Claude augmente-t-il le coût en jetons ?

Cela peut le faire. Chaque modèle utilise un cache d’invite distinct, donc changer de modèle au milieu d’une longue conversation peut forcer le traitement de l’historique existant à nouveau au prix d’entrée complet pour le nouveau modèle.

Pourquoi dois-je utiliser @ lors de la référence à un fichier ?

Une référence de fichier avec @ attache le fichier directement au message, ce qui peut éviter à Claude de chercher le fichier ou de faire un appel de lecture supplémentaire. Le contenu du fichier consomme toujours du contexte, donc le bénéfice est d’éviter des étapes de découverte inutiles plutôt que de rendre le fichier lui-même gratuit.

Quand dois-je utiliser un sous-agent Claude Code ?

Utilisez un sous-agent pour un travail qui produit beaucoup de sortie intermédiaire dont vous n’avez pas besoin dans la conversation principale, comme l’inspection de journaux ou l’exécution d’une recherche large. Le sous-agent travaille dans un contexte séparé et n’envoie que sa réponse finale à la session principale.

Comment puis-je vérifier ce qui consomme déjà du contexte ?

Exécutez /context dans une nouvelle session Claude Code. Anthropic recommande de l’utiliser pour inspecter le contexte de démarrage comme CLAUDE.md et les définitions d’outils MCP afin de pouvoir supprimer les instructions ou intégrations dont vous n’avez pas besoin.

Outils associés

• Claude Code : l’outil de codage agentique d’Anthropic pour travailler avec des bases de code à partir du terminal, de l’IDE, du web et d’autres environnements pris en charge.
• Claude : l’interface principale d’assistant d’Anthropic et l’entrée de compte.

point pour les formules Claude qui incluent Claude Code.

• Claude Agent SDK : Le SDK expose la même boucle d'agent, les mêmes outils et les mêmes mécanismes de gestion de contexte que Claude Code.
• Vitest : Un framework de test JavaScript utilisé dans l'exemple d'Anthropic pour réduire les sorties de test bruyantes avec --reporter=dot.

Liens connexes

• Maximiser la valeur de vos sessions Claude Code : Le guide officiel d'Anthropic de août 2026 qui constitue la base technique de cet article.
• Gestion des coûts de Claude Code : Documentation officielle pour suivre l'utilisation, contrôler les dépenses et réduire la consommation de jetons.
• Tarification de l'API Claude : Tarifs actuels des modèles, du cache de prompt, du mode rapide et de l'API.
• Documentation sur la mise en cache des prompts : Explication officielle des TTL de cache, des multiplicateurs d'écriture, des lectures de cache et du comportement d'implémentation.
• Gestion des sessions Claude Code : Guide d'Anthropic pour choisir entre continuer, rembobiner, compacter ou effacer une session.
• Choisir un modèle Claude et un niveau d'effort : Conseils pour adapter la capacité du modèle et l'effort de raisonnement à la difficulté de la tâche.
• La mise en cache des prompts, c'est tout : Les leçons d'ingénierie d'Anthropic sur la préservation de l'efficacité du cache de prompts dans les flux de travail agents.
• Quand l'IA se construit elle-même : Le rapport d'Anthropic sur le code écrit par l'IA en interne, le rendement d'ingénierie et les expériences d'optimisation pilotées par modèles.

Résumé

Les coûts de Claude Code sont influencés par bien plus que le prix du modèle. La longueur du contexte, l'effort de raisonnement, les sorties de commande, la durée des sessions, les hits de cache, la découverte de fichiers et l'utilisation de sous-agents peuvent tous modifier le nombre de jetons qu'une tâche consomme.

Les habitudes à plus forte valeur sont simples : vider le contexte lorsque la tâche change, éviter les changements inutiles de modèle ou d'effort en cours de session, limiter les sorties bruyantes, référencer directement les fichiers connus, compacter avant une longue pause et isoler les travaux à forte production lorsque un sous-agent est plus approprié.

Ces pratiques ne visent pas à minimiser l'utilisation de jetons à tout prix. Elles visent à garantir que les jetons que vous payez contribuent à la tâche plutôt que de transporter à répétition un historique non pertinent.

Une utilisation efficace de Claude Code est de plus en plus une forme d'ingénierie de contexte : gardez le contexte pertinent, préservez le cache lorsqu'il aide, et dépensez le raisonnement là où il améliore réellement le résultat.