Limite de tokens Claude Code : comment rester en dessous

Qu'est-ce que la limite de tokens de Claude Code, et comment rester en dessous ?

La limite de tokens de Claude Code est un budget d'usage — pas un nombre fixe de tokens imprimé sur votre forfait — qui se réinitialise sur une fenêtre glissante de 5 heures, avec un plafond hebdomadaire supplémentaire ; et vous restez en dessous en dépensant moins de tokens par tâche plutôt qu'en rationnant vos prompts. Chaque fichier que Claude Code lit, chaque sortie de commande qu'il ingère, et chaque tour où il relit le transcript ponctionne ce budget. Réduisez le nombre de tokens que coûte chaque action et vous abattrez plus de travail avant même de voir apparaître la bannière « limite atteinte ». Je construis des outils de réduction de tokens pour gagner ma vie, alors je serai direct sur la partie que la plupart des guides escamotent : sur les forfaits Pro et Max, Anthropic ne publie pas de nombre fixe de tokens autorisés par semaine. La limite est décrite comme un budget d'usage qui se réinitialise sur une fenêtre glissante, et le même budget est partagé entre claude.ai, Claude Desktop et Claude Code (Anthropic — usage and length limits, Anthropic — Claude Code with Pro or Max). Cela paraît vague jusqu'à ce qu'on le reformule : si le plafond mesure « combien vous pouvez dépenser », alors dépenser moins par tâche est tout l'enjeu. Voici le pendant spécifique à Claude Code de Comment réduire l'usage de tokens de Claude Code — lisez-le pour les mécanismes en profondeur ; cet article-ci porte sur la limite elle-même et comment ne pas s'y écraser.

Comment fonctionne réellement la limite de Claude Code ?

La limite de Claude Code fonctionne comme un budget d'usage partagé qui se recharge sur un cycle glissant de 5 heures, avec un plafond hebdomadaire distinct superposé par-dessus, et elle comptabilise votre usage sur chaque surface Claude que vous touchez. Trois propriétés comptent pour rester en dessous : C'est une fenêtre glissante, pas une réinitialisation quotidienne. Le budget de type session se recharge environ toutes les cinq heures plutôt qu'à minuit (Anthropic — usage and length limits). Ainsi une session de debug brutale d'une heure peut vous verrouiller pour le reste de cette fenêtre même si vous avez à peine travaillé ce jour-là. Le rythme compte. Elle est partagée entre les surfaces. Votre usage de claude.ai, Claude Desktop et Claude Code puise tout dans le même budget (Anthropic — Claude Code with Pro or Max). Si vous avez passé l'après-midi à discuter dans l'application web, vous arrivez dans votre session terminal avec moins de marge que vous ne le pensez. Elle est libellée en tokens que vous ne voyez pas directement. Ce qui est décompté du budget, ce sont les tokens — input et output, plus le transcript complet relu à chaque tour. C'est le point crucial : Claude Code relit l'intégralité de l'historique de conversation à chaque étape de sa boucle agentique, donc une lecture de fichier surdimensionnée tôt dans une session est repayée à chaque tour qui suit. La limite ne mesure pas vos prompts ; elle mesure le poids cumulé en tokens de tout ce qui reste dans le context window. Anthropic ne publie pas de comptes exacts de tokens par forfait, et les plafonds sont explicitement susceptibles d'évoluer pour gérer la capacité (Anthropic — usage and length limits). Je préfère vous donner une méthode qui survit à une modification de la page de tarification plutôt qu'un chiffre périmé au trimestre prochain.

Pourquoi est-ce que j'atteins la limite plus vite que prévu ?

Vous atteignez la limite plus vite que prévu parce que l'agentic coding dépense des tokens sur une courbe quadratique, pas linéaire — la relecture du transcript fait que le gaspillage précoce se compose sur toute la session. Voici le mécanisme en une phrase : à chaque tour, Claude Code relit l'intégralité du contexte, donc un fichier de 6 000 tokens que vous lisez au tour 2 est refacturé aux tours 3, 4, 5, et ainsi de suite. Lisez une douzaine de fichiers d'emblée « pour comprendre la codebase », traînez-les pendant vingt tours, et vous avez payé cette exploration vingt fois. C'est l'agentic coding qui fonctionne comme prévu ; c'est aussi pourquoi les sessions naïves brûlent le budget à une vitesse alarmante. Quatre schémas font l'essentiel des dégâts :

Lectures avides de fichiers entiers. Un fichier TypeScript de 500 lignes pèse environ 5 000 à 7 000 tokens. Claude Code lit par défaut le fichier en entier alors qu'il n'avait besoin que d'une signature de fonction.
Sortie de commande non filtrée. Un npm test en échec peut déverser 15 000 tokens de stack traces et de coches de tests réussis. Le modèle en avait besoin d'une cinquantaine : le nom du test en échec et l'assertion cassée. Voir output filtering pour la solution.
Le manifeste MCP. Chaque serveur MCP connecté re-annonce ses définitions d'outils complètes à chaque tour, utilisé ou non. Cinq serveurs, c'est un surcoût constant et silencieux boulonné à votre budget.
Une session sans fin. Un transcript qui s'étale sur plusieurs tâches sans rapport refacture chaque lecture précoce indéfiniment. C'est la plus grosse fuite évitable que je vois.

Si vous vous êtes déjà demandé pourquoi une session qui semblait productive a soudain calé, c'est presque toujours l'un de ces points — généralement le transcript.

Comment rester en dessous de la limite de tokens de Claude Code ?

Vous restez en dessous de la limite en vous attaquant aux quatre fuites de tokens ci-dessus, à peu près dans cet ordre : bornez le transcript, filtrez la sortie de commande, recherchez au lieu de lire des fichiers entiers, et élaguez vos serveurs MCP. Des étapes concrètes que vous pouvez appliquer dès aujourd'hui :

Lancez /compact de façon proactive, entre les sous-tâches — pas quand l'avertissement se déclenche. /compact remplace les tours antérieurs par un résumé compressé, récupérant du contexte. Le lancer après chaque sous-tâche terminée signifie que chaque nouvelle sous-tâche démarre d'une base épurée au lieu de refacturer les lectures de fichiers de la précédente. Traitez-le comme de l'hygiène de session, pas comme un frein d'urgence.
Démarrez une nouvelle session par tâche. Un travail sans rapport n'a pas sa place dans le même transcript. Une nouvelle session est le contexte le moins cher possible — il n'y a rien à relire.
Faites chercher l'agent, pas lire. Pointez Claude Code vers une fonction ou un symbole plutôt que de lui demander de « lire le fichier ». Le semantic code search renvoie les 200 tokens pertinents au lieu du fichier entier de 6 000 tokens.
Filtrez avant que le modèle ne voie. Faites passer les commandes bruyantes par quelque chose qui renvoie la ligne d'erreur, pas le log complet. Le modèle corrige le bug tout aussi bien à partir de 50 tokens que de 15 000.
Déconnectez les serveurs MCP que vous n'utilisez pas cette session. Le manifeste de chacun est une taxe par tour. Charger paresseusement les définitions d'outils seulement quand elles sont invoquées supprime ce surcoût constant.
Gardez CLAUDE.md stable et court. Le prompt caching sur Claude ne se déclenche que lorsque le préfixe est identique octet pour octet d'un tour à l'autre, et un cache read est facturé à environ 10 % d'un token d'input frais. Un CLAUDE.md que vous éditez en cours de session annule le cache et se voit refacturé au plein tarif. Stable et concis, c'est à la fois une réduction de tokens et un multiplicateur de cache.

Aucune de ces mesures ne sacrifie la qualité. Elles retirent du bruit — logs boilerplate, corps de fichiers non pertinents, définitions d'outils inutilisées — pas le signal sur lequel Claude raisonne. Les modèles prêtent le moins attention à l'information enfouie dans un contexte gonflé, donc une fenêtre plus épurée produit généralement de meilleures réponses, pas de moins bonnes. C'est tout l'argument du context engineering, et c'est la rare optimisation où moins cher et meilleur pointent dans la même direction.

Acheter un forfait plus gros règle-t-il le problème ?

Acheter un forfait plus gros relève le plafond mais ne change pas la pente — si vos sessions gaspillent des tokens, un forfait 20x vous laisse juste en gaspiller 20x plus avant de caler. Les paliers Max offrent réellement des limites bien plus élevées, et si vous êtes un gros utilisateur c'est le bon choix (Anthropic — Claude Code with Pro or Max). Mais accordez un instant aux coûts unitaires d'abord. Si jamais vous passez à l'API, le gaspillage n'est plus une limite de débit — il est facturé. Au tarif catalogue, Claude Opus 4.8 coûte 5 $ par million de tokens d'input et 25 $ par million d'output ; Sonnet 4.6 est à 3 $ / 15 $ ; Haiku 4.5 à 1 $ / 5 $. Un cache read coûte environ 10 % d'un token d'input frais. Relire ce fichier de 6 000 tokens vingt fois sur Opus représente 120 000 tokens d'input — environ 0,60 $ — pour un fichier lu une seule fois. Multipliez sur une vraie session et la « limite » cesse d'être abstraite ; c'est de l'argent. La décomposition Coûts en tokens des agents de codage IA contient tous les calculs, et le calculateur de coût en tokens LLM vous laisse entrer vos propres chiffres. Mon avis honnête : optimisez d'abord la pente, puis dimensionnez le forfait à votre usage réel. La plupart des gens qui pensent avoir besoin de Max ont en réalité juste besoin d'arrêter de traîner du contexte mort.

Comment faire tout cela sans micro-gérer chaque prompt ?

Vous automatisez les leviers au lieu de vous en souvenir, parce que les techniques ci-dessus ne fonctionnent que si vous les appliquez avec constance — et les humains sont mauvais en constance sous deadline. C'est l'écart que comble Tokenade. Il applique automatiquement la récupération sémantique, la compression de sortie, les lectures structure-first et le chargement paresseux des MCP à l'intérieur de Claude Code (et de Cursor, Codex, Copilot, Windsurf — les mêmes mécaniques sont agnostiques de l'agent, puisque tout agent qui relit son transcript a le même problème), avec un dashboard pour que vous puissiez réellement voir ce que vous économisez au lieu de deviner. Il est source-available sous licence MIT, vous pouvez donc auditer exactement ce qu'il envoie. Gratuit jusqu'à environ 20M de tokens par mois ; Pro est à 9,90 $/mois HT aux États-Unis (9,90 €/mois TTC en France) avec 3 sièges. Le but n'est pas de ne jamais atteindre la limite — c'est de faire de l'atteindre l'exception plutôt que votre mardi.

Ce qui dérape (anti-patterns)

« Lis d'abord tout le projet. » Ça semble exhaustif ; c'est une grenade à tokens. Claude Code charge d'emblée des dizaines de milliers de tokens qu'il ignorera en grande partie, puis les refacture à chaque tour — droit dans votre limite. Demander au modèle d'« être bref » pour économiser le budget. Cela rogne l'output, qui est la partie peu chère et petite. La limite est dominée par l'input — le transcript et les lectures de fichiers que vous continuez d'alimenter. La brièveté en output ne change presque rien. Une seule session marathon pour toute la journée. Un historique non borné est la route la plus rapide vers la limite. Compacter et redémarrer entre les tâches n'est pas un hack ; c'est une gestion de session correcte. Attendre l'avertissement de limite avant de compacter. Le temps que l'avertissement se déclenche, vous avez déjà payé le gonflement sur des dizaines de tours. Compactez de façon proactive. Ajouter des serveurs MCP et les oublier. Le manifeste de chaque serveur connecté est facturé à chaque tour, utilisé ou non. Connectez ce dont cette session a besoin ; déconnectez le reste.

Foire aux questions

Quelle est la limite exacte de tokens pour Claude Code sur Pro ou Max ?

Anthropic ne publie pas de nombre de tokens fixe. La limite est décrite comme un budget d'usage qui se réinitialise sur une fenêtre glissante (environ cinq heures) avec un plafond hebdomadaire, partagé entre claude.ai, Claude Desktop et Claude Code, et explicitement susceptible d'évoluer pour gérer la capacité (Anthropic — usage and length limits). En pratique, « la limite » est le poids en tokens que vos sessions accumulent — c'est pourquoi réduire les tokens par tâche est le levier, pas mémoriser un chiffre.

Claude Code partage-t-il sa limite avec claude.ai ?

Oui. L'usage de claude.ai, Claude Desktop et Claude Code compte tout dans le même budget (Anthropic — Claude Code with Pro or Max). Un après-midi chargé sur l'application web vous laisse moins de marge dans le terminal.

Réduire les tokens rendra-t-il les réponses de Claude Code moins bonnes ?

Non — bien fait, cela les rend meilleures. Vous retirez du contexte à faible valeur (logs bruts, corps de fichiers non pertinents, définitions d'outils inutilisées), pas le signal sur lequel le modèle raisonne. Un context window plus épuré relève le rapport signal/bruit. La seule façon de nuire à la qualité est de compresser quelque chose de porteur, et c'est pourquoi les lectures structure-first conservent chaque signature de fonction et les output filters conservent l'erreur réelle.

`/compact` réinitialise-t-il ma limite ?

Non. /compact réduit le context window pour les tours futurs en résumant l'historique antérieur ; il ne rembourse pas les tokens déjà dépensés et ne réinitialise pas le budget d'usage. Sa valeur est tournée vers l'avant : chaque tour après un compact est moins cher, donc vous étirez davantage le budget qu'il vous reste.

Ces techniques fonctionnent-elles avec Cursor, Copilot ou Windsurf ?

Oui. Les mécaniques sont agnostiques de l'agent — tout agent facturé au token qui relit son transcript à chaque tour a le même problème et bénéficie des mêmes leviers. Le tableau d'ensemble inter-agents est dans Comment réduire l'usage de tokens des agents de codage IA.

À voir aussi :

Comment réduire l'usage de tokens de Claude Code — les mécanismes en profondeur derrière chaque levier ici.
Comment réduire l'usage de tokens des agents de codage IA — le pilier inter-agents dont celui-ci dérive.
Context engineering pour les agents de codage IA — la discipline derrière un context window épuré.
Coûts en tokens des agents de codage IA — les calculs de tarification derrière la limite.
Calculateur de coût en tokens LLM — entrez vos propres chiffres de session.