Claude Code uitgaven monitoren: welke tool kiest u?

Wat een Claude Code-uitgavenmonitor daadwerkelijk leest

Elke Claude Code-uitgavenmonitor leest een van de drie gegevensbronnen, en de bron bepaalt welke vragen deze kan beantwoorden. Een log-parser leest de sessietranscriptbestanden op uw eigen schijf. Een dashboard leest de gebruiksgegevens die Anthropic bijhoudt voor uw account of uw organisatie. Een metrics-backend leest de OpenTelemetry (OTel)-stroom die Claude Code uitzendt wanneer u deze inschakelt. Alle drie kunnen tegelijkertijd correct zijn en toch van elkaar verschillen, omdat ze verschillende zaken tellen.

Deze handleiding legt tokens niet opnieuw uit. hoe Claude Code tokengebruik telt behandelt input, output, cache-schrijfacties en cache-leesacties, en een dashboard is pas zinvol als dat deel duidelijk is. De vraag hier is specifieker: wat kan elk type tool zien en wat kan deze nooit zien.

Waarom er op één dag drie Claude Code-uitgaventrackers verschenen

Er werden op dezelfde dag drie afzonderlijke Claude Code-uitgaventrackers gepubliceerd. Dit waren geen drie versies van hetzelfde hulpmiddel, en dat is juist het nuttige aspect. De eerste analyseerde de lokale sessiebestanden. De tweede fungeerde als wrapper voor de schermen met accountgebruik. De derde was een gehoste tracing-backend die u zelf uitvoert.

Ze verschenen tegelijkertijd omdat de kosten van een agentsessie niet langer inzichtelijk waren. Een chat kost ongeveer wat u op het scherm ziet. Een agent leest twintig bestanden, voert de testsuite uit en verstuurt bij elke stap het volledige gesprek opnieuw; de rekening wordt dus bepaald door context die u nooit zelf hebt getypt. Bij een abonnement is er helemaal geen dollarbedrag zichtbaar, enkel een verbruiksbalk die op sommige dagen sneller leegloopt dan op andere. Elk van de drie vormen vult een ander deel van die leemte op.

Vorm 1: een lokale log-parser vertelt u wat vandaag heeft gekost

Claude Code slaat elk gesprek op als JSON Lines (JSONL) op ~/.claude/projects/<project>/<session-id>.jsonl, waarbij <project> uw werkmap-pad is met niet-alfanumerieke tekens vervangen door -. Elke beurt van de assistent in dat bestand bevat de tokentellingen voor het verzoek. Een log-parser telt deze bij elkaar op en berekent de kosten.

ccusage is de optie die de meeste mensen gebruiken. Installatie is niet nodig:

npx ccusage@latest daily
npx ccusage@latest daily --breakdown
npx ccusage@latest blocks
npx ccusage@latest session --json

daily geeft totalen per datum. --breakdown splitst elke rij per model; zo ontdekt u dat één middag met Opus het grootste deel van de week beslaat. blocks groepeert op het tijdvenster van vijf uur waarop een abonnement wordt gereset. session geeft totalen per gesprek en --instances groepeert per project, zodat u kunt zien welke repository duur is. Voeg --since en --until toe om het bereik te beperken en voer npx ccusage@latest daily --help uit voor de datumnotatie die uw versie verwacht. Sinds augustus 2026 leest het ook andere agent-CLI's, waaronder Codex en OpenCode; dit is relevant als u deze met elkaar vergelijkt.

De prijsstelling is afkomstig uit een prijstabel voor modellen en de tool kent drie kostenmodi. --mode auto gebruikt de costUSD-waarde die Claude Code in het bestand heeft geschreven wanneer deze aanwezig is, en berekent de kosten op basis van tokentellingen wanneer deze ontbreekt. --mode calculate berekent altijd op basis van tokens en negeert eventuele geregistreerde kosten. --mode display toont alleen geregistreerde kosten en print $0.00 voor rijen die deze niet hebben. Als een totaal onjuist lijkt, voer dan hetzelfde rapport uit onder calculate en daarna onder display. Een groot verschil tussen beide betekent dat de meeste vermeldingen geen geregistreerde kosten bevatten, waardoor alles wat u leest een schatting is.

Dezelfde gegevens kunnen uw prompt voeden. ccusage statusline print een compacte regel voor de statusbalk van Claude Code, gekoppeld aan ~/.claude/settings.json zoals elk ander statusregelcommando. Zie een Claude Code statusregel bouwen voor het instellingenblok en de velden die het ontvangt.

Wat een log-parser niet kan zien, is alles wat niet op deze machine is gebeurd. Een tweede laptop, een sessie op claude.ai, het werk van een teamgenoot: die transcripten staan op die schijven. Oude gegevens ontbreken ook, omdat transcripten standaard na 30 dagen worden opgeschoond onder de cleanupPeriodDays-instelling; het vorige kwartaal is dus verdwenen, tenzij u het hebt gearchiveerd.

Er is nog een risico, en dat is structureel. De documentatie van Anthropic stelt dat het invoerformaat intern is voor Claude Code en verandert tussen versies. Scripts die deze bestanden direct parsen, kunnen dus bij elke release defect raken. Dat geldt voor elke tool van dit type. Het is ook de reden waarom een zelfgeschreven jq-oneliner over de JSONL een slechter idee is dan het lijkt: de onderhouden parsers volgen de formaatwijzigingen voor u, terwijl uw oneliner een zelfverzekerd foutief getal zal rapporteren op de dag dat een veld wordt hernoemd.

Tot slot behoeft het dollarbedrag een kanttekening bij een abonnement. U wordt bij Pro of Max niet per token gefactureerd, dus het getal is wat uw tokens zouden hebben gekost tegen de standaard API-tarieven. Het meet hoe intensief uw gebruik is. Het is niet uw factuur. Als de werkelijke vraag is welk abonnement u moet kiezen, dan is die vergelijking een aparte oefening: zie API-facturatie versus een Claude-abonnement.

Vorm 2: de ingebouwde gebruiksstatistieken tonen welk model uw budget heeft verbruikt

Claude Code bevat eigen rapportagefunctionaliteit die door de meeste gebruikers onopgemerkt blijft. Voer /usage uit tijdens een sessie. Het blok 'Session' bovenaan toont het aantal tokens per model en een geldbedrag voor de huidige sessie, lokaal berekend op basis van tokenaantallen tegen de standaardtarieven. Dit bedrag houdt geen rekening met kortingen of promotionele prijzen en kan daarom afwijken van uw factuur. De totalen worden gereset wanneer /clear een nieuw gesprek start.

Bij een Pro-, Max-, Team- of Enterprise-abonnement toont hetzelfde scherm hoeveel van uw abonnementslimiet u heeft verbruikt. Het wijst recent gebruik toe aan skills, subagents, plugins en individuele MCP-servers als percentage van het totaal. Het markeert gedrag dat verantwoordelijk is voor 10% of meer van het recente gebruik, zoals een lange context of cache-misses. Druk op d of w om te wisselen tussen de afgelopen 24 uur en de afgelopen 7 dagen. Deze cijfers zijn een benadering en worden berekend op basis van de lokale sessiegeschiedenis op deze machine; een tweede apparaat wordt dus niet meegeteld. Wanneer die balk leeg is in plaats van slechts laag, geeft het scherm aan dat het venster is gesloten, maar niet hoe u verder kunt werken. Wat u moet doen zodra u de limiet heeft bereikt is een afzonderlijke beslissing over het model, de context en het abonnement.

Bij meer dan één ontwikkelaar verschuiven de cijfers naar het accountniveau. Een API-organisatie krijgt toegang tot de gebruiks-pagina in de Console: een Claude Code-dashboard met uitgaven en geaccepteerde regels per lid, en een Claude Code Analytics API die dezelfde dagelijkse statistieken per gebruiker retourneert met een admin-sleutel. Team- en Enterprise-abonnementen krijgen een uitgavenrapport in de admin-console met CSV-export, dat dagelijks wordt bijgewerkt. Enterprise voegt hier een analytics API aan toe. Welke van deze u ziet, hangt af van de manier waarop elke ontwikkelaar is ingelogd; een gemengde organisatie moet dus twee rapporten lezen en deze handmatig bij elkaar optellen.

Voor het bepalen van een budget: het gepubliceerde cijfer in de kostendocumentatie van Anthropic per augustus 2026 is een gemiddelde van ongeveer $13 per ontwikkelaar per actieve dag en $150 tot $250 per ontwikkelaar per maand, waarbij 90% van de gebruikers onder de $30 per actieve dag blijft. Beschouw dit als een gepubliceerde benchmark uit enterprise-implementaties, niet als een voorspelling voor uw team. Voer een pilotgroep uit en meet de resultaten voordat u extrapoleert.

Wat de dashboards niet kunnen zien, is alles onder het niveau van de dag en de persoon. Ze vertellen u dat Opus het grootste deel van dinsdag in beslag nam. Ze vertellen u niet welke prompt, welke repository of welke CI-taak dit veroorzaakte. Ze vertonen ook vertraging, omdat de organisatierapporten dagelijks worden bijgewerkt. Het zijn daarom instrumenten voor evaluatie achteraf, in plaats van een manier om een op hol geslagen agent vanmiddag nog te stoppen. Het stoppen van een op hol geslagen agent vereist limieten, geen rapporten; dit is het onderwerp van het beperken van agentkosten op een VPS.

Vorm 3: uw eigen OpenTelemetry-stack vertelt u welke prompt is teruggelopen

Claude Code zendt OpenTelemetry-metrieken en -events uit zodra u één omgevingsvariabele instelt. Dit is de enige optie die per gebruiker token- en kostengegevens in bijna real-time naar een systeem streamt dat u zelf beheert. De metrieken bevatten claude_code.cost.usage in USD, claude_code.token.usage in tokens, claude_code.session.count en claude_code.active_time.total.

De token-metriek is interessant vanwege de bijbehorende attributen. Elk datapunt bevat type, wat input, output, cacheRead of cacheCreation is, plus model en query_source, wat main, subagent of auxiliary is. Het bevat ook agent.name, skill.name, mcp_server.name en mcp_tool.name. Dat is voldoende om vragen te beantwoorden die geen enkel dashboard kan bereiken: welk deel van de rekening bestaat uit subagents in plaats van uw eigen interacties, of een bepaalde MCP-server uw input-tokens heeft verdubbeld, of dat cache-reads zijn ingestort nadat iemand CLAUDE.md heeft bewerkt. Cache-gedrag is meestal waar de verrassingen zich verbergen, en wanneer prompt caching zichzelf terugbetaalt legt uit waar u naar kijkt.

Eén correctie is hier op zijn plaats, omdat dit in elke discussie hierover naar voren komt. Langfuse is een goede self-hosted tracing-backend, en het draaien ervan op een VPS wordt behandeld in self-hosting van Langfuse voor agent-tracing. Het OTLP-eindpunt accepteert alleen traces. Claude Code exporteert metrieken en log-events, geen spans. Het wijzen van OTEL_EXPORTER_OTLP_ENDPOINT naar Langfuse laat het project daarom leeg en geeft u geen foutmelding die nuttig is om te lezen. Langfuse is de juiste tool voor agents die u zelf op de API bouwt, waarbij uw eigen code elke span aanmaakt met de bijbehorende prompt, het model en de kosten. Voor de Claude Code CLI is een metrieken-opslag de juiste keuze.

Claude Code uitgaven bijhouden op uw eigen VPS

Twee services volstaan: een collector om de statistieken te ontvangen en Prometheus om ze op te slaan. Houd beide buiten het publieke internet, aangezien een open OTLP-poort schrijfacties accepteert van iedereen die deze vindt. Schrijf /opt/ccmetrics/compose.yaml:

services:
  collector:
    image: otel/opentelemetry-collector-contrib:latest
    command: ["--config=/etc/otel/config.yaml"]
    volumes:
      - ./collector.yaml:/etc/otel/config.yaml:ro
    ports:
      - "10.8.0.1:4318:4318"
    restart: unless-stopped
  prometheus:
    image: prom/prometheus:latest
    volumes:
      - ./prometheus.yml:/etc/prometheus/prometheus.yml:ro
      - prom-data:/prometheus
    ports:
      - "127.0.0.1:9090:9090"
    restart: unless-stopped

volumes:
  prom-data:

10.8.0.1 is het adres van de server binnen een WireGuard-tunnel, waardoor de collector alleen bereikbaar is vanaf uw eigen machines. Het adres voor de poort is hier essentieel, omdat gepubliceerde Docker-poorten niet worden gefilterd door ufw: zie waarom Docker gepubliceerde poorten ufw omzeilen. Het opzetten van de tunnel zelf staat in een WireGuard VPN op uw eigen VPS.

/opt/ccmetrics/collector.yaml:

receivers:
  otlp:
    protocols:
      http:
        endpoint: 0.0.0.0:4318

processors:
  batch:

exporters:
  prometheus:
    endpoint: 0.0.0.0:8889

service:
  pipelines:
    metrics:
      receivers: [otlp]
      processors: [batch]
      exporters: [prometheus]

/opt/ccmetrics/prometheus.yml. Poort 8889 wordt niet gepubliceerd naar de host, omdat Prometheus de collector bereikt via het Compose-netwerk op servicenaam:

global:
  scrape_interval: 30s

scrape_configs:
  - job_name: claude-code
    static_configs:
      - targets: ["collector:8889"]

cd /opt/ccmetrics
docker compose up -d
docker compose logs collector

Het logboek van de collector moet eindigen met Everything is ready. Begin running and processing data.. Een logboek dat stopt bij een configuratiefout betekent dat de YAML niet kon worden geparseerd, waarna de container in een lus blijft herstarten.

Wijs Claude Code nu naar deze omgeving. Voeg op elke machine die Claude Code draait het volgende toe aan ~/.claude/settings.json:

{
  "env": {
    "CLAUDE_CODE_ENABLE_TELEMETRY": "1",
    "OTEL_METRICS_EXPORTER": "otlp",
    "OTEL_LOGS_EXPORTER": "none",
    "OTEL_EXPORTER_OTLP_PROTOCOL": "http/protobuf",
    "OTEL_EXPORTER_OTLP_ENDPOINT": "http://10.8.0.1:4318",
    "OTEL_METRIC_EXPORT_INTERVAL": "10000"
  }
}

Start een sessie, verstuur één prompt, wacht op het exportinterval (hier 10 seconden, standaard 60 seconden) en vraag Prometheus vervolgens wat er is geregistreerd:

curl -s http://localhost:9090/api/v1/label/__name__/values | grep -o 'claude_code[a-z_]*'

U zou verschillende namen moeten krijgen die beginnen met claude_code_. De exporter vervangt punten door underscores en voegt de eenheid toe, dus de exacte strings hangen af van uw collector-versie. Een leeg resultaat betekent dat er niets is binnengekomen. Controleer of het protocol en de poort overeenkomen, aangezien http/protobuf naar 4318 gaat en grpc naar 4317; een mismatch resulteert in een stille fout. Voer claude --debug uit en het debug-logboek rapporteert OTel-exporterfouten.

Voor één machine zonder server kunt u bovenstaande stappen overslaan. Stel OTEL_METRICS_EXPORTER=prometheus in en Claude Code stelt zelf een scrape-endpoint beschikbaar op http://localhost:9464/metrics. Wanneer prometheus de enige vermelde exporter is, laat Claude Code de eenheden USD, tokens en s weg uit de namen van de statistieken, zodat de scrape een geldig Prometheus-tekstformaat behoudt.

Bij deze opzet hoort een privacybesluit. Standaard verlaten alleen tellers de machine; er worden geen promptteksten of tool-outputs verstuurd. OTEL_LOG_USER_PROMPTS=1 en OTEL_LOG_TOOL_CONTENT=1 wijzigen dit, waarna uw metrics-server broncode en andere contextgegevens bevat. Schakel deze opties bewust in en lees eerst geheimen buiten de agent-context houden.

Uitgaven bijhouden voor gescripte en CI-runs

Niet-interactieve runs verrassen gebruikers vaak, omdat er niemand meekijkt op het scherm. claude -p met --output-format json rapporteert de kosten van die run in de resultaat-payload:

claude -p "summarise the failing tests" --output-format json | jq '.total_cost_usd'

De payload bevat total_cost_usd en een uitsplitsing per model, zodat een CI-job zijn eigen uitgaven kan vastleggen zonder tussenkomst van een dashboard. Voeg de waarde toe aan een bestand of verstuur deze als metriek naar de bovenstaande collector. Dit is de goedkoopste bruikbare methode voor het bijhouden van uitgaven en het kost slechts één jq-aanroep per run.

Foutmodi en wat u zult zien

Het rapport is leeg. npx ccusage@latest daily als er geen rijen worden afgedrukt, betekent dit dat het programma niet leest op de locatie waar Claude Code schrijft. CLAUDE_CONFIG_DIR verplaatst die locatie en de parser moet hiervan op de hoogte worden gesteld. Als er wel rijen bestaan, maar deze stoppen ongeveer een maand geleden, dan werkt cleanupPeriodDays zoals ontworpen: transcripties worden standaard na 30 dagen verwijderd.

Twee machines rapporteren verschillende totalen. Dit is verwacht en geen bug. Zowel /usage als elke log-parser leest alleen de lokale sessiegeschiedenis, dus gebruik vanaf een ander apparaat of via claude.ai ontbreekt in beide gevallen.

Het lokale totaal komt niet overeen met de factuur. Lokale cijfers worden berekend op basis van tokentellingen tegen standaardlijsttarieven. Ze hebben geen weet van promotionele prijzen of contractuele kortingen, en bij een abonnement worden uw tokens helemaal niet individueel gefactureerd. De gebruiksgegevens in de Console zijn leidend voor API-facturering.

De kosten stegen terwijl u hetzelfde werk deed. Controleer als eerste de cache-kolommen. Een lange sessie verstuurt bij elke beurt de volledige geschiedenis opnieuw; dit wordt berekend tegen het cache-tarief zolang de cache warm is, en tegen het volledige input-tarief zodra deze afkoelt. Eén lange pauze zorgt er dus voor dat het volledige gesprek opnieuw wordt verwerkt. Dit is zichtbaar als een hoog input-getal naast een laag output-getal, en input- versus output-tokenprijzen legt uit waarom deze twee onafhankelijk van elkaar variëren.

Een dag met subagents lijkt onmogelijk. Elke subagent draait in zijn eigen contextvenster, dus het tokengebruik schaalt mee met het aantal actieve agents en de duur van elk proces. Alleen de OTel-data maakt onderscheid tussen deze agents, via het query_source-attribuut op claude_code.token.usage. Een log-parser toont u het totaal en laat u in het ongewisse over de verdeling.

FAQ

Geeft ccusage aan wat er daadwerkelijk in rekening wordt gebracht bij een Max-abonnement?

Nee. Bij een abonnement betaalt u niet per token. Een log-parser berekent de kosten van uw tokens op basis van de standaard API-tarieven en toont wat hetzelfde werk via de API zou hebben gekost. Het is een goede relatieve maatstaf voor de werklast op een dag en is nuttig om projecten of modellen met elkaar te vergelijken. Voor het bedrag dat u verschuldigd bent, raadpleegt u de pagina voor API-facturering in de Console en de pagina voor abonnementsfacturering.

Waar slaat Claude Code de sessiebestanden op die deze tools uitlezen?

In ~/.claude/projects/<project>/<session-id>.jsonl, waarbij <project> het pad naar de werkmap is, met niet-alfanumerieke tekens vervangen door -. Elke regel is een JSON-object voor één bericht, toolgebruik of metadata-item. CLAUDE_CONFIG_DIR verplaatst de gehele map en cleanupPeriodDays in settings.json regelt de bewaartermijn van 30 dagen. Anthropic documenteert het invoerformaat als intern en onderhevig aan wijzigingen tussen versies; parse dit daarom met een onderhouden tool in plaats van met een eigen script.

Kan ik Claude Code-telemetrie naar Langfuse sturen?

Niet rechtstreeks. Het Langfuse OTLP-eindpunt accepteert traces, terwijl Claude Code metrics en log-events exporteert in plaats van spans; de data kan daar dus niet worden verwerkt. Stuur Claude Code-metrics naar een OpenTelemetry-collector en sla deze op in Prometheus. Gebruik Langfuse voor agents die u zelf bouwt op de API, waarbij uw eigen code spans genereert die de prompt, het model en de kosten bevatten.

Waarom komen mijn lokale cijfers niet overeen met de gebruiksgegevens in de Console?

Omdat ze op verschillende manieren worden berekend. /usage en log-parsers tellen het aantal tokens uit sessiebestanden op de machine waar u aan werkt en berekenen de prijs op basis van de standaardtarieven. De Console rapporteert wat uw organisatie daadwerkelijk in rekening is gebracht, over alle machines en alle keys heen, na eventuele kortingen. Een verschil is normaal. Een zeer groot verschil duidt meestal op een tweede apparaat, een CI-runner of een ander teamlid dat kosten maakt op hetzelfde account.

Hoe houd ik de kosten van een claude -p-run in CI bij?

Voer deze uit met --output-format json en lees total_cost_usd uit het resultaat, bijvoorbeeld met claude -p "..." --output-format json | jq '.total_cost_usd'. Dezelfde payload bevat een uitsplitsing per model en het sessie-ID. Registreer die waarde per job en u beschikt over de kosten per pipeline zonder dat daar een agent, dashboard of extra service voor nodig is.