Observabilité de Claude Code : suivez les jetons, les coûts et l'utilisation par développeur
.webp)
Conçu pour la vitesse : latence d'environ 10 ms, même en cas de charge
Une méthode incroyablement rapide pour créer, suivre et déployer vos modèles !
- Gère plus de 350 RPS sur un seul processeur virtuel, aucun réglage n'est nécessaire
- Prêt pour la production avec un support complet pour les entreprises
Ce que signifie l'observabilité pour un agent de codage
L'observabilité traditionnelle cherche à savoir si un service est fonctionnel. Un agent de codage est toujours « en ligne » — il s'exécute sur un ordinateur portable et communique avec un fournisseur de modèles. La question primordiale est d'ordre économique et comportemental : quel développeur a dépensé quoi, sur quel modèle, pour faire quoi, et pourquoi une session a-t-elle coûté dix fois plus cher qu'une autre. Il s'agit de comptabilité de jetons et non de vérification d'état (health check), et c'est le prisme utilisé dans ce guide. Pour le côté facturation de cette même pièce, consultez Explication des tarifs de Claude Code.
Les enjeux sont concrets. Un seul développeur actif génère environ 13 $ par jour d'activité et entre 150 et 250 $ par mois, environ 90 % des utilisateurs restant sous la barre des 30 $/jour — les exceptions ont donc une importance considérable. Sans une vue par développeur, vous ne pouvez pas identifier les trois personnes au sein d'une équipe de trente qui génèrent la majeure partie de la facture, ni savoir si elles accomplissent des tâches complexes ou si elles laissent Opus activé par défaut. L'observabilité transforme un total surprenant en une liste de causes corrigeables.
Ce qu'il faut réellement suivre
Sept signaux regroupent la quasi-totalité de la valeur. Tout le reste en découle.
Deux d'entre eux — la répartition des modèles et le ratio de cache — constituent également vos plus grands leviers d'optimisation des coûts, c'est pourquoi leur observation est rapidement rentabilisée. La partie routage est traitée dans Opus vs Sonnet vs Haiku : guide de routage coût/capacité, et la partie mise en cache dans Mise en cache des prompts Claude : le calcul réel des coûts.
Le jeton n'est pas un chiffre unique — il est quadruple
La métrique « Jetons utilisés » est un agrégat inutile car les quatre catégories sont tarifées de manière très différente. Sur Opus 5.5, l'écart est frappant : la sortie coûte cinq fois le prix d'une entrée brute, l'écriture dans le cache coûte plus cher que l'entrée brute, et la lecture dans le cache ne coûte qu'une fraction de celle-ci. Les fusionner masque précisément les informations dont vous avez besoin pour réduire la facture.
Un ratio élevé de lecture du cache est le signal recherché : un contexte à longue durée de vie réutilisé au lieu d'être facturé au prix fort d'une nouvelle entrée. Sur un abonnement, le cache de prompt dure environ une heure ; sur l'API ou chez un fournisseur cloud, il dure environ cinq minutes, le ratio attendu varie donc selon la configuration. Si les lectures de cache s'effondrent et que les entrées brutes augmentent, quelque chose a interrompu le cache — et vous ne le remarquerez que si les quatre chiffres sont suivis séparément.
Les options natives, et leurs limites
Claude Code intègre une réelle visibilité — mais elle est limitée à l'échelle individuelle.
/usagedans le CLI affiche les jetons de la session en cours et le coût estimé, calculé localement au tarif catalogue. C'est précis pour un développeur sur une machine, et cela se réinitialise lorsque la session est effacée. Cela ne permet pas d'agréger les données d'une équipe./insightsrésume les sessions récentes sur cette machine — utile pour un développeur qui analyse ses propres habitudes, mais ce n'est toujours pas une vue globale du parc.- L'analyse des abonnements (Teams et Enterprise) fournit un rapport de dépenses au niveau de l'organisation par utilisateur et par modèle, mis à jour quotidiennement — idéal pour la finance, mais il ne s'agit pas d'une vue en direct, requête par requête.
- L'utilisation via les fournisseurs cloud est invisible sur les tableaux de bord d'Anthropic. Exécutez Claude Code sur Amazon Bedrock, Google Vertex ou Microsoft Foundry et l'analyse native ne la verra simplement pas, car les jetons sont facturés sur votre compte cloud.
Le constat est constant : les outils natifs répondent à la question « combien viens-je de dépenser », et non à « que fait l'ensemble du parc en ce moment ». Pour cela, vous devez faire sortir les métriques de la machine.
OpenTelemetry : extraire les métriques de la machine
La méthode native pour combler ce manque est OpenTelemetry. Claude Code peut exporter les métriques de jetons et de coûts par utilisateur via OTLP vers votre propre stack d'observabilité, et cela fonctionne sur n'importe quelle configuration — abonnement, API Console ou n'importe quel fournisseur cloud. Cela en fait la seule option native offrant des données par développeur en quasi-temps réel, quel que soit le mode d'authentification des développeurs.
Activation
L'exportation est désactivée par défaut et dépend entièrement de variables d'environnement, définies dans le profil du terminal (shell profile) ou via un fichier de paramètres géré et déployé sur chaque machine. Une configuration minimale pour les métriques et les journaux :
Les métriques sont envoyées selon un intervalle régulier — par défaut 60 000 ms pour les métriques, 5 000 ms pour les journaux — ainsi, le « quasi-temps réel » s'exprime à la minute près et non par requête. Les traces constituent un signal bêta distinct, soumis à la variable CLAUDE_CODE_ENHANCED_TELEMETRY_BETA=1 et OTEL_TRACES_EXPORTER=otlp ; ne les activez qu'avec un collecteur prêt à recevoir les spans.
Ce que contient chaque signal
OpenTelemetry émet trois types de signaux : des métriques (les compteurs sur lesquels vous construisez des tableaux de bord), des journaux (des événements distincts) et des traces (des spans en version bêta pour une interaction unique). Les métriques sont le cœur du suivi des coûts :
L'attribution par utilisateur s'appuie sur les attributs user.email et account-identifier, inclus par défaut. Notez que session.id augmente considérablement la cardinalité — une série temporelle par session — si votre backend facture à la série, désactivez-le pour les tableaux de bord globaux et attribuez plutôt par utilisateur. Les journaux d'événements (claude_code.user_prompt, claude_code.tool_result, claude_code.api_request) ajoutent des détails par action que les métriques ne peuvent pas fournir, et peuvent optionnellement inclure le contenu du prompt ou de l'outil — une décision liée à la confidentialité à trancher avant l'activation.
Le compromis est d'ordre opérationnel : vous devez instrumenter chaque machine, maintenir les variables lors des renouvellements d'ordinateurs portables et des nouvelles embauches, et gérer vous-même le collecteur et les tableaux de bord. Le flux de métriques fonctionne bien, mais un flux de métriques n'est pas un journal d'audit au niveau de la requête et ne permet pas d'appliquer un budget — il ne fait que le rapporter. Pour une analyse plus approfondie de la comptabilité des jetons, consultez Observabilité pour Claude en production : comptabilité des jetons et traçage.
Comparatif : Native vs OpenTelemetry vs Passerelle IA
OpenTelemetry et une passerelle ne s'excluent pas mutuellement — une bonne passerelle est conforme à OpenTelemetry et peut alimenter la même stack. La différence est que la passerelle se situe également sur le parcours de la requête, ce qui lui permet de tracer et de plafonner, et pas seulement de compter. OTel est la solution adaptée lorsque vous gérez l'intégralité du parc, que vous avez la certitude que chaque machine reste instrumentée et que vous avez seulement besoin de produire des rapports. Une passerelle est la solution idéale lorsque les machines évoluent, qu'une partie du trafic passe par un fournisseur cloud, et que la visualisation doit s'accompagner d'un moyen d'action.
Observabilité avec la passerelle IA TrueFoundry
Routez Claude Code via la Passerelle IA TrueFoundry et chaque exécution passera par un point unique que vous contrôlez. L'observabilité cesse d'être une option activée individuellement par chaque développeur sur son poste pour devenir un standard natif :
- Traces de requêtes — chaque requête enregistre l'utilisateur identifié, le modèle servi, le nombre de jetons et la latence, ce qui permet de répondre a posteriori à la question « qui a envoyé cela et combien cela a-t-il coûté ».
- Tableaux de bord de métriques qui agrègent les données du parc par utilisateur, équipe et modèle — la vue par développeur détaillée dans le guide sur le suivi des coûts pour Claude Code.
- Une vue unique sur l'ensemble des outils — Claude Code, Cursor et Codex sont centralisés au même endroit au lieu d'être dispersés, comme expliqué dans centralisation du contrôle des coûts pour les IDE de codage IA.
- Export conforme à OpenTelemetry avec un surcoût de latence d'environ 3 à 4 ms seulement, afin de transmettre ces mêmes chiffres vers Grafana, Datadog ou Prometheus si vous les utilisez déjà.
Ce qu'enregistre une trace de requête unique
Une passerelle répond à des questions auxquelles les métriques OpenTelemetry ne peuvent pas répondre car elle enregistre chaque requête comme un événement distinct, et non comme un compteur agrégé par minute. Une trace capture l'identité résolue, le modèle servi, la répartition quadruplement ventilée des jetons, le coût selon votre tarif négocié, la latence de bout en bout en millisecondes, le statut et la décision de routage. Chaque ligne étant recherchable et conservée, vous pouvez analyser un pic de consommation : filtrez sur un développeur et une heure précise, puis consultez les appels réels qui l'ont provoqué — le journal d'audit complet qu'un flux de métriques a tendance à consolider.
Les alertes à configurer et les tableaux de bord à construire
Collecter des signaux ne sert à rien si personne ne les consulte avant la réception de la facture. L'intérêt d'extraire les métriques de la machine est de pouvoir agir à temps — grâce à un ensemble restreint d'alertes et quelques tableaux de bord ciblés, plutôt qu'un mur de graphiques. Des alertes efficaces doivent correspondre à une cause précise et corrigeable :
- Dépense quotidienne par développeur franchissant un seuil — par exemple, un dépassement prolongé des ~30 $/jour qui couvrent déjà environ 90 % des utilisateurs. Cela permet de détecter une anomalie le jour même où elle survient, et non un mois plus tard.
- Part de jetons Opus dépassant un plafond — le signal le plus clair d'une dérive du modèle par défaut, lorsque des modifications de routine s'exécutent silencieusement sur le modèle le plus cher.
- Chute du ratio de lecture du cache — une baisse soudaine signifie que la mise en cache a régressé et que les nouvelles entrées sont re-facturées au prix fort.
- Latence p95/p99 en ms dépassant une limite — révèle les dégradations de service du fournisseur et les problèmes de délai d'attente avant que les développeurs ne signalent que « Claude est lent ».
- Volume de requêtes en dehors des heures de bureau — les tâches planifiées et les traitements en arrière-plan qui renvoient régulièrement un contexte volumineux apparaissent sous forme de dépenses sans qu'aucun humain ne soit devant son écran.
Les tableaux de bord essentiels sont tout aussi peu nombreux : le coût du parc par développeur (top N), le coût par modèle pour visualiser d'un coup d'œil la répartition Opus / Sonnet / Haiku, une vue empilée des quatre types de jetons pour surveiller le ratio de cache, le coût par dépôt ou par équipe pour la refacturation interne, la distribution de la latence en millisecondes et le taux d'acceptation des appels d'outils. Sur une passerelle, ces éléments sont préconfigurés et alimentés automatiquement ; avec OpenTelemetry, vous les assemblez dans Grafana ou votre backend à partir des métriques mentionnées ci-dessus.
Exemple concret
Une équipe plateforme compte trente développeurs utilisant Claude Code, certains via un abonnement et d'autres sur Bedrock. La facture mensuelle augmente et personne ne sait pourquoi. Ils redirigent l'ensemble des installations vers la passerelle et consultent le tableau de bord le lendemain : trois développeurs représentent 60 % de la consommation de jetons, tous les trois parce qu'Opus est configuré comme leur modèle par défaut, et une tâche planifiée renvoie un contexte volumineux toutes les heures. Ils définissent une règle de routage qui dirige les modifications de routine vers Sonnet, corrigent la tâche planifiée, et la courbe de dépenses s'inverse — sans demander à quiconque d'exécuter une commande sur son ordinateur portable. L'observabilité n'a pas modifié directement les comportements ; c'est la visibilité offerte qui a permis d'agir.
La limite objective : une passerelle affiche les dépenses et vous permet de les plafonner. Elle ne réécrit pas les prompts — elle rend le gaspillage impossible à ignorer et vous donne le levier politique nécessaire pour intervenir. L'aspect contrôle et application des règles est abordé dans Gouvernance de Claude Code avec une passerelle IA.
Pièges à connaître
- Le montant affiché par
/usageest une estimation calculée localement au tarif catalogue. Si votre organisation bénéficie de tarifs négociés, ce montant ne correspondra pas à la facture, à moins qu'un administrateur n'applique un ajustement de tarif. /usageest spécifique à chaque machine. Un développeur qui code sur un ordinateur portable et un poste fixe verra deux vues partielles ; seul un suivi externalisé (OTel ou une passerelle) permet de les consolider.- Les tableaux de bord des fournisseurs cloud fragmentent les données. Sur Bedrock, Vertex ou Foundry, vos dépenses apparaissent dans la console de facturation du cloud, et l'attribution par utilisateur nécessite l'ajout d'OpenTelemetry ou d'une passerelle.
- Les sessions inactives génèrent toujours des requêtes. Les tâches planifiées et les traitements en arrière-plan renvoient l'intégralité du contexte selon leur fréquence définie, ainsi un développeur inactif peut continuer à cumuler des coûts — ce que vous ne verrez que dans une trace au niveau de la requête.
- Compter ne signifie pas plafonner. OpenTelemetry vous informe qu'un budget a été dépassé après coup ; seul un composant situé sur le parcours de la requête peut bloquer celle-ci avant qu'elle ne génère une dépense.
session.idest un piège à cardinalité. Activé sur les tableaux de bord globaux, il crée une série temporelle de métriques par session, ce qui peut faire exploser les coûts sur un backend d'observabilité facturé à l'usage — privilégiez une attribution par utilisateur.- Les équipes d'agents multiplient les jetons. Les exécutions multi-agents consomment environ 7 fois plus de jetons qu'une session unique, l'adoption de ces usages peut donc faire grimper les dépenses sans qu'aucun utilisateur n'ait changé ses habitudes.
Lectures complémentaires
- Observabilité pour Claude en production : comptabilité des jetons et traçage — la comptabilité des jetons en détail
- Suivi des coûts de Claude Code avec la passerelle IA TrueFoundry — l'attribution par développeur en pratique
- Centraliser le contrôle des coûts pour les IDE de codage IA — une vue unique pour Claude Code, Cursor et Codex
- Explication des tarifs de Claude Code — ce que coûtent réellement les jetons que vous observez
- Gouvernance de Claude Code avec une passerelle IA — transformer l'observabilité en contrôle actif
Conclusion
L'observabilité de Claude Code est essentiellement une observabilité des coûts avec un niveau de détail élevé : des jetons ventilés en quatre catégories, attribués à un développeur, un modèle et une tâche. Les outils natifs répondent à ce besoin pour une personne sur une machine ; OpenTelemetry y répond pour l'ensemble du parc si vous instrumentez chaque poste ; et une passerelle y répond par défaut pour tout le parc, puisque chaque requête passe systématiquement par elle.
Choisissez le niveau d'intégration qui correspond à la visibilité dont vous avez besoin. Si votre objectif est d'avoir une vision « par développeur, sur l'ensemble des modèles et des fournisseurs, avec la capacité de contrôler ce que vous observez », c'est sur le parcours de la requête qu'il faut vous positionner.
TrueFoundry AI Gateway offre une latence d'environ 3 à 4 ms, gère plus de 350 RPS sur 1 processeur virtuel, évolue horizontalement facilement et est prête pour la production, tandis que LiteLM souffre d'une latence élevée, peine à dépasser un RPS modéré, ne dispose pas d'une mise à l'échelle intégrée et convient parfaitement aux charges de travail légères ou aux prototypes.













.webp)








