Wat zijn Claude-tokens? Tokenverbruik in Claude Code

Wat zijn tokens in Claude?

Een token is de teksteenheid die Claude leest en schrijft: een deel van een woord. In de eigen woordenlijst van Anthropic komt dit bij modellen van vóór Claude Opus 4.7 neer op ongeveer 3.5 Engelse tekens. Bij de huidige tokenizer ligt dit dichter bij 2.5, omdat Anthropic daar 1M tokens gelijkstelt aan ongeveer 2.5M tekens. In beide gevallen komt dit, wanneer spaties en leestekens worden meegerekend, neer op ruim één token per woord. Duizend woorden proza zijn dus ruimschoots meer dan 1,300 tokens. Code gebruikt per regel meer tokens: accolades, operators, underscores en inspringingen worden per teken in meer tokens opgesplitst dan Engelse tekst. Een bronbestand van enkele honderden regels bevat doorgaans enkele duizenden tokens. Een bestand van 2,000 regels dat de agent besluit te lezen, kost al vijf cijfers aan tokens voordat er ook maar één regel nieuwe code is geschreven.

Twee eigenschappen van tokenizers zorgen vaak voor verwarring. Ten eerste zijn ze modelspecifiek. Vanaf oktober 2026 gebruiken Claude Opus 4.7 en alle latere modellen, waaronder de huidige Fable 5.1, Opus 5.5, Sonnet 5.5 en Haiku 5.5, een nieuwere tokenizer die voor dezelfde tekst ongeveer 30% meer tokens produceert dan eerdere Claude-modellen, zoals Haiku 4.5. De exacte toename verschilt per inhoud. Daardoor verschuift alles wat u in tokens begroot, ook al zijn de prijzen per token niet verhoogd. Ten tweede is tiktoken, de library waarnaar vrijwel elk blogbericht verwijst, de tokenizer van OpenAI en niet die van Claude. De telling daarvan komt dus niet overeen met wat Anthropic factureert. Alleen het count_tokens-endpoint geeft een betrouwbare telling. Dit wordt hieronder behandeld.

Waarom uw codesessie kost wat deze kost

Elke Claude-factuur, zowel een API-factuur als een abonnementslimiet, draait voornamelijk op één teller: tokens erin en tokens eruit. Enkele API-tools voegen een afzonderlijke kostenpost toe. Web search kost bijvoorbeeld vanaf October 2026 $10 per 1.000 zoekopdrachten, boven op de tokens die de resultaten toevoegen. In een codesessie is het echter de tokenteller die doorloopt. De prijspagina lijkt eenvoudig: een bepaald bedrag per miljoen invoertokens en een bepaald bedrag per miljoen uitvoertokens. Wat daar niet uit blijkt, is dat de invoerkant van de teller in een agentische codesessie veel sneller oploopt dan u op basis van intuïtie zou verwachten, omdat de volledige conversatie bij elke beurt opnieuw wordt verzonden. Ik verkoop al vijftien jaar infrastructuur met verbruiksmeting. Tokens zijn de eerste teller die ik ben tegengekomen waarvan de meeste klanten werkelijk niet kunnen aangeven wat deze laat oplopen. Dit is de les in het aflezen van de teller: wat in een agentische sessie als invoer en uitvoer telt, waarom de lus van het opnieuw verzenden zo duur is, waarom prompt caching de berekening volledig verandert en aan welke knoppen u daadwerkelijk kunt draaien om het getal te beïnvloeden.

Alles is invoer: wat de meter daadwerkelijk telt

Mensen denken dat ze betalen voor de code die Claude schrijft. In een agentische sessie is dat slechts een kleine kostenpost. Invoertokens hebben een lager tarief, maar het volume is veel groter. Hieronder vallen:

• De systeemprompt. De eigen harness-instructies van Claude Code, plus uw CLAUDE.md en geheugenbestanden, worden bij de start van de sessie geladen en daarna bij elk verzoek opnieuw meegestuurd.
• Tooldefinities. Elk toolschema dat de agent kan aanroepen. Elke MCP-server waarmee u verbinding maakt verhoogt deze vaste overhead. Claude Code stelt volledige MCP-tooldefinities nu standaard uit. Daardoor staan alleen de toolnamen in de context totdat een tool voor het eerst wordt gebruikt. Dat beperkt de kosten, maar elimineert ze niet.
• Elk bestand dat de agent leest. Een Read van een bronbestand plaatst het volledige bestand in de context. Het blijft daar vervolgens staan.
• Elk toolresultaat. Testuitvoer, grep-uitvoer, terminaluitvoer, buildlogs: alles komt terug als invoertokens. Een mislukte testsuite die 8,000 regels afdrukt, is een klein boek. Sinds oktober 2026 stuurt Claude Code standaard ongeveer 30,000 tekens van commandoutput inline mee. Langere uitvoer komt binnen als opgeslagen bestand met een voorbeeld van maximaal 2,000 tekens. Elke uitvoer onder die limiet en elke latere lezing van het opgeslagen bestand wordt echter volledig in rekening gebracht.
• Het volledige gesprek tot dat moment, bij elke beurt opnieuw verzonden. Dit onderwerp verdient een eigen sectie.

De kosten van opnieuw verzenden lopen snel op

De Claude API is stateless. De API onthoudt uw sessie niet tussen aanvragen; geen enkele aanvraag doet dat. Bij beurt 2 stuurt de client daarom beurt 1, het antwoord daarop en uw nieuwe bericht mee. Bij beurt 50 verzendt de client opnieuw alles wat uit beurten 1 tot en met 49 nog in de context staat: elk gelezen bestand, elk toolresultaat en elk diff dat nog niet is gecomprimeerd, plus beurt 50. Bij compaction wordt oude geschiedenis vervangen door een samenvatting. Het lezen van bestanden door een subagent blijft in diens eigen context; alleen het resultaat komt terug. Het model leest telkens opnieuw het volledige behouden transcript. Al die opnieuw gelezen tokens worden als input in rekening gebracht.

Het gevolg is dat de kosten per beurt ongeveer lineair toenemen met de sessieduur. De totale kosten van de sessie nemen ongeveer kwadratisch toe. 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 zestig beurten aan context meedraagt. Dit ene feit verklaart de meeste meldingen met de vraag waarom een factuur zo hoog was. Het is geen eigenaardigheid van Claude. Elk LLM-product dat aanvoelt alsof het stateful is, gebruikt onderliggend een stateless API met een lus die de context opnieuw verzendt.

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

Output-tokens zijn de kostbare tokens; ze zijn vijf keer zo duur als de input-tokens in de huidige line-up ($10/$50 voor Fable 5.1, $4/$20 voor Opus 5.5, $2/$10 voor Sonnet 5.5, $0,10/$0,50 voor Haiku 5.5 voor prompts tot 100.000 tokens, per oktober 2026). Output omvat de tekst en code die Claude genereert, en denk-tokens: de interne redenering die het model uitvoert voordat het antwoord wordt gegeven. Twee feiten zijn hierbij van belang. Denken 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; de API laat deze standaard weg bij Fable 5.1, Opus 5.5, Sonnet 5.5, Haiku 5.5 en de eerdere modellen tot aan Opus 4.7, maar het denkproces heeft wel plaatsgevonden en wordt nog steeds gefactureerd. Onzichtbaar is niet gratis.

Claude Code schakelt uitgebreid denken standaard in omdat dit de resultaten bij taken met meerdere stappen meetbaar 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 schakel het denkproces uit in /config bij modellen die dit toestaan. Per oktober 2026 kan Claude Code het denkproces niet uitschakelen bij Opus 5.5, Sonnet 5.5, Haiku 5.5 of de Fable-modellen, dus inspanning is daar de knop waaraan u kunt draaien. De API biedt u bij twee van deze modellen meer ruimte. Haiku 5.5 accepteert thinking: {"type": "disabled"} bij een inspanningsniveau van 'high' of lager, net als de oudere Opus 5, terwijl de oudere Sonnet 5 dit bij elk inspanningsniveau accepteert, inclusief xhigh en max. Sonnet 5.5 wijst "disabled" af en accepteert in plaats daarvan thinking: {"type": "between_tools"}, wat het voorafgaande denkproces bij een laag, gemiddeld of hoog inspanningsniveau achterwege laat, zodat een verzoek zonder tools direct antwoord geeft zonder eerst te denken. Alleen Opus 5.5 en de Fable-modellen blijven denken bij alles wat u verstuurt. Dat is een reële kostenfactor, geen bijgeloof.

Promptcaching herschrijft de rekensom

Promptcaching voorkomt dat de resend-lus iedereen financieel ruïneert. De API kan een stabiel prefix van uw prompt, systeemprompt, tooldefinities en gespreksgeschiedenis cachen en dit bij het volgende verzoek tegen een fractie van de prijs leveren. In oktober 2026 zijn de multipliers als volgt: een cache-write kost 1.25× het basistarief voor input (2× voor de variant van 1 uur), en een cache-read kost 0.1× bij de meeste modellen, 0.05× bij Claude Opus 5.5 en Claude Sonnet 5.5, en 0.025× bij Claude Fable 5.1. Writes zijn duurder; reads geven bij de meeste modellen 90% korting, bij Opus 5.5 en Sonnet 5.5 95% korting en bij Fable 5.1 97.5% korting. (Het read-tarief van Sonnet 5.5 is op 7 oktober 2026 verlaagd van 0.1× naar 0.05×.) Eén read verdient de meerprijs van de write na 5 minuten al ruimschoots terug.

Claude Code beheert de caching voor u. In een gezonde sessie wordt vrijwel die volledige grote resend vanuit de cache geleverd. De cache verloopt echter na een periode van inactiviteit. In oktober 2026 geeft Claude Code uw hoofdgesprek een cache van 1 uur bij een abonnement, binnen het inbegrepen gebruik van uw plan. Met een API key, een cloudprovider of zodra u usage credits gebruikt, geldt een cacheduur van 5 minuten sinds het laatste gebruik (de instelling promptCacheTtl kan daar 1 uur aanvragen, tegen een write-tarief van 2×). Bij een cache van 5 minuten gaat u even weg voor een koffie die langer duurt. U komt terug en verstuurt een bericht. De cache is verlopen en het volledige opgebouwde prefix wordt opnieuw geschreven tegen 1.25×, in plaats van gelezen tegen het cache-tarief. In een sessie van 150K tokens worden bij die ene koude beurt alle 150K tokens geschreven tegen 1.25×. Bij een warme beurt zouden ze zijn gelezen tegen 0.1×. Dat is een verschil van factor 12.5 voor het prefix, factor 25 bij Opus 5.5 en Sonnet 5.5, en factor 50 bij Fable 5.1. Dit tegenintuïtieve resultaat moet u onthouden: een ritme van inactiviteit en hervatten kan meer kosten dan continu werken, omdat elke inactieve periode die langer duurt dan de TTL uw volgende beurt omzet van een goedkope read in een dure nieuwe write. Werk in blokken. Voer bij een cache van 5 minuten geen enorme sessie druppelsgewijs uit met één bericht per 10 minuten.

Als u de API aanroept vanuit uw eigen applicatie op een VPS, gebeurt dit niet automatisch. U kiest hiervoor met cache_control. De klassieke fout die u zelf veroorzaakt, is een timestamp of request ID die in de systeemprompt wordt geïnterpoleerd. Daardoor veranderen de bytes van het prefix bij elk verzoek en wordt caching stilzwijgend uitgeschakeld. De aanwijzing is dat usage.cache_read_input_tokens bij ogenschijnlijk identieke aanroepen op nul blijft staan.

De formule, met een uitgewerkt voorbeeld

Negeer iedereen die beweert dat "een sessie $X kost". De kosten van sessies kunnen honderdvoudig verschillen. De formule is wel betrouwbaar:

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

read multiplier = 0.10 on most models, 0.05 on Opus 5.5 and Sonnet 5.5, 0.025 on Fable 5.1
session cost = sum over all turns

Uitgewerkt voorbeeld met Claude Opus 4.8, inmiddels een verouderd model maar nog steeds beschikbaar en per oktober 2026 nog steeds geprijsd op $5 per miljoen invoertokens en $25 per miljoen uitvoertokens. Een beurt halverwege de sessie met 80,000 tokens aan opgebouwde context: 75,000 gelezen uit de cache, 3,000 nieuw geschreven, 2,000 niet-gecachete nieuwe invoertokens en 1,500 uitvoertokens, inclusief thinking.

• Cachelezingen: 75,000 × $0.50/M = $0.0375
• Cache-schrijfbewerkingen: 3,000 × $6.25/M = $0.019
• Niet-gecachete invoer: 2,000 × $5/M = $0.010
• Uitvoer: 1,500 × $25/M = $0.0375

Ongeveer $0.10 voor de beurt; vijftig vergelijkbare beurten kosten ongeveer $5. Bekijk nu dezelfde beurt nadat de cache is verlopen: de 78,000 cachebare tokens worden opnieuw geschreven tegen $6.25/M. Samen met dezelfde 2,000 niet-gecachete tokens tegen $5/M komt dit vóór de uitvoer uit op ongeveer $0.50. Dat is ongeveer vijf keer de kosten van de volledige beurt met een warme cache, voor identiek werk. Dat verschil vat caching in één getal samen. Met het huidige Claude Opus 5.5 ($4/$20, met cachelezingen tegen 0.05×) kost dezelfde beurt met een warme cache ongeveer $0.07 (lezingen $0.015, schrijfbewerkingen $0.015, niet-gecachete invoer $0.008, uitvoer $0.030). De koude variant kost vóór de uitvoer $0.40, dus bijna zes keer de warme beurt. Diezelfde vier regels zijn ook de enige eerlijke manier om leveranciers te vergelijken, omdat vermelde tarieven geen rekening houden met cachelezingen en thinking. Als u ze toepast op drie echte taken, ziet u waar de Claude-factuur hoger of lager uitvalt dan die van OpenAI.

Als u inzicht wilt in de factureringseenheid zelf, in plaats van in één afzonderlijke beurt, voert wat een miljoen tokens oplevert in pagina's, bestanden en dollars dezelfde berekening één niveau hoger uit. Gebruik de volgende cijfers voor kalibratie, niet voor voorspellingen: volgens de gepubliceerde cijfers van Anthropic voor enterprise-implementaties van Claude Code bedragen de kosten per actieve dag gemiddeld ongeveer $13 per ontwikkelaar en $150 tot $250 per maand, per oktober 2026. 90% van de gebruikers blijft onder $30 per dag. Uw kosten hangen af van de modelkeuze, sessiehygiëne en de omvang van de codebase. Daarom zijn de onderstaande instellingen van belang.

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 kostenraming voor de huidige sessie; bij abonnementen toont hetzelfde scherm uw limietbalken en een overzicht waarin recent verbruik wordt toegeschreven aan skills, subagents, plugins en individuele MCP-servers. In recente versies bevat het Session-blok ook een Prompt cache (main)-regel die het aandeel van de input uit de cache toont, de misses, en of de cache op dit moment warm is. 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 het contextvenster bezet houdt, systeem-prompt, tools, MCP-definities, bestanden, geschiedenis, en is de snelste manier om een opgeblazen CLAUDE.md of een spraakzame MCP-server op te sporen; in de fullscreen-modus wordt het overzicht per item ingeklapt, en door all mee te geven wordt het uitgeklapt.

Vanuit de API vertelt elke respons u precies wat er is gebeurd:

response = client.messages.create(model="claude-sonnet-5-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 dat input_tokens alleen het niet-gecachte restant is; de werkelijke promptgrootte is de som van alle drie de inputvelden. 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-eindpunt om een schatting te maken voordat u verstuurt; 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 het daadwerkelijke verzoek):

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

Gebruik nooit tiktoken, om de hierboven genoemde reden.

Abonnementen versus betalen op basis van gebruik

De werking in deze handleiding is overal hetzelfde; alleen de afrekening verschilt. Met een API key brengt Anthropic kosten in rekening op basis van gebruik, per token en tegen de gepubliceerde tarieven. Elk hierboven genoemd getal vertegenwoordigt dus echte kosten. Die meter begint eerder te lopen dan de meeste mensen verwachten. Er is namelijk geen gratis niveau waarop u kunt terugvallen. U krijgt alleen een klein tegoed bij registratie en enkele endpoints waarvoor geen kosten in rekening worden gebracht. Zie wat een nieuw API-account daadwerkelijk krijgt voordat u een kaart registreert. De uitzondering is sinds October 7, 2026 een Max- of Team-abonnement. Deze plannen bevatten nu maandelijkse API-tegoeden voor uw eigen apps en agents op het Claude Platform: $100 per maand bij Max 5x, $200 bij Max 20x en bij Team $20 per Standard-seat en $100 per Premium-seat, samengevoegd en gemaximeerd op $500. U activeert deze door een Console-organisatie te koppelen. Ongebruikte tegoeden verlopen aan het einde van elke factureringscyclus en zijn niet beschikbaar voor interactief Claude Code. Bij een Claude-abonnement (Pro, Max, Team en oudere Enterprise-plannen op basis van seats) wordt het gebruik van Claude Code in plaats daarvan afgetrokken van de inbegrepen hoeveelheid van uw plan. In October 2026 gaat het om een voortschrijdend sessievenster van vijf uur plus een wekelijks venster. Deze worden gedeeld tussen modellen en met de chat op claude.ai. Het bedrag in dollars van /usage is informatief en geen factuurbedrag. Er zijn twee uitzonderingen sinds October 2026. Huidige Enterprise-seats op basis van gebruik bevatten helemaal geen inbegrepen gebruik. Elke token wordt daar tegen de standaard API-tarieven in rekening gebracht. Fable-modellen vallen niet binnen de inbegrepen hoeveelheid bij Pro, standaard Team-seats of standaard oudere Enterprise-seats. Daarvoor betaalt u op basis van gebruik met gebruikstegoeden. Als u een venster volledig gebruikt, ziet u "You've hit your session limit" of "You've hit your weekly limit", met een tijdstip waarop het venster wordt gereset. Wisselen van model met /model herstelt de toegang niet, omdat de vensters voor alle modellen worden gedeeld. Deze vensters zijn gekoppeld aan het account en niet aan de client waarin u op dat moment werkt. Dat is belangrijk als u nog nagaat wat native op Linux werkt en welk plan elke omgeving dekt. Welk van de twee vensters u daadwerkelijk hebt uitgeput, bepaalt hoe lang u moet wachten en wat u intussen kunt doen. Daarom is het nuttig om te weten wat uw opties zijn wanneer u midden in een taak een limiet bereikt. Plannen kunnen optioneel gebruikstegoeden inschakelen. Met /usage-credits beheert u deze tegoeden en koopt u gebruik boven de limiet. Ik vermeld de plangrenzen bewust niet. Dat zijn de meest veranderlijke getallen in dit hele onderwerp. Controleer daarom claude.com/pricing en uw eigen /usage-balken. De tokenwerking blijft ook bij een abonnement belangrijk. Een verspillende sessie gebruikt uw venster op dezelfde manier als zij dollars zou kosten. Zie voor het abonnementsdeel welk Claude-plan bij uw gebruik past.

De maatregelen 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 beknopt. Het wordt in elke sessie geladen, dus beperk het tot de essentie. Verplaats workflow-specifieke instructies naar skills die alleen worden geladen wanneer dat nodig is.
• Houd de context duidelijk en compact. Na /clear tussen niet-gerelateerde taken wordt verouderde context bij elk volgend bericht opnieuw verzonden en opnieuw in rekening gebracht. Binnen één lange taak vat /compact Focus on the failing tests and the diff de geschiedenis steeds verder samen, zodat u niet op de kwadratische groeicurve terechtkomt.
• Kies een model van de juiste omvang. Sonnet volstaat voor de meeste programmeertaken tegen $2/$10 per miljoen tokens per oktober 2026. Dat is nu een standaardtarief en geen introductieprijs: Sonnet 5.5 kost $2/$10 en Sonnet 5 behield $2/$10 nadat de geplande verhoging per September 1 naar $3/$15 was geannuleerd. Ter vergelijking: Opus 5.5 kost $4/$20. Haiku 5.5 kost $0.10/$0.50 voor prompts tot 100,000 tokens en $0.50/$2.50 daarboven, en is geschikt voor mechanisch subagentwerk zoals het sorteren van logmeldingen. Fable 5.1 bevindt zich aan het andere uiteinde met $10/$50, hetzelfde tarief als Fable 5 en aan beide zijden van de meter tweeënhalf keer zo duur als Opus 5.5. Het is daarom verstandig om te weten welke taken dat tarief daadwerkelijk rechtvaardigen voordat u dit model voor routinematig werk geselecteerd laat. Met /model kunt u tijdens een sessie van model wisselen.
• Filter uitvoer met veel tekst vooraf. Een hook die een testrun met grep terugbrengt tot alleen fouten voordat Claude de uitvoer ziet, verkleint een toolresultaat van 20,000 tokens tot 300 tokens. Dat gebeurt opnieuw bij elke toekomstige verzending van die beurt.
• Verwerk niet-interactieve taken in batches. 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.
• Houd rekening met de cacheklok. Werk in aaneengesloten sessies. Een losgekoppelde Claude Code-sessie in tmux op een VPS kost niets zolang deze inactief is; tokens worden alleen verbruikt wanneer een beurt wordt uitgevoerd. Inactiviteit na de cache-TTL maakt de warme cache echter ongeldig. De volgende beurt moet de context dan opnieuw wegschrijven.

FAQ

Hoeveel tokens gebruikt een codeersessie in Claude Code?

Er is geen vast aantal. Eén beurt halverwege een sessie bevat vaak tienduizenden prompttokens zodra bestanden en geschiedenis zich hebben opgestapeld. Een werksessie loopt op tot miljoenen tokens. Het grootste deel daarvan wordt vanuit de cache geleverd tegen een tiende van het basistarief of minder, afhankelijk van het model. Ter kalibratie: de gepubliceerde enterprise-cijfers van Anthropic komen in oktober 2026 uit op gemiddeld ongeveer $13 per ontwikkelaar per actieve dag. Bij 90% van de gebruikers blijft dit onder $30. Voer /usage uit in uw eigen sessie. Vijf minuten monitoren is nuttiger dan welk gepubliceerd gemiddelde ook.

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

Ja. Thinking tokens worden gefactureerd als outputtokens tegen het hogere tarief. Ze tellen mee voor max_tokens. Huidige modellen factureren deze tokens ook wanneer de interface de samenvatting van de redenering niet weergeeft. Als een antwoord wordt afgekapt met stop_reason: "max_tokens" voordat het zichtbare antwoord is voltooid, heeft thinking waarschijnlijk het budget verbruikt. Verlaag in Claude Code het inspanningsniveau met /effort voor taken waarvoor geen diepgaande redenering nodig is.

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

Omdat de API stateless is: bij elke beurt wordt de volledige conversatie die nog in de context staat opnieuw verzonden. Daaronder vallen elk gelezen bestand, elk toolresultaat en elke eerdere uitwisseling die nog niet is gecomprimeerd. Deze inhoud wordt als invoer gefactureerd. Beurt 50 bevat daardoor beurten 1 tot en met 49 als invoer. Prompt caching levert het herhaalde voorvoegsel bij de meeste modellen tegen een tiende van de prijs voor standaardinvoer (5% voor Opus 5.5 en Sonnet 5.5, 2.5% voor Fable 5.1). Het voorvoegsel blijft echter groeien. Na een inactieve periode die langer duurt dan de cache-TTL wordt de volgende beurt volledig tegen het normale tarief opnieuw geschreven. /compact verkleint de geschiedenis. /clear start deze opnieuw.

Hoe controleer ik mijn Claude-tokengebruik en -kosten?

In Claude Code toont /usage de tokenstatistieken van de sessie, een lokale kostenraming en balken met de limieten van het abonnement (/cost is een alias). /context toont welke inhoud het contextvenster vult. Gebruik voor de definitieve API-facturering de usage-pagina in de Claude Console. Lees in uw eigen code response.usage uit. De som van input_tokens, cache_creation_input_tokens en cache_read_input_tokens geeft de werkelijke promptgrootte. Gebruik het count_tokens-endpoint om vooraf een schatting te maken, en gebruik daarvoor nooit tiktoken.