Passer au contenu principal
Claude Code consomme des tokens pour chaque interaction. Les coûts varient en fonction de la taille de la base de code, de la complexité des requêtes et de la longueur de la conversation. Le coût moyen est de 6 pardeˊveloppeurparjour,lescou^tsquotidiensrestantendessousde12par développeur par jour, les coûts quotidiens restant en dessous de 12 pour 90 % des utilisateurs. Pour l’utilisation en équipe, Claude Code facture selon la consommation de tokens API. En moyenne, Claude Code coûte environ 100 à 200 $ par développeur par mois avec Sonnet 4.6, bien qu’il y ait une grande variance selon le nombre d’instances que les utilisateurs exécutent et s’ils l’utilisent dans l’automatisation. Cette page explique comment suivre vos coûts, gérer les coûts pour les équipes et réduire l’utilisation des tokens.

​
Suivre vos coûts

​
Utiliser la commande /cost

La commande /cost affiche l’utilisation des tokens API et est destinée aux utilisateurs d’API. Les abonnés Claude Max et Pro ont l’utilisation incluse dans leur abonnement, donc les données /cost ne sont pas pertinentes à des fins de facturation. Les abonnés peuvent utiliser /stats pour afficher les modèles d’utilisation.
La commande /cost fournit des statistiques détaillées sur l’utilisation des tokens pour votre session actuelle : 
Total cost:            $0.55
Total duration (API):  6m 19.7s
Total duration (wall): 6h 33m 10.2s
Total code changes:    0 lines added, 0 lines removed

​
Gérer les coûts pour les équipes

Lors de l’utilisation de l’API Claude, vous pouvez définir des limites de dépenses pour l’espace de travail sur la dépense totale de l’espace de travail Claude Code. Les administrateurs peuvent afficher les rapports de coûts et d’utilisation dans la Console.
Lorsque vous authentifiez pour la première fois Claude Code avec votre compte Claude Console, un espace de travail appelé « Claude Code » est automatiquement créé pour vous. Cet espace de travail fournit un suivi et une gestion centralisés des coûts pour toute l’utilisation de Claude Code dans votre organisation. Vous ne pouvez pas créer de clés API pour cet espace de travail ; il est exclusivement destiné à l’authentification et à l’utilisation de Claude Code.
Sur Bedrock, Vertex et Foundry, Claude Code n’envoie pas de métriques depuis votre cloud. Pour obtenir des métriques de coûts, plusieurs grandes entreprises ont signalé l’utilisation de LiteLLM, qui est un outil open-source qui aide les entreprises à suivre les dépenses par clé. Ce projet n’est pas affilié à Anthropic et n’a pas été audité pour la sécurité.

​
Recommandations de limite de débit

Lors de la configuration de Claude Code pour les équipes, tenez compte de ces recommandations de Token Par Minute (TPM) et Requête Par Minute (RPM) par utilisateur en fonction de la taille de votre organisation :
Taille de l’équipeTPM par utilisateurRPM par utilisateur
1-5 utilisateurs200 000-300 0005-7
5-20 utilisateurs100 000-150 0002,5-3,5
20-50 utilisateurs50 000-75 0001,25-1,75
50-100 utilisateurs25 000-35 0000,62-0,87
100-500 utilisateurs15 000-20 0000,37-0,47
500+ utilisateurs10 000-15 0000,25-0,35
Par exemple, si vous avez 200 utilisateurs, vous pourriez demander 20 000 TPM pour chaque utilisateur, soit 4 millions de TPM au total (200 × 20 000 = 4 millions). Le TPM par utilisateur diminue à mesure que la taille de l’équipe augmente, car moins d’utilisateurs ont tendance à utiliser Claude Code simultanément dans les grandes organisations. Ces limites de débit s’appliquent au niveau de l’organisation, et non par utilisateur individuel, ce qui signifie que les utilisateurs individuels peuvent temporairement consommer plus que leur part calculée lorsque d’autres n’utilisent pas activement le service.
Si vous anticipez des scénarios avec une utilisation concurrente inhabituellement élevée (comme des sessions de formation en direct avec de grands groupes), vous pourriez avoir besoin d’allocations TPM plus élevées par utilisateur.

​
Coûts en tokens des équipes d’agents

Les équipes d’agents lancent plusieurs instances de Claude Code, chacune avec sa propre fenêtre de contexte. L’utilisation des tokens augmente avec le nombre de coéquipiers actifs et la durée d’exécution de chacun. Pour maintenir les coûts des équipes d’agents gérables :
  • Utilisez Sonnet pour les coéquipiers. Il équilibre la capacité et le coût pour les tâches de coordination.
  • Gardez les équipes petites. Chaque coéquipier exécute sa propre fenêtre de contexte, donc l’utilisation des tokens est à peu près proportionnelle à la taille de l’équipe.
  • Gardez les invites de génération concentrées. Les coéquipiers chargent CLAUDE.md, les serveurs MCP et les skills automatiquement, mais tout ce qui se trouve dans l’invite de génération s’ajoute à leur contexte dès le départ.
  • Nettoyez les équipes lorsque le travail est terminé. Les coéquipiers actifs continuent à consommer des tokens même s’ils sont inactifs.
  • Les équipes d’agents sont désactivées par défaut. Définissez CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1 dans votre settings.json ou dans l’environnement pour les activer. Voir activer les équipes d’agents.

​
Réduire l’utilisation des tokens

Les coûts des tokens augmentent avec la taille du contexte : plus Claude traite de contexte, plus vous utilisez de tokens. Claude Code optimise automatiquement les coûts grâce à la mise en cache des invites (qui réduit les coûts pour le contenu répété comme les invites système) et à la compaction automatique (qui résume l’historique des conversations en approchant les limites du contexte). Les stratégies suivantes vous aident à maintenir le contexte petit et à réduire les coûts par message.

​
Gérer le contexte de manière proactive

Utilisez /cost pour vérifier votre utilisation actuelle des tokens, ou configurez votre ligne d’état pour l’afficher en continu.
  • Effacer entre les tâches : Utilisez /clear pour recommencer à zéro lorsque vous passez à un travail non lié. Le contexte obsolète gaspille des tokens à chaque message suivant. Utilisez /rename avant d’effacer pour pouvoir facilement retrouver la session plus tard, puis /resume pour y revenir.
  • Ajouter des instructions de compaction personnalisées : /compact Focus on code samples and API usage indique à Claude ce qu’il faut préserver lors de la résumé.
Vous pouvez également personnaliser le comportement de compaction dans votre CLAUDE.md : 
# Compact instructions

When you are using compact, please focus on test output and code changes

​
Choisir le bon modèle

Sonnet gère bien la plupart des tâches de codage et coûte moins cher qu’Opus. Réservez Opus pour les décisions architecturales complexes ou le raisonnement multi-étapes. Utilisez /model pour changer de modèle en cours de session, ou définissez une valeur par défaut dans /config. Pour les tâches simples de subagent, spécifiez model: haiku dans votre configuration de subagent.

​
Réduire la surcharge des serveurs MCP

Chaque serveur MCP ajoute des définitions d’outils à votre contexte, même lorsqu’il est inactif. Exécutez /context pour voir ce qui consomme de l’espace.
  • Préférez les outils CLI lorsqu’ils sont disponibles : Les outils comme gh, aws, gcloud et sentry-cli sont plus efficaces en contexte que les serveurs MCP car ils n’ajoutent pas de définitions d’outils persistantes. Claude peut exécuter les commandes CLI directement sans la surcharge.
  • Désactiver les serveurs inutilisés : Exécutez /mcp pour voir les serveurs configurés et désactiver ceux que vous n’utilisez pas activement.
  • La recherche d’outils est automatique : Lorsque les descriptions des outils MCP dépassent 10 % de votre fenêtre de contexte, Claude Code les reporte automatiquement et charge les outils à la demande via recherche d’outils. Puisque les outils reportés n’entrent en contexte que lorsqu’ils sont réellement utilisés, un seuil inférieur signifie moins de définitions d’outils inactifs consommant de l’espace. Définissez un seuil inférieur avec ENABLE_TOOL_SEARCH=auto:<N> (par exemple, auto:5 se déclenche lorsque les outils dépassent 5 % de votre fenêtre de contexte).

​
Installer des plugins d’intelligence de code pour les langages typés

Les plugins d’intelligence de code donnent à Claude une navigation de symboles précise au lieu d’une recherche basée sur le texte, réduisant les lectures de fichiers inutiles lors de l’exploration de code inconnu. Un seul appel « aller à la définition » remplace ce qui pourrait autrement être une recherche grep suivie de la lecture de plusieurs fichiers candidats. Les serveurs de langage installés signalent également automatiquement les erreurs de type après les modifications, donc Claude détecte les erreurs sans exécuter un compilateur.

​
Déléguer le traitement aux hooks et aux skills

Les hooks personnalisés peuvent prétraiter les données avant que Claude ne les voie. Au lieu que Claude lise un fichier journal de 10 000 lignes pour trouver les erreurs, un hook peut rechercher ERROR et retourner uniquement les lignes correspondantes, réduisant le contexte de dizaines de milliers de tokens à des centaines. Une skill peut donner à Claude des connaissances de domaine pour qu’il n’ait pas à explorer. Par exemple, une skill « codebase-overview » pourrait décrire l’architecture de votre projet, les répertoires clés et les conventions de nommage. Lorsque Claude invoque la skill, il obtient ce contexte immédiatement au lieu de dépenser des tokens pour lire plusieurs fichiers pour comprendre la structure. Par exemple, ce hook PreToolUse filtre la sortie des tests pour afficher uniquement les échecs :
Ajoutez ceci à votre settings.json pour exécuter le hook avant chaque commande Bash :
{
  "hooks": {
    "PreToolUse": [
      {
        "matcher": "Bash",
        "hooks": [
          {
            "type": "command",
            "command": "~/.claude/hooks/filter-test-output.sh"
          }
        ]
      }
    ]
  }
}

​
Déplacer les instructions de CLAUDE.md vers les skills

Votre fichier CLAUDE.md est chargé en contexte au démarrage de la session. S’il contient des instructions détaillées pour des flux de travail spécifiques (comme les révisions de PR ou les migrations de base de données), ces tokens sont présents même lorsque vous faites un travail non lié. Les skills se chargent à la demande uniquement lorsqu’elles sont invoquées, donc déplacer les instructions spécialisées dans les skills maintient votre contexte de base plus petit. Visez à garder CLAUDE.md en dessous d’environ 500 lignes en incluant uniquement les éléments essentiels.

​
Ajuster la réflexion étendue

La réflexion étendue est activée par défaut avec un budget de 31 999 tokens car elle améliore considérablement les performances sur les tâches complexes de planification et de raisonnement. Cependant, les tokens de réflexion sont facturés comme des tokens de sortie, donc pour les tâches plus simples où un raisonnement approfondi n’est pas nécessaire, vous pouvez réduire les coûts en abaissant le niveau d’effort avec /effort ou dans /model, en désactivant la réflexion dans /config, ou en abaissant le budget (par exemple, MAX_THINKING_TOKENS=8000).

​
Déléguer les opérations détaillées aux subagents

L’exécution de tests, la récupération de documentation ou le traitement de fichiers journaux peuvent consommer un contexte important. Déléguez-les aux subagents pour que la sortie détaillée reste dans le contexte du subagent tandis que seul un résumé revient à votre conversation principale.

​
Gérer les coûts des équipes d’agents

Les équipes d’agents utilisent environ 7 fois plus de tokens que les sessions standard lorsque les coéquipiers s’exécutent en mode plan, car chaque coéquipier maintient sa propre fenêtre de contexte et s’exécute en tant qu’instance Claude distincte. Gardez les tâches d’équipe petites et autonomes pour limiter l’utilisation des tokens par coéquipier. Voir équipes d’agents pour plus de détails.

​
Écrire des invites spécifiques

Les demandes vagues comme « améliorer cette base de code » déclenchent une analyse large. Les demandes spécifiques comme « ajouter la validation des entrées à la fonction de connexion dans auth.ts » permettent à Claude de travailler efficacement avec des lectures de fichiers minimales.

​
Travailler efficacement sur des tâches complexes

Pour un travail plus long ou plus complexe, ces habitudes aident à éviter les tokens gaspillés en prenant la mauvaise direction :
  • Utilisez le mode plan pour les tâches complexes : Appuyez sur Maj+Tab pour entrer en mode plan avant l’implémentation. Claude explore la base de code et propose une approche pour votre approbation, évitant les retouches coûteuses lorsque la direction initiale est mauvaise.
  • Corriger la trajectoire tôt : Si Claude commence à aller dans la mauvaise direction, appuyez sur Échap pour arrêter immédiatement. Utilisez /rewind ou appuyez deux fois sur Échap pour restaurer la conversation et le code à un point de contrôle précédent.
  • Donner des cibles de vérification : Incluez des cas de test, collez des captures d’écran ou définissez la sortie attendue dans votre invite. Lorsque Claude peut vérifier son propre travail, il détecte les problèmes avant que vous ayez besoin de demander des corrections.
  • Tester de manière progressive : Écrivez un fichier, testez-le, puis continuez. Cela détecte les problèmes tôt lorsqu’ils sont bon marché à corriger.

​
Utilisation des tokens en arrière-plan

Claude Code utilise des tokens pour certaines fonctionnalités en arrière-plan même lorsqu’il est inactif :
  • Résumé des conversations : Les tâches en arrière-plan qui résument les conversations précédentes pour la fonctionnalité claude --resume
  • Traitement des commandes : Certaines commandes comme /cost peuvent générer des requêtes pour vérifier l’état
Ces processus en arrière-plan consomment une petite quantité de tokens (généralement moins de 0,04 $ par session) même sans interaction active.

​
Comprendre les changements dans le comportement de Claude Code

Claude Code reçoit régulièrement des mises à jour qui peuvent modifier le fonctionnement des fonctionnalités, y compris la génération de rapports de coûts. Exécutez claude --version pour vérifier votre version actuelle. Pour des questions de facturation spécifiques, contactez le support Anthropic via votre compte Console. Pour les déploiements en équipe, commencez par un petit groupe pilote pour établir les modèles d’utilisation avant un déploiement plus large.