Wat zijn tokens in Claude? Kosten uitleg

Wat zijn tokens in Claude?

Een token is de tekstuele eenheid die Claude leest en schrijft: een fragment van een woord, ongeveer 3.5 Engelse tekens. Dit cijfer komt uit de eigen woordenlijst van Anthropic. Inclusief spaties en leestekens resulteert dit in ruim meer dan één token per woord. Duizend woorden tekst zijn dus ruim meer dan 1.300 tokens. Code verbruikt meer tokens per regel: accolades, operatoren, underscores en inspringingen splitsen in meer tokens per karakter dan Engels. Een bronbestand van enkele honderden regels weegt typisch enkele duizenden tokens. Een bestand van 2.000 regels dat de agent leest, kost al vijf cijfers aan tokens voordat er een regel nieuwe code is geschreven.

Twee aspecten van tokenizers zorgen voor verwarring. Ten eerste zijn ze modelspecifiek. Sinds juli 2026 gebruiken Opus 4.7 en later, Sonnet 5 en Fable 5 een nieuwere tokenizer. Deze produceert ongeveer 30% meer tokens voor dezelfde tekst dan eerdere Claude-modellen (de exacte toename varieert per inhoud). Dit beïnvloedt uw tokenbudget, ook al zijn de prijzen per token niet gestegen. Ten tweede is tiktoken, de bibliotheek die veel gebruikt wordt in blogposts, de tokenizer van OpenAI. Deze onderschat het aantal tokens voor Claude met ongeveer 15–20% bij gewone tekst, en nog meer bij code. De enige betrouwbare meting is de count_tokens endpoint, beschreven in het volgende gedeelte.

Waarom uw programmeersessie deze kosten met zich meebrengt

Elke Claude-factuur, of het nu een API-factuur of een abonnementslimiet betreft, is gebaseerd op één meter: tokens in en tokens uit. De prijzenpagina maakt het eenvoudig: een bepaald aantal dollars per miljoen input tokens en een bepaald aantal per miljoen output tokens. Wat er niet staat, is dat bij een agentic programmeersessie de input-zijde van de meter veel sneller oploopt dan men verwacht. Dit komt doordat de volledige conversatie bij elke beurt opnieuw wordt verzonden. Ik verkoop al vijftien jaar infrastructuur op basis van verbruik, en tokens zijn de eerste meter waarbij de meeste klanten niet precies kunnen aangeven wat de kosten drijft. Dit is de les over het aflezen van de meter: wat telt als input en output in een agentic sessie, waarom de herhalingslus duur is, waarom prompt caching de berekening verandert, en welke knoppen de kosten daadwerkelijk beïnvloeden.

Alles is input: wat de meter daadwerkelijk bijhoudt

Gebruikers gaan ervan uit dat zij betalen voor de code die Claude schrijft. In een agentic session is dit slechts een klein onderdeel van de kosten. Input tokens — het goedkopere tarief, maar met een veel groter volume — bevatten het volgende:

• De system prompt. De instructies van de Claude Code harness, plus uw CLAUDE.md en memory files. Deze worden geladen bij de start van de session en zijn aanwezig bij elke volgende request.
• Tool definitions. Elk tool schema dat de agent kan aanroepen. Elke MCP server die u verbindt verhoogt deze vaste overhead. Claude Code stelt volledige MCP tool definitions standaard uit; alleen de tool namen staan in de context totdat een tool voor het eerst wordt gebruikt. Dit verlaagt de kosten, maar elimineert ze niet.
• Elk bestand dat de agent leest. Een Read van een source file plaatst het volledige bestand in de context, en dit blijft aanwezig.
• Elk tool result. Test runs, grep output, terminal output, build logs — alles komt terug als input tokens. Een test suite die faalt en 8,000 regels print, brengt de kosten van een klein boek in rekening.
• De volledige conversatie tot nu toe, die bij elke beurt opnieuw wordt verzonden. Dit onderdeel verdient een eigen sectie.

De kosten stijgen door het opnieuw verzenden van data

De Claude API is stateless. De API onthoudt uw sessie niet tussen verzoeken. Daarom stuurt de client bij beurt 2 de inhoud van beurt 1, het antwoord van de API en uw nieuwe bericht. Bij beurt 50 worden beurten 1 tot en met 49 opnieuw verzonden — inclusief elke gelezen file, elk tool result en elke diff — plus beurt 50. Het model leest het volledige transcript elke keer opnieuw. Elk token dat opnieuw wordt gelezen, wordt in rekening gebracht als input.

Het gevolg: de kosten per beurt stijgen nagenoeg lineair met de sessie-lengte. De totale sessiekosten stijgen nagenoeg kwadratisch. Een bericht dat bij beurt 3 een half cent kostte, kan bij beurt 60 twintig keer dat bedrag kosten voor dezelfde vraag van één regel. Dit komt doordat het bericht de data van zestig beurten met zich meedraagt. Dit is de belangrijkste reden voor de meeste supportvragen over hoge facturen. Dit is geen eigenaardigheid van Claude; elk LLM-product dat stateful lijkt, is in feite een stateless API met een resend loop.

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

Output tokens zijn de duurste tokens — vijf keer de input-tarieven binnen de huidige lijn ($5/$25 op Opus 4.8, $3/$15 op Sonnet 5, $1/$5 op Haiku 4.5, per juli 2026). Output bevat de tekst en code die Claude genereert, en thinking tokens: de interne redenering die het model uitvoert voordat het antwoordt. Twee feiten zijn hier van belang. Thinking wordt gefactureerd tegen de output-tarieven en telt mee voor max_tokens — een API-respons die stopt bij stop_reason: "max_tokens" en een afgebroken antwoord betekent vaak dat het denken het budget heeft verbruikt voordat het antwoord dat deed. En bij huidige modellen wordt de samenvatting van de redenering mogelijk helemaal niet weergegeven — Opus 4.8, Sonnet 5 en Fable 5 laten dit standaard weg — maar het denken heeft nog steeds plaatsgevonden en wordt nog steeds gefactureerd. Onzichtbaar is niet gratis.

Claude Code staat uitgebreid denken standaard toe omdat het meerstaps-taken meetbaar verbetert, en het standaardbudget kan oplopen tot tienduizenden tokens per verzoek. Bij eenvoudigere taken kunt u dit verlagen: verlaag het inspanningsniveau met /effort of in /model, of pas de thinking-instellingen aan in /config. Dit is een echte kostenpost, geen bijgeloof.

Prompt caching verandert de kostenberekening

Prompt caching voorkomt dat herhaalde verzoeken de kosten onbeheersbaar maken. De API kan een stabiele prefix van uw prompt opslaan — zoals de system prompt, tool-definities en de conversatiegeschiedenis — en deze bij de volgende aanvraag tegen een fractie van de prijs serveren. Per juli 2026 gelden de volgende multipliers: een cache write kost 1.25× het basis tarief voor input (2× voor de 1-uurs variant), en een cache read kost 0.1×. Writes zijn duurder; reads bieden een korting van 90%. Eén enkele read verdient de meerprijs van een 5-minuten write al terug.

Claude Code beheert de caching voor u. In een actieve sessie wordt bijna al het herhaalde dataverkeer uit de cache geleverd. De standaard cache is echter slechts vijf minuten geldig na het laatste gebruik. Als u een pauze neemt die langer duurt, is de cache verlopen zodra u een nieuw bericht stuurt. De volledige geaccumuleerde prefix moet dan opnieuw worden geschreven tegen 1.25× in plaats van gelezen tegen 0.1×. Bij een sessie van 150K-tokens kost één enkele koude beurt meer dan een dozijn warme beurten. Dit is het tegenintuïtieve resultaat: een ritme van inactiviteit gevolgd door herstel kan meer kosten dan continu werken. Elke pauze die langer duurt dan de TTL verandert de volgende beurt van een goedkope read in een dure re-write. Werk in blokken; stuur niet elke tien minuten één bericht in een grote sessie.

Als u de API aanroept vanuit uw eigen applicatie op een VPS, krijgt u deze voordelen niet automatisch. Een veelvoorkomende fout is het invoegen van een timestamp of request ID in de system prompt. Dit verandert de bytes van de prefix bij elke aanvraag, waardoor caching onzichtbaar wordt uitgeschakeld. U herkent dit wanneer usage.cache_read_input_tokens op nul blijft staan bij identieke aanroepen.

De formule, met een uitgewerkt voorbeeld

Negeer uitspraken die beweren dat "een sessie $X kost." De kosten per sessie variëren met twee grootteordes. De formule is de enige constante:

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 op Claude Opus 4.8. De tarieven zijn per juli 2026 $5 per miljoen input tokens en $25 per miljoen output tokens. Een gemiddelde sessie-beurt met 80.000 tokens aan geaccumuleerde context: 75.000 gelezen uit cache, 3.000 nieuw geschreven, 2.000 nieuwe uncached input, 1.500 output tokens inclusief thinking.

• Cache reads: 75.000 × $0.50/M = $0.0375
• Cache writes: 3.000 × $6.25/M = $0.019
• Uncached input: 2.000 × $5/M = $0.010
• Output: 1.500 × $25/M = $0.0375

Ongeveer $0.10 per beurt. Bij vijftig vergelijkbare beurten is het totaal ongeveer $5. De kosten voor dezelfde beurt nadat de cache is verlopen: de volledige 80.000 tokens tegen $6.25/M is $0.50 voordat de output wordt berekend. Dit is ongeveer vijf keer de kosten van de warme beurt voor dezelfde hoeveelheid werk. Dit verschil illustreert de impact van caching.

Ter kalibratie in plaats van voorspelling: de gepubliceerde cijfers van Anthropic voor enterprise Claude Code-implementaties zijn per juli 2026 gemiddeld ongeveer $13 per ontwikkelaar per actieve dag — $150–250 per maand. 90% van de gebruikers blijft onder de $30 per dag. De uiteindelijke kosten zijn afhankelijk van de modelkeuze, de hygiëne van de sessie en de omvang van de codebase. Dit is de reden waarom de onderstaande methoden belangrijk zijn.

Uw eigen verbruik bekijken

In Claude Code is het commando /usage (/cost werkt nog steeds — dit is een alias). Het Session-blok bovenaan toont tokenstatistieken en een lokaal berekende kostenraming voor de huidige sessie. Bij abonnementen toont hetzelfde scherm de limieten van uw abonnement en een uitsplitsing van recent verbruik per skill, subagent, plugin en individuele MCP server. Voor de officiële facturatie bij API-accounts is de usage-pagina in de Claude Console de enige bron van waarheid — het bedrag in de CLI is een schatting. /context genereert een gekleurd raster van wat het contextvenster bezet houdt — system prompt, tools, MCP-definities, bestanden, historie — en is de snelste manier om een opgeblazen CLAUDE.md of een zeer actieve MCP server te identificeren; gebruik all voor een volledige uitsplitsing per item.

Via de API geeft elke respons exact aan 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 dat input_tokens alleen het niet-gecachete restant is — de werkelijke promptgrootte is de som van alle drie de invoervelden. Een agent die een uur lang draait met een verbruik van input_tokens: 4000 is niet goedkoop; de overige 200.000 tokens werden uit de cache geleverd. Gebruik de token-counting endpoint om verbruik te schatten voordat u een verzoek verzendt. Het aanroepen hiervan is gratis, het heeft een eigen rate limit en telt met de tokenizer van het door u opgegeven model (beschouw het resultaat als een nauwkeurige schatting; de facturatie is gebaseerd op het werkelijke verzoek):

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

Gebruik nooit tiktoken, vanwege de bovengenoemde reden.

Abonnementen versus pay-as-you-go

De werking in deze handleiding is overal identiek; alleen de afrekening verschilt. Met een API-key factureert Anthropic via pay-as-you-go, per token, tegen de gepubliceerde tarieven — elk getal hierboven vertegenwoordigt echt geld. Bij een Claude-abonnement (Pro, Max, Team, Enterprise) wordt het verbruik van Claude Code in plaats daarvan verrekend met de inclusieve limiet van uw abonnement. Sinds juli 2026 is dit een rollend venster van vijf uur plus een wekelijks venster, gedeeld tussen verschillende modellen en met de claude.ai chat. Het /usage dollarbedrag is informatief en geen factuurbedrag. Wanneer een venster is bereikt, ziet u de melding "You've hit your session limit" of "You've hit your weekly limit" met een resettijd. Het wisselen van model met /model herstelt de toegang niet, omdat de vensters over alle modellen worden gedeeld. Abonnementen kunnen optioneel verbruikskredieten inschakelen, te beheren via /usage-credits, om verbruik boven de limiet te kopen. Ik vermeld de quota van de abonnementen niet bewust: dit zijn de meest veranderlijke getallen in dit onderwerp. Raadpleeg in plaats daarvan claude.com/pricing en uw eigen /usage balken. De token-mechanica blijft relevant bij een abonnement — een inefficiënte sessie verbruikt uw limiet op exact dezelfde wijze als dollars. Zie welk Claude-abonnement bij uw verbruik past voor de abonnementen.

De effectieve methoden

• Beperk de leesomvang van de agent. "Fix de validatiefout in auth.py" leest één bestand; "verbeter deze codebase" leest er veertig. Houd CLAUDE.md beperkt — het wordt in elke sessie geladen, dus beperk het tot de essentie — en verplaats workflow-specifieke instructies naar skills die alleen op aanvraag worden geladen.
• Wees helder en compact. Gebruik /clear tussen ongerelateerde taken — verouderde context wordt bij elk volgend bericht opnieuw verzonden en gefactureerd. Binnen één langdurige taak vat /compact Focus on the failing tests and the diff de geschiedenis samen om de kosten exponentieel te beperken.
• Kies de juiste modelgrootte. Sonnet is geschikt voor de meeste programmeertaken tegen $2/$10 per miljoen tokens bij de introductieprijs in juli 2026 ($3/$15 standaard, versus Opus op $5/$25), en Haiku tegen $1/$5 is het juiste instrument voor mechanische subagent-taken zoals log-triage. /model wisselt tijdens de sessie.
• Filter uitgebreide output vooraf. Een hook die een testrun filtert tot alleen de fouten voordat Claude deze ziet, reduceert 20.000 tokens aan tool-resultaten naar 300. Dit gebeurt bij elke toekomstige verzending van die beurt.
• Verwerk niet-interactieve taken in batches. Voor eigen API-pipelines — zoals classificatie, bulk-review of nachtelijke taken — biedt de Batches API dezelfde modellen aan met 50% korting in ruil voor asynchrone levering.
• Houd rekening met de cache-tijd. Werk in aaneengesloten blokken. Een losstaande Claude Code sessie in tmux op een VPS kost niets tijdens inactiviteit — tokens worden alleen verbruikt wanneer een beurt wordt uitgevoerd — maar bij inactiviteit gaat de warme cache verloren en moet de volgende beurt de herschrijving betalen.

FAQ

Hoeveel tokens verbruikt een programmeersessie in Claude Code?

Er is geen vast aantal. Een enkele beurt halverwege een sessie bevat vaak tienduizenden prompt tokens zodra bestanden en historie zijn opgebouwd. Een actieve sessie verbruikt miljoenen tokens, waarvan de meeste via de cache tegen een tiende van het basistarief worden verwerkt. Ter kalibratie: de gepubliceerde enterprise-cijfers van Anthropic per juli 2026 bedragen gemiddeld $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 is nauwkeuriger dan elk gepubliceerd gemiddelde.

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

Ja. Thinking tokens worden gefactureerd als output tokens — het duurdere tarief — en tellen mee bij max_tokens. Huidige modellen factureren deze tokens zelfs wanneer de interface de samenvatting van de redenering niet weergeeft. Als een antwoord wordt afgebroken met stop_reason: "max_tokens" voordat het zichtbare antwoord klaar is, heeft het denkproces waarschijnlijk het budget verbruikt. Verlaag in Claude Code het niveau van inspanning met /effort voor taken die geen diepgaande redenering vereisen.

Waarom wordt een lange Claude Code sessie duurder per bericht?

Omdat de API stateless is: elke beurt stuurt de volledige conversatie opnieuw — elk gelezen bestand, tool-resultaat en vorig gesprek — als gefactureerde input. Hierdoor bevat beurt 50 de inhoud van beurten 1 tot en met 49. Prompt caching verwerkt de herhaalde prefix tegen ongeveer een tiende van de basisprijs voor input, maar de prefix blijft groeien. Als de cache TTL is verstreken, wordt de volgende beurt als een volledige rewrite gefactureerd. /compact verkleint de historie; /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 de limieten van uw abonnement (/cost is een alias); /context toont de inhoud van het venster. Gebruik voor officiële API-facturatie de usage-pagina in de Claude Console. Lees in uw eigen code response.usage — de som van input_tokens, cache_creation_input_tokens en cache_read_input_tokens geeft de werkelijke promptgrootte — en schat kosten vooraf in met de count_tokens endpoint, nooit met tiktoken.