Hoe werken Claude tokens en wat kosten code sessies?

Wat zijn tokens in Claude?

Een token is de eenheid van tekst die Claude leest en schrijft: een fragment van een woord, ongeveer 3,5 Engelse tekens. Dat cijfer is afkomstig uit de eigen woordenlijst van Anthropic en komt uit op ruim meer dan één token per woord als spaties en leestekens worden meegeteld; duizend woorden proza zijn dus ruim meer dan 1.300 tokens. Code is zwaarder per regel: accolades, operatoren, underscores en inspringingen worden opgesplitst in meer tokens per teken dan bij Engels, en een bronbestand van enkele honderden regels telt doorgaans enkele duizenden tokens. Een bestand van 2.000 regels dat de agent besluit te lezen, is een aankoop van vijf cijfers aan tokens voordat er ook maar één regel nieuwe code is geschreven.

Twee zaken met betrekking tot tokenizers zorgen vaak voor verwarring. Ten eerste zijn ze modelspecifiek. Sinds juli 2026 gebruiken Opus 4.7 en later, Sonnet 5 en Fable 5 een nieuwere tokenizer die ongeveer 30% meer tokens genereert voor dezelfde tekst dan eerdere Claude-modellen (de exacte toename varieert per inhoud). Dit verschuift alles wat u in tokens begroot, ook al zijn de prijzen per token niet mee gestegen. Ten tweede is tiktoken, de bibliotheek waar elke blogpost naar verwijst, de tokenizer van OpenAI; deze telt voor Claude ongeveer 15–20% te laag bij gewone tekst, en nog meer bij code. De enige betrouwbare telling is het count_tokens-eindpunt, dat hieronder wordt behandeld.

Waarom uw codeersessie de kosten met zich meebrengt die u ziet

Elke factuur van Claude, of het nu gaat om een API-factuur of een abonnementslimiet, is gebaseerd op één meter: tokens in, tokens uit. De prijspagina doet het eenvoudig lijken: een bepaald bedrag per miljoen input-tokens, en een bedrag per miljoen output-tokens. Wat daar niet wordt vermeld, is dat bij een agentische codeersessie de inputzijde van de meter veel sneller oploopt dan men intuïtief zou verwachten, omdat het volledige gesprek bij elke afzonderlijke interactie opnieuw wordt verzonden. Ik verkoop al vijftien jaar infrastructuur op basis van verbruik, en tokens zijn de eerste meter waarbij de meeste klanten oprecht niet kunnen zeggen wat het verbruik veroorzaakt. Dit is de les in het aflezen van de meter: wat telt als input en output in een agentische sessie, waarom de herhalingslus zo kostbaar is, waarom prompt caching de berekening verandert en welke factoren daadwerkelijk invloed hebben op het totaalbedrag.

Alles is input: wat de meter daadwerkelijk telt

Mensen gaan ervan uit dat ze betalen voor de code die Claude schrijft. In een agent-sessie is dat slechts een kleine kostenpost. Input-tokens, het goedkopere tarief maar met een aanzienlijk groter volume, omvatten:

• De system prompt. De eigen instructies van Claude Code, plus uw CLAUDE.md en geheugenbestanden, die bij de start van de sessie worden geladen en daarna bij elk verzoek aanwezig zijn.
• Tool-definities. Elk tool-schema dat de agent kan aanroepen. Elke MCP-server die u verbindt draagt bij aan deze vaste overhead, hoewel Claude Code volledige MCP-tooldefinities tegenwoordig standaard uitstelt. Hierdoor staan alleen de toolnamen in de context totdat een tool voor het eerst wordt gebruikt, wat de kosten verzacht maar niet elimineert.
• Elk bestand dat de agent leest. Een Read van een bronbestand plaatst de volledige inhoud in de context, en deze blijft daar staan.
• Elk tool-resultaat. Testruns, grep-output, terminal-uitvoer, build-logs; dit alles komt terug als input-tokens. Een falende testsuite die 8.000 regels afdrukt, heeft u zojuist gefactureerd voor een klein boekwerk.
• Het volledige gesprek tot nu toe, dat bij elke beurt opnieuw wordt verzonden. Dit punt verdient een eigen sectie.

De kosten van het opnieuw verzenden

De Claude API is stateless. Deze onthoudt uw sessie niet tussen verzoeken, en dat geldt voor alle API's. Bij de tweede beurt verstuurt de client daarom de eerste beurt, inclusief het antwoord daarop, plus uw nieuwe bericht. Bij de vijftigste beurt worden beurt 1 tot en met 49 opnieuw verzonden, inclusief elk gelezen bestand, elk tool-resultaat en elke diff, aangevuld met beurt 50. Het model leest het volledige transcript telkens opnieuw, en al deze opnieuw gelezen tokens worden als input in rekening gebracht.

Het gevolg: de kosten per beurt stijgen ongeveer lineair met de lengte van de sessie, en de totale sessiekosten stijgen ongeveer kwadratisch. Een bericht dat bij beurt 3 een halve cent kostte, kan bij beurt 60 twintig keer zoveel kosten voor dezelfde vraag van één regel, omdat het de ballast van zestig beurten meedraagt. Dit is het enige feit dat de meeste supporttickets over "waarom is mijn factuur zo hoog" verklaart. Dit is geen eigenaardigheid van Claude; elk LLM-product dat stateful aanvoelt, is in feite een stateless API met een resend-loop op de achtergrond.

Output: wat u ziet, plus het denkproces dat u niet ziet

Output-tokens zijn de kostbare tokens; ze zijn vijf keer zo duur als input-tokens in de huidige line-up ($5/$25 voor Opus 4.8, $3/$15 voor Sonnet 5, $1/$5 voor Haiku 4.5, per juli 2026). Output omvat zowel de tekst en code die Claude genereert, als denk-tokens: de interne redenering die het model uitvoert voordat het antwoord wordt gegeven. Twee feiten zijn hierbij van belang. Het denkproces wordt gefactureerd tegen output-tarieven en telt mee voor max_tokens; een API-respons die eindigt met stop_reason: "max_tokens" en een afgebroken antwoord betekent vaak dat het denkproces het budget heeft verbruikt voordat het antwoord klaar was. Bij de huidige modellen wordt de samenvatting van het redeneerproces mogelijk helemaal niet weergegeven; Opus 4.8, Sonnet 5 en Fable 5 laten deze standaard weg, maar het denkproces heeft wel plaatsgevonden en wordt nog steeds gefactureerd. Onzichtbaar is niet gratis.

Claude Code schakelt uitgebreid denkwerk standaard in omdat dit meetbaar de resultaten bij taken met meerdere stappen verbetert, en het standaardbudget kan oplopen tot tienduizenden tokens per verzoek. Bij eenvoudigere taken kunt u dit terugschroeven: verlaag het inspanningsniveau met /effort of in /model, of pas de instellingen voor het denkproces aan in /config. Dit is een reële kostenbesparende maatregel, geen bijgeloof.

Prompt caching herschrijft de berekening

Prompt caching is de reden waarom de resend-loop niet iedereen failliet laat gaan. De API kan een stabiel voorvoegsel van uw prompt, systeemprompt, tooldefinities en gespreksgeschiedenis cachen en deze bij een volgend verzoek tegen een fractie van de prijs aanbieden. Sinds juli 2026 gelden de volgende vermenigvuldigers: een cache-write kost 1,25× het basistarief voor invoer (2× voor de variant van 1 uur), en een cache-read kost 0,1×. Writes zijn een premium; reads bieden 90% korting. Eén enkele read verdient de 5-minuten write-premium al ruimschoots terug.

Claude Code beheert caching voor u, en in een gezonde sessie wordt bijna die volledige, enorme resend vanuit de cache geserveerd. De standaard cache blijft echter vijf minuten na het laatste gebruik actief. Als u even wegloopt voor een koffiepauze die uitloopt, terugkomt en een bericht verstuurt, is de cache verlopen en wordt het volledige opgebouwde voorvoegsel opnieuw geschreven tegen 1,25× in plaats van gelezen tegen 0,1×. Bij een sessie van 150K tokens kost die ene koude beurt meer dan een dozijn warme beurten. Dit is het contra-intuïtieve resultaat dat u zich moet realiseren: een ritme van pauzeren en hervatten kan meer kosten dan continu doorwerken, omdat elk inactief gat na de TTL uw volgende beurt verandert van een goedkope read in een dure re-write. Werk in blokken; verstuur niet mondjesmaat één bericht per tien minuten in een grote sessie.

Als u de API aanroept vanuit uw eigen applicatie op een VPS, krijgt u dit niet gratis. De klassieke, zelfveroorzaakte fout is een timestamp of request ID die in de systeemprompt wordt geïnterpoleerd; dit verandert bij elk verzoek de bytes van het voorvoegsel en schakelt caching geruisloos uit. Het teken hiervan is dat usage.cache_read_input_tokens op nul blijft staan bij verzoeken die er identiek uitzien.

De formule, met een uitgewerkt voorbeeld

Negeer beweringen dat "een sessie $X kost". De kosten van sessies variëren met twee ordes van grootte. Wat wel standhoudt, is de formule:

turn cost = (uncached input      x base input price)
          + (cache writes        x 1.25 x base input price)
          + (cache reads         x 0.10 x base input price)
          + (output incl. thinking x output price)

session cost = sum over all turns

Uitgewerkt voorbeeld voor Claude Opus 4.8, dat per juli 2026 $5 per miljoen input-tokens en $25 per miljoen output-tokens kost. Een gemiddelde sessie-interactie met 80.000 tokens aan opgebouwde context: 75.000 gelezen uit de cache, 3.000 nieuw geschreven, 2.000 niet-gecachte verse input, 1.500 output-tokens inclusief denkproces.

• Cache-reads: 75.000 × $0,50/M = $0,0375
• Cache-writes: 3.000 × $6,25/M = $0,019
• Niet-gecachte input: 2.000 × $5/M = $0,010
• Output: 1.500 × $25/M = $0,0375

Ongeveer $0,10 voor de interactie; vijftig van dergelijke interacties kosten ongeveer $5. Dezelfde interactie nadat de cache is verlopen: de volledige 80.000 tokens worden opnieuw geschreven tegen $6,25/M, wat $0,50 kost vóór de output. Dit is ruwweg vijf keer de prijs van de volledige 'warme' interactie voor identiek werk. Dat verschil is de essentie van caching in één getal. Diezelfde vier regels zijn ook de enige eerlijke manier om leveranciers te vergelijken, omdat catalogusprijzen cache-reads en denkprocessen volledig negeren. Wanneer u deze vergelijkt over drie echte opdrachten, ziet u waar de rekening van Claude boven of onder die van OpenAI uitkomt.

Als u meer inzicht wilt in de facturatie-eenheid zelf in plaats van in een enkele interactie, dan voert wat een miljoen tokens betekent in pagina's, bestanden en dollars dezelfde berekening uit op een hoger niveau. Ter kalibratie in plaats van voorspelling: de gepubliceerde cijfers van Anthropic voor zakelijke Claude Code-implementaties bedragen per juli 2026 gemiddeld ongeveer $13 per ontwikkelaar per actieve dag, $150–250 per maand, waarbij 90% van de gebruikers onder de $30 per dag blijft. Uw werkelijke kosten zijn afhankelijk van de modelkeuze, sessiehygiëne en de omvang van de codebase; dit is precies waarom de onderstaande knoppen van belang zijn.

Uw eigen verbruik inzien

In Claude Code is het commando /usage (/cost werkt ook nog, dit is een alias). Het Session-blok bovenaan toont tokenstatistieken en een lokaal berekende kostenindicatie voor de huidige sessie; bij abonnementen toont hetzelfde scherm de voortgangsbalken van uw limieten en een overzicht waarin recent verbruik wordt toegewezen aan skills, subagents, plugins en individuele MCP-servers. Voor officiële facturatie bij API-accounts is de verbruikspagina in de Claude Console de enige bron van waarheid; het cijfer in de CLI is een schatting. /context tekent een gekleurd raster van wat de context window bezet houdt, system prompt, tools, MCP-definities, bestanden en geschiedenis. Dit is de snelste manier om een opgeblazen CLAUDE.md of een spraakzame MCP-server te identificeren; gebruik all om het volledige overzicht per item uit te klappen.

Vanuit de API vertelt elk antwoord u precies wat er is gebeurd:

response = client.messages.create(model="claude-sonnet-5", max_tokens=2048,
                                  messages=messages)
u = response.usage
total_prompt = u.input_tokens + u.cache_creation_input_tokens + u.cache_read_input_tokens
print(f"uncached={u.input_tokens} written={u.cache_creation_input_tokens} "
      f"read={u.cache_read_input_tokens} output={u.output_tokens}")

Let op: input_tokens is alleen het niet-gecachte restant; de werkelijke promptgrootte is de som van alle drie de invoervelden. Een agent die een uur heeft gedraaid en input_tokens: 4000 toont, is niet goedkoop; de overige 200.000 tokens werden vanuit de cache geserveerd. Gebruik het token-counting endpoint om vooraf een schatting te maken. Dit is gratis aan te roepen, heeft een eigen rate limit en telt met de tokenizer van het model dat u opgeeft (beschouw het resultaat als een nauwkeurige schatting; de facturatie weerspiegelt de daadwerkelijke aanvraag):

count = client.messages.count_tokens(model="claude-sonnet-5",
                                     messages=[{"role": "user", "content": big_file}])
print(count.input_tokens)

Gebruik nooit tiktoken, vanwege de bovenstaande reden.

Abonnementsvormen versus pay-as-you-go

De mechanismen in deze handleiding zijn overal identiek; alleen de afrekening verschilt. Met een API key factureert Anthropic op basis van pay-as-you-go, per token, tegen de gepubliceerde tarieven; elk getal hierboven staat voor echt geld. Die meter begint sneller te lopen dan de meeste mensen verwachten, omdat er geen gratis laag is om op terug te vallen, enkel een klein tegoed bij aanmelding en een handvol endpoints die niets kosten, wat is wat een nieuw API-account daadwerkelijk krijgt voordat u een creditcard koppelt. Bij een Claude-abonnement (Pro, Max, Team, Enterprise) verbruikt Claude Code de inbegrepen limiet van uw abonnement: per juli 2026 is dat een voortschrijdend venster van vijf uur plus een wekelijks venster, gedeeld over modellen en met claude.ai chat, en het /usage dollarbedrag is informatief in plaats van een factuur. Zodra een venster is uitgeput, ziet u "You've hit your session limit" of "You've hit your weekly limit" met een reset-tijd, en het wisselen van modellen met /model herstelt de toegang niet, omdat de vensters gedeeld worden over alle modellen. Die vensters zijn gekoppeld aan het account in plaats van aan de client waarin u werkt; dit is nuttig om te weten als u nog aan het uitzoeken bent wat er native op Linux draait en welk abonnement elk platform dekt. Welk van de twee vensters u daadwerkelijk heeft uitgeput, bepaalt hoe lang de wachttijd is en wat u in de tussentijd kunt doen, dus het is de moeite waard om uw opties te kennen wanneer u een limiet bereikt tijdens een taak. Abonnementen kunnen optioneel gebruikstegoeden inschakelen, beheerd via /usage-credits, om verbruik voorbij het plafond te kopen. Ik vermeld bewust de abonnementsquota niet: dit zijn de meest volatiele getallen in dit hele onderwerp, dus controleer claude.com/pricing en uw eigen /usage-balken. De token-mechanismen blijven van belang bij een abonnement; een inefficiënte sessie verbruikt uw venster op precies dezelfde manier als het dollars zou verbruiken. Zie voor de abonnementskant welk Claude-abonnement bij uw gebruik past.

De hefbomen die daadwerkelijk werken

• Beperk wat de agent leest. "Los de validatiefout in auth.py op" leest één bestand; "verbeter deze codebase" leest er veertig. Houd CLAUDE.md compact; het wordt in elke sessie geladen, dus beperk het tot de essentie en verplaats werkstroomspecifieke instructies naar vaardigheden die op aanvraag worden geladen.
• Helder en beknopt. /clear tussen niet-gerelateerde taken; verouderde context wordt bij elk volgend bericht opnieuw verzonden en in rekening gebracht. Binnen één lange taak vat /compact Focus on the failing tests and the diff de geschiedenis samen, waardoor u niet tegen de kwadratische curve aanloopt.
• Kies het juiste model. Sonnet verwerkt het meeste programmeerwerk voor $2/$10 per miljoen tokens tegen introductieprijzen per juli 2026 ($3/$15 catalogusprijs, tegenover Opus voor $5/$25), en Haiku voor $1/$5 is het juiste gereedschap voor mechanisch subagent-werk zoals het triëren van logs. Fable 5 bevindt zich aan de andere kant van het spectrum met $10/$50, twee keer zo duur als Opus aan beide kanten van de meter. Het is daarom de moeite waard om te weten welke taken dat tarief daadwerkelijk rechtvaardigen voordat u het geselecteerd laat voor routinewerk. /model schakelt tijdens een sessie.
• Filter uitgebreide uitvoer vooraf. Een hook die een testrun met grep reduceert tot alleen de fouten voordat Claude deze ziet, verandert 20.000 tokens aan toolresultaten in 300. Dit bespaart tokens bij elke toekomstige herverzending van die beurt.
• Batch wat niet interactief is. Voor uw eigen API-pipelines, classificatie, bulkbeoordelingen en nachtelijke taken voert de Batches API dezelfde modellen uit met 50% korting in ruil voor asynchrone levering.
• Respecteer de cache-klok. Werk in aaneengesloten periodes. Een losgekoppelde Claude Code-sessie in tmux op een VPS kost niets terwijl deze inactief is; tokens worden alleen verbruikt wanneer een beurt wordt uitgevoerd, maar de warme cache gaat verloren tijdens de inactiviteit, waardoor de volgende beurt de kosten voor het opnieuw schrijven betaalt.

FAQ

Hoeveel tokens verbruikt een programmeersessie in Claude Code?

Er is geen vast aantal. Een enkele interactie halverwege een sessie bevat vaak tienduizenden prompt-tokens zodra bestanden en de geschiedenis zich opstapelen. Een volledige werksessie loopt in de miljoenen, waarbij het merendeel uit de cache wordt geserveerd tegen een tiende van het basistarief. Ter indicatie: de door Anthropic gepubliceerde zakelijke cijfers van juli 2026 liggen gemiddeld rond de $13 per ontwikkelaar per actieve dag, waarbij 90% van de gebruikers onder de $30 blijft. Voer /usage uit in uw eigen sessie; vijf minuten observeren zegt meer dan welk gepubliceerd gemiddelde dan ook.

Kosten 'thinking tokens' geld, zelfs als ik ze niet kan zien?

Ja. Thinking tokens worden gefactureerd als output-tokens, het dure tarief, en tellen mee voor max_tokens. Huidige modellen factureren deze tokens ook wanneer de interface de samenvatting van het redeneerproces niet toont. Als een antwoord wordt afgebroken met stop_reason: "max_tokens" voordat het zichtbare antwoord is voltooid, heeft het denkproces waarschijnlijk het budget verbruikt. Verlaag in Claude Code het inspanningsniveau met /effort voor taken die geen diepgaande redenering vereisen.

Waarom wordt een lange Claude Code-sessie per bericht duurder?

Omdat de API stateless is: elke interactie verstuurt het volledige gesprek, elk gelezen bestand, elk tool-resultaat en elke eerdere uitwisseling opnieuw als gefactureerde input. Interactie 50 draagt dus interacties 1 tot en met 49 als ballast mee. Prompt caching serveert het herhaalde voorvoegsel tegen ongeveer een tiende van de basisprijs voor input, maar het voorvoegsel zelf blijft groeien. Elke inactieve periode die de cache-TTL overschrijdt, dwingt de volgende interactie tot een volledige herberekening tegen de volle prijs. /compact verkleint de geschiedenis; /clear reset deze.

Hoe controleer ik mijn Claude-tokenverbruik en -kosten?

In Claude Code toont /usage de tokenstatistieken van de sessie, een lokale kostenraming en voortgangsbalken voor abonnementslimieten (/cost is een alias); /context laat zien wat het venster vult. Gebruik voor officiële API-facturering de usage-pagina in de Claude Console. Lees in uw eigen code response.usage uit; het sommeren van input_tokens, cache_creation_input_tokens en cache_read_input_tokens geeft de werkelijke promptgrootte. Maak vooraf een schatting met het count_tokens-endpoint, nooit met tiktoken.