Wat zijn tokens in Claude en hoe werken ze? We hebben er 3,8 miljard geteld

Je komt het woord overal rond Claude tegen: in de prijslijst, in de limietmelding, in /usage, in elk artikel over geld besparen. Bijna niemand zegt wat een token is, en het getal waar mensen naar kijken is zelden het getal dat ertoe doet. Het deel dat Claude terugschrijft, is een fractie van een procent van wat een codeersessie telt.

Dus hebben we de onze geteld. Dertig dagen Claude Code-sessies op één Mac, van 10 september tot 9 oktober 2026: 388 sessies, 19.668 verzoeken aan het model, 3,8 miljard tokens. Dit is wat een token is, de vier manieren waarop Claude ze telt, en hoe die getallen eruitzien bij echt werk.

Een token is een stukje tekst, en de grootte van het stukje verandert

Een model leest geen letters of woorden. Het leest tokens: stukjes tekst uit een vaste woordenschat, soms een heel kort woord, vaak een deel van een woord, soms een enkel teken of byte voor iets wat het nog nooit heeft gezien. Alles wordt in die stukjes geteld: wat je stuurt, wat Claude schrijft, wat het tussen beurten bewaart.

Hoeveel tekst er in een token past, hangt af van het model en van de taal. De woordenlijst van Anthropic geeft ongeveer 3,5 Engelse tekens per token op modellen vóór Claude 4.7, en zegt dat Claude 4.7 en later een nieuwere tokenizer gebruiken die voor dezelfde tekst ongeveer 30% meer tokens oplevert. Het exacte aantal komt alleen uit het token counting-endpoint, met het model dat je wilt gebruiken.

We hebben de verhouding op onze eigen tekst gemeten. Onze agents antwoorden in het Frans, dus namen we de antwoorden die alleen uit tekst bestonden, zonder denkwerk, zonder toolaanroep, zonder codeblok, met minstens 80 woorden: 296 ervan, verdeeld over Opus 5, Opus 5.5, Fable 5.1 en Sonnet 5.5. De mediaan was 2,3 tekens per token, ongeveer 2,6 tokens per woord. Code, JSON en niet-Latijnse schriften geven andere verhoudingen. Het gaat niet om het exacte getal: een token is kleiner dan een woord, en je telt ze nooit met de hand.

Elk verzoek wordt op vier tellers geteld

Claude Code schrijft elke sessie naar een JSONL-transcript onder ~/.claude/projects/. Elk antwoord van het model bevat een usage-blok. Hier is een echt exemplaar uit onze transcripten, met de nuttige velden:

"usage": {
  "input_tokens": 2,
  "cache_creation_input_tokens": 51836,
  "cache_read_input_tokens": 24882,
  "output_tokens": 315,
  "output_tokens_details": { "thinking_tokens": 54 },
  "cache_creation": {
    "ephemeral_1h_input_tokens": 51836,
    "ephemeral_5m_input_tokens": 0
  }
}

Vier tellers, en ze kosten niet hetzelfde:

• input_tokens: het deel van de prompt dat niet naar de cache wordt geschreven en er ook niet uit wordt gelezen, gefactureerd tegen de basisprijs voor input. In Claude Code is het bijna altijd een handvol tokens, omdat bijna alles via de cache loopt.
• cache_creation_input_tokens: het deel van de prompt dat in de cache wordt opgeslagen zodat het volgende verzoek het kan hergebruiken. Een cacheschrijving kost 1,25 keer de inputprijs voor een cache van 5 minuten en 2 keer voor een cache van 1 uur. In onze transcripten was 97% van de schrijvingen van het type 1 uur.
• cache_read_input_tokens: het deel van de prompt dat opnieuw uit de cache wordt afgespeeld. Een cachelezing kost 0,1 keer de inputprijs op de meeste modellen, 0,05 keer op Opus 5.5 en Sonnet 5.5, en 0,025 keer op Fable 5.1 (de pagina van Anthropic over prompt caching, gecontroleerd op 10 oktober 2026).
• output_tokens: wat Claude schrijft, denkwerk inbegrepen. Output kost op elk huidig model 5 keer de inputprijs: 20 dollar per miljoen op Opus 5.5, 25 op Opus 5, 50 op Fable 5.1, 10 op Sonnet 5.5.

De eerste drie samen vormen de context die het model voor dit verzoek heeft gelezen. De vierde is het antwoord.

Hoe 30 dagen van onze sessies eruitzien

Over de 19.668 verzoeken, elk verzoek één keer geteld (één API-aanroep kan meerdere regels van een transcript beslaan):

De kostenkolom prijst elk verzoek met zijn eigen model en zijn eigen cacheduur. Dat bedrag betalen we niet: deze sessies liepen op een abonnement. Het is het gewicht van elke teller, dezelfde weging die AgentsRoom gebruikt om het percentage van een abonnement over de projecten te verdelen.

Drie conclusies.

Bijna elk token is het gesprek dat opnieuw wordt gelezen. 97,7% van de tokens zijn cachelezingen. 99,2% van de verzoeken las iets uit de cache. Als mensen zeggen dat een sessie "50 miljoen tokens heeft gebruikt", is dit waar ze naar kijken.

Wat Claude schrijft, is klein in tokens en niet klein in kosten. 0,34% van de tokens, 16,8% van de rekening, omdat output het duurste token is dat er bestaat. Denkwerk was 29% van die output.

Cacheschrijvingen zijn de dure verrassing. 2% van de tokens, 37% van de kosten. We verwachtten dat ze zouden komen van het verlopen van de cache, maar slechts 16 van de 19.668 verzoeken moesten een koude context opnieuw schrijven, zeven daarvan na meer dan een uur stilte. 79% van de schrijvingen is gewoon elk nieuw bericht en elk toolresultaat dat één keer wordt opgeslagen, tegen twee keer de inputprijs, voordat het bij elke volgende beurt opnieuw wordt gelezen. De overige 20% is het eerste verzoek van elke sessie.

Waarom een sessie bij elke beurt zwaarder wordt

Het model onthoudt niets tussen twee verzoeken. Claude Code stuurt elke keer alles opnieuw: de systeemprompt, de tooldefinities, CLAUDE.md, elk bericht, elk bestand dat het las, elke commando-uitvoer. De cache maakt het herhaalde deel goedkoop per token, niet gratis, en niet kleiner.

Mediane gelezen context per verzoek, naar positie in de sessie:

Het mediane verzoek las 179.000 tokens context om 290 tokens antwoord te schrijven. Die verhouding is het hele verhaal van tokens in een codeeragent: het antwoord is kort, het lezen is lang, en het lezen groeit mee met de sessie.

Ons eerste verzoek is zwaar, 52.000 tokens voordat iemand iets had getypt, omdat onze agents starten met een lange rolbriefing en vier MCP-servers waarvan de tooldefinities in de prompt staan. Een kale Claude Code-sessie in een lege map begint veel lager. /context laat zien wat de jouwe meedraagt vóór het eerste bericht.

Wat één sessie gebruikt

Over de 380 sessies met minstens drie verzoeken:

• 33 verzoeken als mediaan, 16 tot 61 voor de middelste helft.
• 27.000 outputtokens als mediaan, 12.000 tot 48.000.
• 5,4 miljoen verwerkte tokens als mediaan, 1,5 tot 10,7 miljoen voor de middelste helft, waarvan 5,1 miljoen cachelezingen.
• 181.000 tokens als mediaan naar de cache geschreven of zonder cache verstuurd: het deel dat echt nieuw was.
• 4,55 dollar tegen API-lijstprijzen als mediaan, 1,81 tot 9,25 voor de middelste helft.

Het eerlijke antwoord op "hoeveel tokens gebruikt een codeersessie" is dus een bereik van ongeveer één tot tien miljoen, bijna allemaal dezelfde context die opnieuw wordt gelezen. Een sessie die de hele middag aan één lange taak werkt, zit bovenaan het bereik; een sessie die één bug oplost en stopt, zit onderaan.

Wat het 5-uursvenster en de week echt tellen

Op een Pro- of Max-abonnement zie je nooit een tokensaldo. Het helpcentrum van Anthropic zegt dat beide abonnementen een sessielimiet van vijf uur en een weeklimiet hebben, dat die limieten gedeeld worden tussen Claude en Claude Code (IDE inbegrepen), en dat Max-abonnementen een aparte weeklimiet voor Fable hebben. Het publiceert voor geen van beide een tokengetal. /usage toont een percentage van elk venster, en het tijdstip waarop het reset.

Wat dat percentage laat bewegen, volgens Anthropics eigen lijst: berichtlengte, grootte van bijlagen, lengte van het huidige gesprek, toolgebruik, modelkeuze, inspanningsniveau en taken met meerdere stappen. Gelezen naast de tabellen hierboven is "lengte van het huidige gesprek" degene die een codeersessie domineert: de context die bij elk verzoek wordt gelezen, groeit over vijftig verzoeken van 52.000 naar 237.000 tokens. Het helpcentrum zegt ook dat gecachete inhoud in projecten minder zwaar meetelt voor je limieten wanneer die wordt hergebruikt, wat hetzelfde idee is als de prijs van een cachelezing.

We weten niet hoe Anthropic tokens omrekent naar een percentage van een venster, en we gaan geen omrekening verzinnen. Wat de data wel zegt, is dat een laat verzoek in een lange sessie voor dezelfde vraag meerdere keren zoveel telt als een vroeg verzoek.

Wat de telling in de praktijk verandert

Vier hefbomen, in de volgorde waarin ze in onze data meetellen:

• /clear tussen taken die niets met elkaar te maken hebben. Anthropic noemt het "de meest effectieve hefboom voor zowel kwaliteit als kosten". Een nieuwe taak in een oude sessie betaalt bij elk verzoek voor de context van de oude taak.
• /compact als je een lange sessie voortzet. Het vervangt de geschiedenis door een korte samenvatting, zodat de volgende verzoeken minder lezen.
• Let op wat er in de context belandt. Een gelezen bestand of commando-uitvoer van 20.000 tokens wordt één keer geschreven tegen twee keer de inputprijs, en daarna bij elk volgend verzoek opnieuw gelezen tot de sessie eindigt. Alleen de regels lezen die je nodig hebt in plaats van het hele bestand, levert dubbel op.
• Model en inspanning. Denkwerk was 29% van onze output, en output is het duurste token. Een lager inspanningsniveau bij routinewerk verlaagt de output, en een goedkoper model verlaagt alle prijzen in één keer.

Wat in onze data niet uitmaakte: een sessie laten stilliggen. Met de cache van 1 uur die Claude Code in onze transcripten gebruikt, gebeurde een koude herschrijving 16 keer in 30 dagen.

Voor meer manieren om minder uit te geven, zie hoe je de tokenkosten van Claude Code verlaagt.

Tel de jouwe

De tabel hierboven komt uit een script zonder afhankelijkheden. Het leest elk Claude Code-transcript op de machine, telt elk verzoek één keer, en print de vier tellers en de medianen per sessie. Voeg een filter op o["timestamp"] toe als je een tijdvenster wilt.

import json, glob, os, statistics as st
from collections import defaultdict

FIELDS = ("input_tokens", "cache_creation_input_tokens",
          "cache_read_input_tokens", "output_tokens")
totals, sessions = defaultdict(int), []
for path in glob.glob(os.path.expanduser("~/.claude/projects/*/*.jsonl")):
    seen, session = set(), defaultdict(int)
    with open(path, errors="ignore") as fh:
        for line in fh:
            try: o = json.loads(line)
            except ValueError: continue
            msg = o.get("message") or {}
            usage = msg.get("usage") if isinstance(msg, dict) else None
            if o.get("type") != "assistant" or not usage: continue
            rid = o.get("requestId") or o.get("uuid")
            if rid in seen: continue   # one API call can span several lines
            seen.add(rid)
            session["requests"] += 1
            for f in FIELDS:
                n = usage.get(f) or 0
                totals[f] += n
                session[f] += n
    if session["requests"] >= 3: sessions.append(session)

grand = sum(totals[f] for f in FIELDS)
for f in FIELDS:
    print(f"{f:30s} {totals[f]:>15,} {100 * totals[f] / grand:6.2f}%")
for key in ("requests", "output_tokens", "cache_read_input_tokens"):
    print(f"median per session, {key}: {st.median(s[key] for s in sessions):,.0f}")

Vergelijk jouw aandelen met de onze. De regel met cachelezingen is het gesprek dat opnieuw wordt gelezen, en de regel met cacheschrijvingen is wat nieuw was: die twee zeggen meer over je rekening dan de outputregel.

Waar AgentsRoom het toont

Het script geeft je een maand. Terwijl je werkt, toont AgentsRoom dezelfde tellers per agent: een tokenbadge in de composer van elke sessie die rood wordt als een sessie zwaar wordt, een sessiemonitor met input, output, cacheschrijvingen, cachelezingen en het cache-hitpercentage, en een sessietrace die de sessie beurt voor beurt afspeelt om te laten zien welk gelezen bestand of welk toolresultaat de context heeft gevuld. Het gebruikspaneel verdeelt het percentage dat je abonnement meldt over je projecten en je agents, waarbij elke sessie wordt gewogen naar wat ze tegen API-prijzen zou kosten, dezelfde weging als in de tabel hierboven.

Wat niets hiervan je geeft, is een tokensaldo, omdat je abonnement er geen heeft. Voor die vraag, zie hoeveel tokens je nog hebt in Claude. Voor de snelheid waarmee die outputtokens binnenkomen, zie tokens per seconde van Claude Code, gemeten.

Veelgestelde vragen

Wat is een token in Claude?

De eenheid waarin Claude tekst leest en schrijft: een stukje van een woord, soms een heel kort woord, soms een enkel teken of byte. Volgens Anthropic hangt de grootte af van het model en de taal: op modellen vóór Claude 4.7 was een token ongeveer 3,5 Engelse tekens, en Claude 4.7 en later gebruiken een nieuwere tokenizer die voor dezelfde tekst ongeveer 30% meer tokens oplevert. Alles wat Claude doet, wordt in tokens gemeten: wat je stuurt, wat het terugschrijft en wat het tussen beurten in zijn cache bewaart.

Hoeveel tekens of woorden is een Claude-token?

Dat hangt af van de taal en van de tekst. Anthropic geeft ongeveer 3,5 Engelse tekens per token op modellen vóór Claude 4.7, en ongeveer 30% meer tokens voor dezelfde tekst op Claude 4.7 en later. Op 296 antwoorden in pure tekst die onze agents in september en oktober 2026 in het Frans schreven, was een token 2,3 tekens, of ongeveer 2,6 tokens per woord. Code, JSON en niet-Latijnse schriften geven andere verhoudingen. Voor een exacte telling neemt het token counting-endpoint van Anthropic de tekst en het model aan.

Waarom gebruikt Claude Code zoveel tokens?

Omdat elk verzoek het hele gesprek opnieuw verstuurt: de systeemprompt, de tooldefinities, CLAUDE.md, elk bericht en elk toolresultaat tot dan toe. Op onze 19.668 verzoeken droeg het mediane verzoek 179.000 tokens context mee om 290 tokens antwoord te schrijven, en de context groeide van 52.000 tokens bij het eerste verzoek van een sessie naar 237.000 na vijftig verzoeken. De cache maakt dat herlezen goedkoop per token, maar het wordt wel geteld.

Hoeveel tokens gebruikt een typische Claude Code-sessie?

Op onze 380 sessies van drie of meer verzoeken, opgenomen tussen 10 september en 9 oktober 2026: een mediaan van 33 verzoeken, 27.000 outputtokens en in totaal 5,4 miljoen verwerkte tokens, waarvan 5,1 miljoen cachelezingen. De helft van de sessies lag tussen 1,5 en 10,7 miljoen tokens. Tegen de API-lijstprijzen zou die mediane sessie ongeveer 4,55 dollar hebben gekost; op een Pro- of Max-abonnement wordt hetzelfde werk in plaats daarvan afgeboekt van het 5-uursvenster en het weekvenster.

Tellen denktokens mee?

Ja. Denktokens maken in elk usage-blok deel uit van output_tokens, met een veld thinking_tokens dat zegt hoeveel van de output denkwerk was. Op de API worden ze tegen de outputprijs gefactureerd, en Anthropic noemt het inspanningsniveau bij de dingen die de gebruikslimieten van een abonnement sneller opmaken. In ons corpus was denkwerk 29% van alles wat de modellen schreven.

Wat is het verschil tussen cacheschrijving- en cachelezingtokens?

Een cacheschrijving slaat een deel van de prompt op zodat het volgende verzoek het kan hergebruiken, en kost meer dan gewone input: 1,25 keer de inputprijs voor een cache van 5 minuten, 2 keer voor een cache van 1 uur. Een cachelezing hergebruikt dat opgeslagen deel en kost veel minder: 0,1 keer de inputprijs op de meeste modellen, 0,05 keer op Opus 5.5 en Sonnet 5.5, 0,025 keer op Fable 5.1. In onze sessies waren cachelezingen 98% van de tokens en 46% van de kosten tegen lijstprijzen; cacheschrijvingen waren 2% van de tokens en 37% van de kosten.