Blank white background with no objects or features visible.

Bonjour, zone EMEA ! TrueFoundry étend sa présence en Europe, au Moyen-Orient et en Afrique. En savoir plus. →

Observabilité de Claude Code : suivez les jetons, les coûts et l'utilisation par développeur

Published: novembre 20, 2026

En résumé :

L'observabilité d'un agent de codage ne concerne pas la disponibilité (uptime). Elle consiste à répondre à une question par développeur : combien cela a-t-il coûté, et pourquoi.

  • L'unité d'observabilité est le jeton, divisé en quatre catégories — entrée, sortie, lecture du cache et écriture dans le cache — car votre facture dépend entièrement de cette répartition.
  • La vue native /usage est locale à une seule machine et à une seule session ; elle peut indiquer à un développeur le coût de sa dernière session, mais ne peut pas vous donner un chiffre global pour l'ensemble de vos équipes.
  • L'export OpenTelemetry est la méthode native pour extraire les métriques par utilisateur de chaque machine vers votre propre stack — cela fonctionne sur toutes les configurations, y compris chez les fournisseurs cloud.
  • L'utilisation chez les fournisseurs cloud ne parvient jamais aux tableaux de bord d'Anthropic. Sur Amazon Bedrock, Google Vertex ou Microsoft Foundry, vous n'obtenez d'attribution que via OpenTelemetry ou une passerelle.
  • Une passerelle IA rend le suivi inévitable : chaque requête passe par un point unique, de sorte que les traces par développeur, les dépenses et l'utilisation des modèles existent, que chaque ordinateur portable soit instrumenté ou non.

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.

SignalPourquoi c'est importantD'où cela provient
Jetons d'entrée / sortieLa base de chaque calcul de coût ; la sortie est bien plus chère que l'entréeChaque réponse d'API
Jetons de lecture / écriture du cacheLes lectures en cache sont ~10x moins chères que l'entrée brute — cette répartition explique votre factureLes champs de cache sur chaque réponse
Coût par développeurIdentifie les deux ou trois anomalies qui génèrent la majorité des dépensesJetons valorisés par modèle, attribués à un utilisateur
Coût par modèleRévèle le gaspillage lié à Opus laissé par défautLe modèle servi à chaque requête
Coût par dépôt ou équipeRefacturation interne, budgets par équipe et courbes de tendanceLes métadonnées de la requête ou la clé de routage
Latence (ms)Appels lents, dégradations du fournisseur et schémas de délai d'attente (timeout)Le temps d'exécution (span) de la requête
Appels d'outils et décisions d'éditionProportion du travail de l'agent acceptée par rapport à celle rejetéeLes événements d'utilisation d'outils dans chaque session

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.

Type de jetonCe que c'estCoût relatif (Opus 5.5)Ce qu'indique une valeur élevée
EntréePrompt brut envoyé au modèle4 $ / M (référence)Contexte volumineux ou répété renvoyé à nouveau
SortieJetons générés par le modèle20 $ / M (~5x l'entrée)Générations verbeuses ou tâches surdimensionnées
Écriture cacheContexte écrit dans le cache5 $ / M (supérieur à l'entrée)Normal au premier tour ; gaspillage si renouvelé trop souvent
Lecture cacheContexte servi depuis le cache0,20 $ / M (~10x moins cher)Optimal — le cache fonctionne comme prévu

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.

  • /usage dans 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.
  • /insights ré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 :

MétriqueCe qu'elle contientAttributs clés
claude_code.token.usageJetons consommés, ventilés par catégorietype (input / output / cacheRead / cacheCreation), model
claude_code.cost.usageDépenses estimées au tarif catalogue (USD)model, user.email
claude_code.session.countSessions démarréessession.id, user.email
claude_code.lines_of_code.countLignes de code modifiées par l'agenttype (added / removed)
claude_code.code_edit_tool.decisionSi une modification a été conservéetool_name, decision (accept / reject)
claude_code.active_time.totalSecondes d'utilisation activetype (user / cli)
claude_code.commit.count / pull_request.countActivité Git effectuée via l'agentattributs standards

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

Fonctionnalité/usage (native)Export OpenTelemetryPasserelle IA
PortéeUne machine, une sessionPar développeur, à l'échelle du parcPar développeur, à l'échelle du parc
Attribution par utilisateurNonOuiOui
Fonctionne sur les fournisseurs cloudLocal uniquementOuiOui
Traces au niveau de la requêteNonPartiel (bêta)Oui
Latence par requête (ms)NonPartielOui
Limites de dépenses / ApplicationNonNonOui
Multi-outils (Cursor, Codex)NonPar outil uniquementOui, une vue unique
Coût de configurationIntégréInstrumenter chaque machinePointer le client vers un endpoint unique

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à.
Vous souhaitez suivre les dépenses Claude Code par développeur sans instrumenter chaque ordinateur portable ?

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.

Champ de la traceCe à quoi il répond
Utilisateur / clé résolu(e)Qui a envoyé cette requête
Modèle serviEst-ce qu'Opus a été utilisé alors que Sonnet suffisait
Répartition des jetons (entrée / sortie / cache)D'où provient le coût de cet appel
Coût au tarif négociéLa dépense réelle, et non une estimation au tarif catalogue
Latence (ms)Cet appel était-il lent, et le fournisseur a-t-il subi une dégradation
Décision de routageQuelle règle a sélectionné ce modèle

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 /usage est 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.
  • /usage est 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.id est 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

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.

Visualisez chaque requête, jeton et dollar dépensé sur Claude Code au même endroit.

Try now.

One gateway for all your models, MCP servers, and agents. No credit card needed.

INSCRIVEZ-VOUS
Table des matières

Gouvernez, déployez et suivez l'IA dans votre propre infrastructure

Réservez un séjour de 30 minutes avec notre Expert en IA

Réservez une démo

Le moyen le plus rapide de créer, de gérer et de faire évoluer votre IA

Démo du livre
Summarize with
ChatGPT logo by OpenAI
Perplexity AI logo
Blurry red snowflake on white background, symmetrical frosty design with soft edges and abstract shape.

Découvrez-en plus

Aucun article n'a été trouvé.
novembre 20, 2026
|
5 min de lecture

Grok 4.3 on Amazon Bedrock: We Routed Four Frontier Models Through One Gateway and Measured the Cost

Outils LLM
comparaison
novembre 20, 2026
|
5 min de lecture

Alternatives au bifrost : les meilleurs outils que vous pouvez envisager en 2026

Aucun article n'a été trouvé.
novembre 20, 2026
|
5 min de lecture

GPT-6.1 Terra : API, benchmarks, tarification et mode d'emploi

Aucun article n'a été trouvé.
novembre 20, 2026
|
5 min de lecture

GPT-5.1 vs GPT-5 : 9 améliorations majeures à connaître

LLM et GenAI
Aucun article n'a été trouvé.
Faites un rapide tour d'horizon des produits
Commencer la visite guidée du produit
Visite guidée du produit