Wat kost LLM-inference? 4 scenario's met echte berekeningen

Wat kost LLM-inference? 4 scenario's met echte berekeningen

GPT-4 kostte in maart 2023 $30 per miljoen inputtokens. Drie jaar later verwerkt GPT-5.6 dezelfde miljoen voor $10. Claude Opus 4.5 zit op $15. De ondergrens? Twee cent. Tussen de goedkoopste en de duurste optie voor exact dezelfde eenheid werk zit een factor 1.500. LLM-inferencekosten zijn de terugkerende rekening die je betaalt elke keer dat een getraind model je input leest en output genereert, door elke grote provider geprijsd per miljoen tokens. Budgetmodellen kosten $0,02-$0,30 per miljoen inputtokens. Frontiermodellen vragen $15-$75 voor hetzelfde volume. Dat verschil doet ertoe, want je workload bepaalt welke klasse je nodig hebt, niet je ambitie.

De belangrijkste punten:

• Budgetmodellen kosten $0,02-$0,30 per miljoen inputtokens; frontiermodellen zitten op $15-$75 (juli 2026).
• Outputtokens kosten 3-5x meer dan inputtokens, omdat generatie sequentieel verloopt en niet parallel.
• Een supportchatbot met 50K gesprekken kost grofweg $9-$420 per maand, afhankelijk van de modelklasse.
• Inferenceprijzen dalen met ~10x per jaar; Gartner voorspelt 90% lager in 2030.

Wat kost LLM-inference per miljoen tokens?

LLM-inferenceprijzen volgen per juli 2026 een structuur met drie klassen. Budgetmodellen van providers als Google (Gemini 2.5 Flash) en open-source-opties (Llama 4, Qwen 3) kosten $0,02-$0,30 per miljoen inputtokens. Middenklasse-modellen (GPT-4.1, Claude Sonnet 4) zitten tussen $0,55 en $15. Frontier-redeneermodellen (o3, Claude Opus 4.5) vragen $15-$75. Elke provider publiceert deze tarieven op hun officiële prijspagina's (OpenAI, Anthropic), en PricePerToken.com volgt 300+ modellen in een live overzicht.

Per juli 2026 kun je een miljoen inputtokens verwerken voor twee cent, of $75 betalen voor dezelfde miljoen op een frontiermodel.

Cached-inputkortingen verlagen je rekening met 50-90% bij herhaalde prompts (promptcaching verlaagt de inputkosten legt het mechanisme uit). Voor het live overzicht van 300 modellen met de actuele tarieven van elke provider, zie onze volledige prijstabel per token.

Waaruit bestaan LLM-inferencekosten? De 4 componenten

Je inferencerekening valt uiteen in vier kostendrijvers: GPU-rekentijd per token, geheugen voor modelgewichten en de KV-cache, de input/outputasymmetrie die generatie duurder maakt dan lezen, en infrastructuuroverhead (stroom, koeling, netwerk). Weten welke component domineert in jouw workload vertelt je waar optimalisatie loont.

Compute: GPU-tijd per token

Elke token gaat door elke laag van het model. Een model met 70B parameters op FP16 heeft grofweg 140 GFLOPs per token nodig. Kwantiseren naar INT4 brengt dat terug tot ~35 GFLOPs. NVIDIA's benchmarkgids voor inference ontleedt de volledige TCO-formule: hardware-afschrijving plus stroom plus operationele overhead, gedeeld door het aantal verwerkte tokens.

Geheugen: modelgewichten + KV-cache

Een 70B-model op FP16 beslaat ~140 GB VRAM, alleen al voor de gewichten. De KV-cache groeit met de contextlengte en de gelijktijdige batchgrootte. Bij 128K context met 32 gelijktijdige requests verbrand je nog eens 80 GB. Daarom zijn VRAM-eisen per model zo bepalend voor zelf-hostbeslissingen.

Input- versus outputasymmetrie

Outputtokens kosten 3-5x meer dan inputtokens omdat het model ze één voor één genereert, in volgorde. Het kan niet paralleliseren zoals bij het lezen van je prompt.

De kale versie: het lezen van je prompt van 2.000 tokens (de "prefill"-fase) verwerkt alle tokens tegelijk over de GPU-kernen. Het genereren van 500 outputtokens (de "decode"-fase) draait één token per stap, waarbij elke token afhangt van de vorige. De GPU staat grotendeels stil te wachten op geheugenbandbreedte tussen stappen. Die stilstand is wat je betaalt tegen 3-5x het inputtarief.

Infrastructuuroverhead

Stroom, koeling, netwerk en de GPU's die stilstaan tussen requests. De optimalisatiedocs van Hugging Face behandelen hoe continuous batching en speculative decoding meer tokens per GPU-uur uit dezelfde hardware persen, en daarmee dit overheadaandeel direct verlagen.

Wat kost LLM-inference voor 4 echte workloads?

Een gemiddelde supportchatbot kost $9-$420 per maand, een RAG-pijplijn draait $168-$3.360 per maand, een code-assistent voor 200 ontwikkelaars kost $123-$2.078 per maand en batch-documentverwerking zit tussen $240 en $6.400 per maand. De spreiding hangt bijna volledig af van de modelklasse. We bouwden deze vier scenario's met tokenvolumes uit onze klantimplementaties, geprijsd tegen de officiële pagina's van juli 2026. Elk dollarbedrag hieronder is reproduceerbaar: genoemde tokenaannames vermenigvuldigd met gepubliceerde tarieven. Onze analyse, geen claims van vendors.

Klantenservice-chatbot: 50K gesprekken per maand

Gemiddeld gesprek: 800 inputtokens (systeemprompt + gebruikersberichten + opgehaalde context), 400 outputtokens. Maandvolume: 50.000 gesprekken = 40M inputtokens, 20M outputtokens.

• Budgetkeuze (Gemini 2.5 Flash): 40M × $0,075/M + 20M × $0,30/M = $9 per maand. Bijna verdacht goedkoop.
• Middenkeuze (Claude Sonnet 4): 40M × $3/M + 20M × $15/M = $420 per maand.

Voor een supportbot die tier-1-tickets afhandelt, kan het budgetmodel 90% van de vragen prima aan. Routeer de moeilijke 10% naar de middenklasse met een classifier.

RAG-pijplijn: 10K queries per dag

Gemiddelde query: 3.200 inputtokens (opgehaalde chunks + systeemprompt + gebruikersvraag), 600 outputtokens. Maandelijks: 300K queries = 960M inputtokens, 180M outputtokens.

• Budgetkeuze (Llama 4 Scout via API): 960M × $0,10/M + 180M × $0,40/M = $168 per maand.
• Middenkeuze (GPT-4.1): 960M × $2/M + 180M × $8/M = $3.360 per maand.

De RAG-workload is inputzwaar, dus cached-inputkortingen slaan hier hard toe. Met 70% promptcaching zakt de middenklasse naar ~$2.100 per maand.

Code-assistent: 200 ontwikkelaars

Gemiddelde sessie: 4.500 inputtokens (bestandscontext + conversatie), 1.200 outputtokens. Uitgaande van 15 requests per ontwikkelaar per dag, 22 werkdagen = 66.000 requests per maand = 297M input, 79M output.

• Budgetkeuze (Qwen 3 32B): 297M × $0,20/M + 79M × $0,80/M = $123 per maand.
• Middenkeuze (Claude Sonnet 4): 297M × $3/M + 79M × $15/M = $2.078 per maand.

Ontwikkelaars merken kwaliteitsverschillen snel. Voor code is de middenklasse meestal de ondergrens. Budgetmodellen werken voor autocomplete-stijl suggesties maar worstelen met refactors over meerdere bestanden.

Batch-documentverwerking: 1M documenten per maand

Gemiddeld document: 2.000 inputtokens, 300 outputtokens (extractie, classificatie, samenvatting). Maandelijks: 2B input, 300M output.

• Budgetkeuze (Gemini 2.5 Flash): 2B × $0,075/M + 300M × $0,30/M = $240 per maand.
• Middenkeuze (GPT-4.1): 2B × $2/M + 300M × $8/M = $6.400 per maand.

Bij dit volume is het prijsverschil van 27x tussen klassen een kostenpost van $6.160 per maand. Budgetmodellen kunnen gestructureerde extractie goed aan. Voor de hardware-dimensionering als je overweegt dit volume zelf te hosten, zie VRAM-eisen per model.

def monthly_cost(input_tokens, output_tokens, requests, price_in, price_out):
    """Estimate monthly LLM inference cost.
    
    Args:
        input_tokens: avg input tokens per request
        output_tokens: avg output tokens per request
        requests: monthly request volume
        price_in: $/M input tokens
        price_out: $/M output tokens
    """
    total_in = input_tokens * requests / 1_000_000
    total_out = output_tokens * requests / 1_000_000
    return (total_in * price_in) + (total_out * price_out)

# Example: support chatbot on Claude Sonnet 4
cost = monthly_cost(
    input_tokens=800,
    output_tokens=400,
    requests=50_000,
    price_in=3.00,
    price_out=15.00
)
print(f"${cost:,.2f}/month")  # $420.00/month

API of zelf hosten: wanneer wint wat?

API wint onder ~20K requests per dag of wanneer je team geen ML-infrastructuurervaring heeft. Zelf hosten wint boven 200K requests per dag met een aanhoudende GPU-benutting boven 50%. Het break-evenpunt ligt volgens de analyse van Introl rond 50-80K requests per dag voor een model van de 70B-klasse op één H100-node. Daaronder verslaat de multi-tenant-efficiency van de API-provider de rekensom van je single-tenant-hardware.

Wanneer API wint

Je bent in dagen live, niet in weken. Geen ML-engineersalaris ($180K-$250K per jaar), geen piketdienst voor GPU-storingen, geen capaciteitsplanning. Voor de meeste teams met minder dan 50 engineers is de API de juiste standaard. Punt.

Wanneer zelf hosten wint

Je bent voorbij 200K requests per dag, je workload is voorspelbaar en je hebt al ML-infrastructuurmensen in dienst. Open-source-modellen (Llama 4, Qwen 3, Mistral) draaien op jouw hardware tegen stroomkosten plus afschrijving. De vLLM vs SGLang-benchmarks laten throughputverschillen van 15-30% zien afhankelijk van de workloadvorm, en dat tikt aan op deze schaal.

Het break-evengetal

Zelf hosten wint pas boven ~50% aanhoudende GPU-benutting. Daaronder betaal je voor stilstaand silicium. De verborgen personeelskosten (tijd van ML-engineers, piket, modelupdates, beveiligingspatches) zijn de echte reden dat de meeste teams op de API blijven, zelfs wanneer de kale GPU-rekensom er gunstig uitziet. Als je wel zelf host, haalt modellen deployen op Modal de infrastructuurbeheerlaag weg terwijl de kosten per token onder de API-tarieven blijven.

De verborgen kosten waar niemand op begroot

Kale tokenuitgaven zijn 60-80% van je echte rekening. De rest verstopt zich in zes kostenposten die nooit in een prijscalculator verschijnen. Begroot 20-40% extra bovenop je tokenschatting om ze te dekken.

• Monitoring- en observability-tooling: $200-$1.500 per maand. Dashboards voor tokenverbruik, latentietracking, kostenattributie per feature. Een LLM-observabilitystack verdient zich terug zodra je voor het eerst een promptregressie vangt voordat die door je budget heen brandt.
• Retries en herhaalde mislukte runs: 3-8% van de requests faalt of moet opnieuw (timeouts, ratelimieten, misvormde outputs). Dat is 3-8% van je tokenrekening die niets oplevert.
• Iteratie-uren voor prompt-engineering: 20-60 uur per kwartaal tegen $100-$200 per uur volledig doorberekende engineeringkosten. Elke promptaanpassing draait testbatches opnieuw.
• Eval- en regressietests: $100-$800 per maand aan tokenverbruik voor geautomatiseerde eval-suites. Je betaalt het model om zichzelf te beoordelen.
• Multi-regio-redundantie: 1,5-2x infrastructuurkosten als je failover over regio's nodig hebt voor latentie of compliance.
• Koude-start-latentieboetes: Serverless GPU-deployments (Modal, AWS Lambda) rekenen stilstand door. Koude starts voegen 2-8 seconden toe en je betaalt voor het opwarmen.

De vuistregel: vermenigvuldig je kale tokenschatting met 1,3 voor een realistisch budget. Vermenigvuldig met 1,4 als je in een gereguleerde sector zit met compliance-overhead.

Waarom wordt LLM-inference steeds goedkoper?

LLM-inferenceprijzen dalen sinds 2023 met ruwweg 10x per jaar. Een workload die in 2024 $1.000 per maand kostte, kost nu eerder $100. Drie krachten drijven dit: hardwareverbeteringen (NVIDIA Blackwell FP4, Google TPU v6), concurrentiedruk (DeepSeek, open-source-modellen die prijsoorlogen afdwingen) en software-optimalisatie (speculative decoding, continuous batching, kwantisatie). Gartner voorspelt dat inferencekosten tegen 2030 nog eens 90% dalen, al is dat een projectie, geen garantie.

Prijsregistratie van Epoch AI documenteert deze daling met harde datapunten. De "LLMflation"-analyse van a16z bedacht de term en schetste de economische implicaties: de prijzen van inference dalen sneller dan in enige eerdere computecategorie.

Trainingskosten versus inferencekosten

Het trainen van een frontiermodel kost $50M-$200M (eenmalig). Inference voor datzelfde model, over alle gebruikers, kost $5M-$50M per jaar afhankelijk van de schaal. Voor de meeste teams is de verhouding 10-100x: training kost 10-100 keer wat één jaar inference kost. Maar training is een eenmalige kapitaaluitgave. Inference is de terugkerende operationele rekening die oploopt met gebruikersgroei. Je betaalt niet voor training tenzij je een foundation model bouwt. Je betaalt elke dag voor inference.

De energierekening

Een NVIDIA H100 verbruikt ~700W onder belasting. Bij $0,10/kWh (VS-gemiddelde) is dat $0,07 per GPU-uur. Een 70B-model op één H100 genereert bij batching grofweg 2.000 outputtokens per seconde. In één uur: 7,2M tokens. Stroomkosten per miljoen outputtokens: ~$0,01. Onze berekening, als zodanig gelabeld. Energie is 1-3% van je API-rekening maar 8-15% van een zelf-gehoste TCO. Het weegt zwaarder als je je eigen GPU's draait in een regio met hoge stroomprijzen (Duitsland op $0,30/kWh verdrievoudigt dit getal).

Praktisch gezien: prijzen dalen snel genoeg dat een commitment van 12 maanden aan een specifieke modelklasse riskant is. Herevalueer per kwartaal. De 12 manieren om je LLM-rekening te verlagen behandelen tactische zetten die je nu kunt maken terwijl de macrotrend het zware werk doet.

Hoe schat je JOUW inferencekosten in?

Schat je maandelijkse LLM-inferencekosten in vier stappen: tel tokens per request, vermenigvuldig met het maandvolume, pas de klassetarieven toe en tel daar 20-40% overhead bij op. Uit onze ervaring met het dimensioneren van inferencebudgets voor klanten weten we dat de meeste teams stap vier overslaan en zich afvragen waarom hun echte rekening een derde hoger uitvalt. Dit is het proces dat wij gebruiken.

1. Tel tokens per request. Log je gemiddelde inputtokens (systeemprompt + context + gebruikersbericht) en outputtokens (modelantwoord) over 100+ echte requests. Niet gokken. Meten.
2. Vermenigvuldig met het maandvolume. Requests per dag × 30 = maandelijkse requests. Vermenigvuldig met je tokenaantallen per request.
3. Pas de klassetarieven toe. Vermenigvuldig het totaal aantal inputtokens met het $/M-inputtarief van het model. Idem voor output. Tel op.
4. Tel 20-40% overhead erbij op. Retries, evals, promptiteratie, monitoring. Dit getal gaat je budget in, niet stap 3.

def estimate_monthly_budget(avg_input_tokens, avg_output_tokens,
                            requests_per_day, price_in, price_out,
                            overhead_pct=0.30):
    """Full monthly budget estimate with overhead."""
    monthly_requests = requests_per_day * 30
    raw_cost = monthly_cost(
        avg_input_tokens, avg_output_tokens,
        monthly_requests, price_in, price_out
    )
    return raw_cost * (1 + overhead_pct)

# RAG pipeline: 10K queries/day on GPT-4.1
budget = estimate_monthly_budget(
    avg_input_tokens=3200,
    avg_output_tokens=600,
    requests_per_day=10_000,
    price_in=2.00,
    price_out=8.00,
    overhead_pct=0.30
)
print(f"${budget:,.0f}/month")  # $4,368/month

Zodra je je getal kent, routen LLM-gatewaytools verkeer naar het goedkoopste model dat je kwaliteitsnorm haalt. Een gateway met modelselectie per request kan je gemengde kosten met 30-50% verlagen zonder je prompts aan te raken.

Veelgestelde vragen

Is LLM-inference duur?

Dat hangt af van schaal en modelkeuze. Een miljoen inputtokens kost $0,02 op Gemini 2.5 Flash of $75 op een frontier-redeneermodel. Voor een kleine app die 10K requests per dag verwerkt, reken op $50-$400 per maand. Voor enterprise workloads met 1M+ requests per dag lopen budgetten van $5.000-$40.000 per maand. De kosten per eenheid zijn laag; volume laat het oplopen.

Hoeveel is 1 miljoen tokens in een LLM?

Eén miljoen tokens staat gelijk aan grofweg 750.000 woorden, of ongeveer 10 volledige romans. In juli 2026 kost het verwerken van 1M inputtokens $0,02 (budgetklasse) tot $75 (frontierklasse). Outputtokens voor hetzelfde volume kosten $0,06 tot $300. De meeste productieworkloads zitten in de middenklasse: $2-$15 per miljoen inputtokens.

Waarom is AI-inference zo duur?

Inference vereist dat elke token door miljarden modelparameters op GPU's gaat die $25.000-$40.000 per stuk kosten. De decodefase genereert tokens sequentieel, waardoor GPU-kernen tussen stappen stilstaan. Je betaalt voor gespecialiseerde hardware, stroom, koeling en het engineeringteam van de provider dat de servingstack 24/7 draaiende houdt.

Dalen de kosten van AI-inference?

Ja, met ruwweg 10x per jaar sinds 2023. GPT-4 lanceerde op $30/$60 per miljoen tokens (input/output). Equivalente capaciteit kost nu $2-$10. De data van Epoch AI bevestigen dit traject bij alle providers. Gartner voorspelt nog eens 90% daling tegen 2030, gedreven door hardwareverbeteringen en concurrentiedruk van open-source-modellen.

Wat kost LLM-inference in 2026?

Budgetmodellen: $0,02-$0,30 per miljoen inputtokens. Middenklasse: $0,55-$15. Frontier: $15-$75. Een typische productieworkload (supportchatbot, RAG-pijplijn of code-assistent) kost $150-$4.000 per maand op middenklasse-modellen. Budgetmodellen handelen taken met een hoog volume en lage complexiteit af voor 10-30x minder.

Wat is het verschil tussen trainingskosten en inferencekosten?

Training is de eenmalige uitgave om een model from scratch te leren: $50M-$200M voor een frontiermodel, met duizenden GPU's maandenlang. Inference is de terugkerende kostenpost van dat getrainde model gebruiken: er input doorheen draaien om output te krijgen, per token gefactureerd. Voor de meeste teams is inference de enige rekening die ze betalen. Training is voor bedrijven die foundation models bouwen.

Hoe bereken ik LLM-inferencekosten voor mijn app?

Vermenigvuldig het gemiddeld aantal inputtokens per request met je maandelijkse requestvolume, en dan met het $/M-inputtarief van het model. Herhaal voor outputtokens. Tel beide op. Tel 30% op voor retries, evals en monitoringoverhead. De Python-snippets in dit artikel automatiseren de rekensom. Meet echte tokenaantallen in plaats van te gokken; logs van 100+ requests geven een betrouwbaar gemiddelde.

Kosten outputtokens meer dan inputtokens?

Ja, doorgaans 3-5x meer. Inputverwerking (prefill) paralleliseert over alle tokens tegelijk en benut GPU-kernen volledig. Outputgeneratie (decode) produceert één token tegelijk, waarbij elke token afhangt van de vorige. De GPU wacht tussen stappen op geheugenbandbreedte. Providers prijzen output hoger om deze lagere hardware-efficiency te weerspiegelen.

Is zelf gehoste inference goedkoper dan een API?

Alleen boven ~200K requests per dag met aanhoudende GPU-benutting boven 50%. Daaronder verslaat de multi-tenant-efficiency van API-providers je single-tenant-hardware. Zelf hosten voegt ook verborgen kosten toe: ML-engineersalarissen ($180K-$250K per jaar), piketdiensten, modelupdates en beveiligingspatches. De meeste teams met minder dan 50 engineers kunnen op de API blijven.

Verbruikt LLM-inference veel energie?

Een H100-GPU verbruikt ~700W onder belasting. Bij $0,10/kWh is dat $0,07 per GPU-uur, wat neerkomt op grofweg $0,01 per miljoen outputtokens voor een 70B-model. Energie is 1-3% van een API-rekening maar 8-15% van een zelf-gehoste TCO. In regio's met dure stroom (Duitsland, $0,30/kWh) verdrievoudigt het energieaandeel en beïnvloedt het de economie van zelf hosten materieel.

Onder de streep

Vier getallen om te onthouden: $0,02 (budgetondergrens per miljoen inputtokens), 3-5x (outputpremie op input), 20-40% (overhead bovenop de kale tokenrekensom) en 10x (jaarlijkse prijsdaling sinds 2023). Je echte rekening hangt af van volume, modelklasse en hoe agressief je cachet, batcht en verkeer routet.

Bij Techsy dimensioneert ons team inferencebudgets en kiest het modelklassen voor B2B-klanten die productie-LLM-workloads draaien. Als je een tweede paar ogen op je kostenmodel wilt, vraag dan een gratis consult aan.