Wat kost 1 miljoen tokens in Claude? API prijzen uitgelegd

Hoeveel kost 1M tokens in Claude?

1M tokens staat voor één miljoen tokens; dit is de eenheid waarin elke prijs voor de Claude API (application programming interface) wordt uitgedrukt. Er is geen vaste prijs voor, omdat input en output tegen verschillende tarieven worden gefactureerd en elk model zijn eigen tarieven hanteert. Per augustus 2026 kost één miljoen input-tokens $1 op Claude Haiku 4.5, $2 op Claude Sonnet 5 en $5 op Claude Opus 5.

Output is het duurdere deel. Bij elk huidig model is het output-tarief vijf keer zo hoog als het input-tarief, waardoor de verhouding tussen beide meer invloed heeft op uw factuur dan het algemene cijfer. Een applicatie die lange documenten verstuurt en korte antwoorden terugkrijgt, gedraagt zich heel anders dan een applicatie die lange antwoorden schrijft op basis van een korte prompt.

Deze pagina behandelt de eenheidseconomie: wat een token kost en hoe u een factuur inschat voordat u begint met bouwen. Voor informatie over waar de tokens daadwerkelijk blijven tijdens uw werkzaamheden, leest u waar de tokens blijven tijdens een Claude Code sessie.

Hoe 1M tokens eruitzien

Een token is een tekstfragment dat het model leest of schrijft. De globale richtlijn van Anthropic is één token per 4 tekens, of ongeveer 0,75 Engelse woorden. Eén miljoen tokens staat daarom gelijk aan ongeveer 750.000 woorden, of ruwweg 4 MB aan platte tekst.

Gepubliceerde schattingen voor veelvoorkomende invoer geven een beter beeld van de schaal.

[
  {
    "label": "Average web page (10 kB)",
    "tokens": "2,500"
  },
  {
    "label": "Documentation page (100 kB)",
    "tokens": "25,000"
  },
  {
    "label": "Research paper PDF (500 kB)",
    "tokens": "125,000"
  }
]

Bij deze verhoudingen staat 1M tokens gelijk aan ongeveer 400 gemiddelde webpagina's die één keer worden gelezen, of acht onderzoekspapers van die omvang. Het is één volledige scan van een middelgrote codebase, of een maand aan licht chatgebruik door één persoon.

Beschouw dit alles als een schatting. Code, JSON en tekst in andere talen dan het Engels bevatten minder woorden per token, waardoor de verhouding van 0,75 aan de optimistische kant is. Nog een factor beïnvloedt het aantal: Claude Opus 4.7 en later, inclusief Opus 5 en Sonnet 5, gebruiken een nieuwere tokenizer die ongeveer 30 procent meer tokens genereert voor dezelfde tekst dan Sonnet 4.6 en eerder. Claude Haiku 4.5 gebruikt de oudere tokenizer. Een telling die u op Haiku 4.5 heeft gemeten, onderschat dus het aantal voor Sonnet 5 bij identieke invoer, wat betekent dat een directe vergelijking van de prijs per miljoen over die grens heen niet representatief is. Tel dezelfde prompt voor beide modellen voordat u een besluit neemt.

Wat Claude per miljoen tokens in rekening brengt

[
  {
    "label": "Haiku 4.5",
    "input_usd": 1,
    "output_usd": 5
  },
  {
    "label": "Sonnet 5 (to 31 Aug 2026)",
    "input_usd": 2,
    "output_usd": 10
  },
  {
    "label": "Sonnet 5 (from 1 Sep 2026)",
    "input_usd": 3,
    "output_usd": 15
  },
  {
    "label": "Opus 5",
    "input_usd": 5,
    "output_usd": 25
  }
]

Claude Sonnet 5 hanteert tot 31 augustus 2026 een introductietarief van $2 voor input en $10 voor output. Vanaf 1 september 2026 geldt het standaardtarief: $3 voor input en $15 voor output. Claude Opus 5 kost $5 en $25. Eén model valt volledig buiten deze tabel: Claude Fable 5 staat genoteerd op $10 voor input en $50 voor output, dus of die tarieven de investering waard zijn hangt af van de taken waarvoor u het model inzet.

Tarieven wijzigen. Beschouw elk cijfer op deze pagina als een rekenvoorbeeld van augustus 2026 en controleer de actuele bedragen op de officiële prijspagina voordat u een budget goedkeurt.

Deze tarieven geven aan wat Claude kost, maar niet of het de goedkopere optie is voor uw werklast. In drie taken vergeleken op zowel Claude als ChatGPT ziet u bij welke API de kosten lager uitvallen.

De contextlengte heeft geen invloed op het tarief. Bij Claude 4.6 en later wordt het volledige contextvenster van 1M tokens gefactureerd tegen het standaardtarief; een verzoek van 900.000 tokens kost per token dus hetzelfde als een verzoek van 9.000 tokens. Een lange prompt kost meer omdat deze uit meer tokens bestaat; er is geen afzonderlijk tarief voor een lange context.

De berekening die een prijswijziging overleeft

Elke factuur bestaat uit twee vermenigvuldigingen en één optelling.

cost = (input_tokens  / 1,000,000) * input_rate
     + (output_tokens / 1,000,000) * output_rate

Geschreven als code die u kunt uitvoeren:

INPUT_RATE = 2.00    # USD per million input tokens, Sonnet 5, August 2026
OUTPUT_RATE = 10.00  # USD per million output tokens

def cost(input_tokens, output_tokens):
    return (input_tokens * INPUT_RATE + output_tokens * OUTPUT_RATE) / 1_000_000

print(f"{cost(4300, 400):.4f}")

Dit print 0.0126. Een verzoek dat 4,300 input tokens verstuurt en 400 output tokens terugkrijgt, kost ongeveer 1,3 cent op Sonnet 5. Houd de twee tarieven op één plek in uw code. Wanneer een prijs verandert, past u twee regels aan en elke schatting in uw systeem wordt automatisch bijgewerkt.

Een uitgewerkte schatting voor een echte applicatie

Neem een ondersteuningsassistent. De systeemprompt en de productdocumentatie beslaan 4.000 tokens. Deze worden bij elk verzoek meegestuurd, omdat de Messages API stateless is en het model niets onthoudt tussen aanroepen door. Een gebruikersvraag voegt ongeveer 300 tokens toe. Een antwoord bevat ongeveer 400 tokens. Dat is 4.300 input- en 400 output-tokens per verzoek.

Eén miljoen input-tokens staat gelijk aan ongeveer 232 verzoeken van dit formaat. Bij 1.000 verzoeken per dag verbruikt de applicatie dagelijks 4,3 miljoen input-tokens; "1M tokens" dekt dus minder dan zes uur aan verkeer.

[
  {
    "label": "Opus 5, list rates",
    "cost_per_1k_usd": "31.50"
  },
  {
    "label": "Sonnet 5, list rates",
    "cost_per_1k_usd": "12.60"
  },
  {
    "label": "Sonnet 5, Batch API",
    "cost_per_1k_usd": "6.30"
  },
  {
    "label": "Haiku 4.5, list rates",
    "cost_per_1k_usd": "6.30"
  },
  {
    "label": "Sonnet 5, warm prompt cache",
    "cost_per_1k_usd": "5.40"
  }
]

Bij Claude Opus 5 kost dat verkeer $31.50 per 1.000 verzoeken. Bij Sonnet 5 is dit $12.60. Overstappen op Claude Haiku 4.5 brengt de kosten op $6.30, en een actieve prompt cache op Sonnet 5 verlaagt dit verder naar $5.40.

Vermenigvuldig dit met 30 voor een maand aan dergelijk verkeer. Sonnet 5 kost tegen standaardtarieven ongeveer $378 per maand. Dezelfde applicatie met een actieve cache kost ongeveer $162. Uw modelkeuze en uw beslissing over caching zijn elk belangrijker dan welk tarief u ook zult onderhandelen bij dit volume. Welk model u moet gebruiken is een vraag op zich, en het goedkoopste model dat slaagt voor uw evaluaties wint: kiezen tussen Opus, Sonnet en Haiku behandelt hoe u dit op de juiste wijze test.

Prompt caching verlaagt de kosten voor herhaalde onderdelen

Die prefix van 4.000 tokens is bij elk verzoek identiek, en u betaalt telkens de volledige invoerprijs. Prompt caching slaat de verwerkte prefix op en brengt een gereduceerd tarief in rekening voor hergebruik.

Een cache-read kost 0,1 keer het basistarief voor invoer. Het schrijven naar de cache kost 1,25 keer het basistarief voor een levensduur van 5 minuten, of 2 keer het basistarief voor een levensduur van 1 uur. De cache van 5 minuten verdient zichzelf dus na één keer lezen terug, omdat het schrijven 0,25 extra kost terwijl elke leesactie 0,9 bespaart. De cache van 1 uur heeft twee leesacties nodig om quitte te spelen.

De eenvoudigste manier om dit in te schakelen is via één veld op het hoogste niveau:

curl https://api.anthropic.com/v1/messages \
  -H "content-type: application/json" \
  -H "x-api-key: $ANTHROPIC_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -d '{
    "model": "claude-opus-5",
    "max_tokens": 1024,
    "cache_control": {"type": "ephemeral"},
    "system": "You are a helpful assistant.",
    "messages": [
      {"role": "user", "content": "What are the key themes in Pride and Prejudice?"}
    ]
  }'

Lees vervolgens het usage-blok dat wordt geretourneerd:

{
  "usage": {
    "cache_creation_input_tokens": 5120,
    "cache_read_input_tokens": 1800,
    "input_tokens": 50,
    "output_tokens": 503
  }
}

Die drie invoertellers worden tegen drie verschillende tarieven gefactureerd en vormen samen uw werkelijke invoervolume: total_input_tokens = cache_read_input_tokens + cache_creation_input_tokens + input_tokens. Een kostenraming die alleen input_tokens leest, zal ernstig afwijken zodra caching is ingeschakeld.

Twee factoren zorgen ervoor dat een cache niet rendabel is, en beide falen zonder foutmelding.

De prefix moet byte-identiek zijn. Cache-lookup is een prefix-match; een tijdstempel of de naam van de gebruiker bovenaan uw system prompt zorgt er dus voor dat deze bij elk verzoek wijzigt. U betaalt dan telkens 1,25 keer de basisinvoer en leest nooit uit de cache. Het symptoom is dat cache_creation_input_tokens hoog blijft terwijl cache_read_input_tokens op 0 blijft staan. Plaats cache_control op het laatste blok waarvan de inhoud bij alle verzoeken gelijk is, en zet alles wat varieert daarna. Het wijzigen van uw tools-definities maakt de gehele cache daaronder ongeldig, omdat invalidatie de volgorde tools, dan system, dan messages volgt.

De prefix moet lang genoeg zijn. De minimale cachebare lengte is 512 tokens voor Opus 5, 1.024 voor Sonnet 5 en 4.096 voor Haiku 4.5. Een kortere prompt wordt niet gecachet en er wordt geen foutmelding geretourneerd. De prefix van 4.000 tokens in het bovenstaande voorbeeld wordt gecachet op Sonnet 5, maar niet op Haiku 4.5, omdat 4.000 onder de ondergrens van dat model ligt. Wanneer beide tellers op 0 staan, is er niets gecachet.

Batchverwerking halveert het tarief

De Batch API verwerkt verzoeken asynchroon tegen een korting van 50 procent op zowel input als output. In het bovenstaande voorbeeld verandert dit $12.60 per 1.000 verzoeken in $6.30. De korting is cumulatief met prompt caching, waardoor een gecachte batch-job de goedkoopste manier is om bulkwerk uit te voeren.

Wat u inlevert is latentie, waardoor batchverwerking ongeschikt is voor processen waarbij een gebruiker moet wachten op een resultaat. Het is geschikt voor classificatietaken die 's nachts worden uitgevoerd en het verwerken van achterstanden in documentatie.

Waarom chatkosten toenemen binnen één gesprek

Omdat de API geen status bijhoudt, verstuurt uw client bij elke beurt het volledige gesprek opnieuw. Het tokenverbruik binnen één chat groeit daarom kwadratisch met de lengte ervan, en niet lineair.

Neem beurten die gemiddeld 500 tokens bevatten. Beurt 1 verstuurt 500 input-tokens. Beurt 2 verstuurt 1.000. Beurt 20 verstuurt 10.000. Als u dit optelt met n(n+1)/2, dan heeft een gesprek van 20 beurten ongeveer 105.000 input-tokens verstuurd, terwijl het transcript zelf slechts 10.000 tokens lang is.

Dit is de reden waarom een chatfunctie meer kost dan het transcript doet vermoeden, en waarom het cachen van het stabiele voorvoegsel of het samenvatten van oudere beurten zichzelf terugbetaalt bij lange threads. Een agent die lussen uitvoert over tool-aanroepen vertoont hetzelfde patroon, en zelfs erger: elk resultaat van een tool blijft in de geschiedenis staan en wordt bij elke latere beurt opnieuw verstuurd. Het instellen van een strikte bestedingslimiet voor een agent die u zelf draait is hierbij cruciaal, omdat deze groei automatisch verloopt en niemand toezicht houdt op het verbruik.

Tel de tokens voordat u een schatting maakt

Stop met het afleiden van aantallen tokens uit het aantal woorden. De API telt deze voor u, zonder extra kosten en met een rate limit die losstaat van het aanmaken van berichten.

curl https://api.anthropic.com/v1/messages/count_tokens \
  -H "x-api-key: $ANTHROPIC_API_KEY" \
  -H "content-type: application/json" \
  -H "anthropic-version: 2023-06-01" \
  -d '{
    "model": "claude-opus-5",
    "system": "You are a scientist",
    "messages": [{
      "role": "user",
      "content": "Hello, Claude"
    }]
  }'

Het antwoord bevat één veld:

{ "input_tokens": 14 }

Voer hier uw werkelijke systeem-prompt en tooldefinities in, samen met een representatief gebruikersbericht, en plaats het getal vervolgens in de bovenstaande kostenfunctie. Het endpoint accepteert dezelfde body als een berichtaanvraag, waardoor afbeeldingen en PDF's ook correct worden meegeteld. Twee kanttekeningen zijn van belang. De telling is een schatting en kan licht afwijken van het gefactureerde cijfer. Bovendien wordt de meting uitgevoerd met de tokenizer van het model dat u doorgeeft; gebruik dus het model dat u daadwerkelijk gaat draaien.

Output-tokens kunnen niet vooraf worden geteld, omdat deze nog niet bestaan. Begrens deze met max_tokens en meet vervolgens de werkelijke distributie op basis van usage.output_tokens bij live verkeer.

Waaruit de factuur verder bestaat

Tokens vormen het grootste deel van de factuur. Enkele posten zijn echter geen tokens, wat vaak tot verrassingen leidt.

• Tooldefinities worden bij elk verzoek als input-tokens meegeteld. Alleen al het systeem-prompt voor toolgebruik voegt 286 tot 406 tokens toe op Opus 5, nog voordat uw eigen schema's worden meegerekend. Tien uitgebreide toolbeschrijvingen kunnen een klein prompt verdubbelen.
• Webzoekopdrachten worden gefactureerd tegen $10 per 1.000 zoekopdrachten, bovenop de tokens die de resultaten verbruiken wanneer deze in de context worden geladen.
• Web-fetches brengen geen eigen kosten met zich mee, maar de opgehaalde pagina wordt wel als input-tokens geteld. Een documentatiepagina van 100 kB staat ongeveer gelijk aan 25,000 tokens.
• Het verzoeken van inferentie die uitsluitend in de VS plaatsvindt met inference_geo op Claude 4.6 en later, past een vermenigvuldigingsfactor van 1,1 toe op elke tokencategorie, inclusief cache-reads en -writes.

Of de API de juiste keuze is, hangt af van uw volume. Het bereiken van een gebruikslimiet binnen een abonnement is meestal de aanleiding voor deze vraag, en de routes om een limiet te omzeilen variëren van wachten tot de periode is verstreken tot het verplaatsen van die werklast naar API-aanroepen op basis van verbruik. Onder een bepaald gebruiksniveau is een vast maandelijks abonnement voordeliger, en de API afgezet tegen een Claude-abonnement voert die vergelijking uit met werkelijke cijfers.

FAQ

Wat kost 1M tokens in Claude?

Dit hangt af van het model en of het om input- of output-tokens gaat. Per augustus 2026 kost één miljoen input-tokens $1 op Claude Haiku 4.5, $2 op Claude Sonnet 5 onder het introductietarief, en $5 op Claude Opus 5. Output kost vijf keer het inputtarief voor elk van deze modellen. Sonnet 5 wijzigt per 1 september 2026 naar $3 voor input en $15 voor output. Tarieven wijzigen, dus controleer deze op de officiële prijspagina voordat u een bedrag in een budget opneemt.

Is 1M tokens hetzelfde als 1M woorden?

Nee. Eén token staat ongeveer gelijk aan 4 tekens in het Engels, of ongeveer 0,75 woorden; één miljoen tokens is dus ongeveer 750.000 woorden. Deze verhouding is slechts een richtlijn. Code, JSON en andere talen dan Engels gebruiken meer tokens per woord. Claude Opus 4.7 en later gebruiken bovendien een nieuwere tokenizer die ongeveer 30 procent meer tokens genereert voor identieke tekst dan Claude Sonnet 4.6 en eerder, waardoor aantallen niet uitwisselbaar zijn tussen modelgeneraties. Meet met het gratis /v1/messages/count_tokens-eindpunt door het model door te geven dat u van plan bent te gebruiken.

Bespaart prompt caching altijd geld?

Nee. Een cache-schrijfactie van 5 minuten kost 1,25 keer het standaard inputtarief; een prefix die wordt geschreven maar nooit wordt gelezen, kost dus 25 procent meer dan deze simpelweg meesturen. Het verdient zichzelf terug vanaf de eerste leesactie. Het faalt op twee manieren, beide zonder foutmelding. Als de gecachte prefix wijzigt tussen verzoeken, vindt er nooit een match plaats, omdat het een exacte prefix-match betreft. Als de prefix korter is dan de minimale cachebare lengte van het model, wat 1.024 tokens is op Sonnet 5 en 4.096 op Haiku 4.5, wordt er niets gecachet en wordt er geen foutmelding geretourneerd. Wanneer cache_creation_input_tokens en cache_read_input_tokens beide 0 lezen, doet de cache niets.

Waarom groeide mijn factuur sneller dan mijn aantal berichten?

Omdat het volledige gesprek bij elke beurt opnieuw wordt verzonden. De Messages API houdt geen status bij, dus beurt 20 van een chat bevat alle 19 eerdere beurten opnieuw als input. Bij beurten van gemiddeld 500 tokens verstuurt een gesprek van 20 beurten ongeveer 105.000 input-tokens, terwijl het transcript slechts 10.000 tokens lang is. Agent-loops gedragen zich op dezelfde manier, omdat elk resultaat van een tool in de geschiedenis blijft staan. Cache de stabiele prefix, of vat oudere beurten samen en verwijder deze uit het verzoek.