Hva koster LLM-inferens? En gjennomgang av 4 scenarier med ekte utregninger

Hva koster LLM-inferens? En gjennomgang av 4 scenarier med ekte utregninger

GPT-4 kostet $30 per million inndatatokens i mars 2023. Tre år senere kjører GPT-5.6 den samme millionen for $10. Claude Opus 4.5 ligger på $15. Gulvet? To cent. Det er en forskjell på 1 500x mellom det billigste og det dyreste alternativet for nøyaktig samme arbeidsenhet. LLM-inferenskostnad er den løpende regningen du betaler hver gang en trent modell leser inndataene dine og genererer et svar, priset per million tokens hos alle store leverandører. Budsjettmodeller koster $0.02-$0.30 per million inndatatokens. Frontiermodeller tar $15-$75 for samme volum. Forskjellen betyr noe, fordi det er arbeidsbelastningen din, ikke ambisjonene dine, som avgjør hvilket nivå du faktisk trenger.

Nøkkelpoeng:

• Budsjettmodeller koster $0.02-$0.30 per million inndatatokens; frontiermodeller koster $15-$75 (juli 2026).
• Utdata-tokens koster 3-5x mer enn inndata-tokens, fordi generering skjer sekvensielt, ikke parallelt.
• En kundestøtte-chatbot med 50 000 samtaler koster omtrent $9-$420/måned, avhengig av modellnivå.
• Inferensprisene har falt ~10x per år; Gartner anslår 90 % lavere innen 2030.

Hva koster LLM-inferens per million tokens?

LLM-inferensprising følger en tre-nivå-struktur per juli 2026. Budsjettmodeller fra leverandører som Google (Gemini 2.5 Flash) og åpen kildekode-alternativer (Llama 4, Qwen 3) koster $0.02-$0.30 per million inndatatokens. Mellomsjiktmodeller (GPT-4.1, Claude Sonnet 4) lander mellom $0.55 og $15. Frontier-resonnementmodeller (o3, Claude Opus 4.5) ligger på $15-$75. Alle leverandører publiserer disse prisene på de offisielle prissidene sine (OpenAI, Anthropic), og PricePerToken.com sporer 300+ modeller i et live rutenett.

Per juli 2026 kan du kjøre en million inndatatokens for så lite som to cent, eller betale 75 dollar for den samme millionen på en frontiermodell.

Rabatter for bufret inndata kutter regningen 50-90 % på gjentatte prompter (prompt-bufring kutter inndatakostnadene forklarer mekanikken). For det live rutenettet med 300 modeller og alle leverandørenes gjeldende priser, se den fullstendige per-token-pristabellen vår.

Hva driver LLM-inferenskostnaden? De 4 komponentene

Inferensregningen din deles inn i fire kostnadsdrivere: GPU-beregningstid per token, minne for modellvekter og KV-cachen, inndata/utdata-asymmetrien som gjør generering dyrere enn lesing, og infrastrukturkostnader (strøm, kjøling, nettverk). Når du forstår hvilken komponent som dominerer arbeidsbelastningen din, vet du hvor optimalisering lønner seg.

Beregning: GPU-tid per token

Hvert token passerer gjennom hvert lag i modellen. En modell med 70B parametre i FP16 trenger omtrent 140 GFLOPs per token. Kvantiserer du til INT4, synker det til ~35 GFLOPs. NVIDIAs guide til inferens-benchmarking bryter ned den fulle TCO-formelen: maskinvareavskrivning pluss strøm pluss driftskostnader, delt på antall serverte tokens.

Minne: Modellvekter + KV-cache

En 70B-modell i FP16 bruker ~140 GB VRAM bare til vekter. KV-cachen vokser med kontekstlengden og den samtidige batchstørrelsen. Med 128K kontekst og 32 samtidige forespørsler kan du brenne av ytterligere 80 GB. Derfor betyr VRAM-krav per modell så mye for beslutninger om selvhosting.

Asymmetri mellom inndata og utdata

Utdata-tokens koster 3-5x mer enn inndata-tokens fordi modellen genererer dem ett om gangen, i rekkefølge. Den kan ikke parallelisere slik den leser prompten din.

Her er den enkle versjonen: Lesing av en 2 000-token prompt («prefill»-fasen) prosesserer alle tokens samtidig på tvers av GPU-kjernene. Generering av 500 utdata-tokens («decode»-fasen) kjører ett token per steg, der hvert token avhenger av det forrige. GPU-en står stort sett inaktiv og venter på minnebåndbredde mellom stegene. Det er den inaktive tiden du betaler for til 3-5x inndataraten.

Infrastrukturkostnader

Strøm, kjøling, nettverk og GPU-ene som står inaktive mellom forespørslene. Optimaliseringsdokumentasjonen til Hugging Face dekker hvordan kontinuerlig batching og spekulativ dekoding presser flere tokens per GPU-time ut av den samme maskinvaren, noe som kutter denne kostnadsandelen direkte.

Hva koster LLM-inferens for 4 reelle arbeidsbelastninger?

En typisk kundestøtte-chatbot koster $9-$420/måned, en RAG-pipeline kjører $168-$3,360/måned, en kodeassistent for 200 utviklere fakturerer $123-$2,078/måned, og batch-dokumentbehandling lander mellom $240 og $6,400/måned. Spredningen avhenger nesten utelukkende av valget av modellnivå. Vi bygde disse fire scenariene fra tokenvolumer fra kundeutrullingene våre, priset mot offisielle sider fra juli 2026. Alle dollartallene nedenfor er reproduserbare: oppgitte tokenantakelser multiplisert med publiserte priser. Analysen vår, ikke leverandørenes påstander.

Kundestøtte-chatbot: 50 000 samtaler/måned

Gjennomsnittlig samtale: 800 inndata-tokens (systemprompt + brukermeldinger + hentet kontekst), 400 utdata-tokens. Månedlig volum: 50 000 samtaler = 40M inndata-tokens, 20M utdata-tokens.

• Budsjettvalg (Gemini 2.5 Flash): 40M × $0.075/M + 20M × $0.30/M = $9/måned. Nesten mistenkelig billig.
• Mellomsjiktvalg (Claude Sonnet 4): 40M × $3/M + 20M × $15/M = $420/måned.

For en støtte-bot som håndterer nivå-1-saker, klarer budsjettmodellen 90 % av henvendelsene fint. Rut de vanskelige 10 % til mellomsjiktet med en klassifiserer.

RAG-pipeline: 10 000 forespørsler/dag

Gjennomsnittlig forespørsel: 3 200 inndata-tokens (hentede chunks + systemprompt + brukerspørsmål), 600 utdata-tokens. Månedlig: 300K forespørsler = 960M inndata-tokens, 180M utdata-tokens.

• Budsjettvalg (Llama 4 Scout via API): 960M × $0.10/M + 180M × $0.40/M = $168/måned.
• Mellomsjiktvalg (GPT-4.1): 960M × $2/M + 180M × $8/M = $3,360/måned.

RAG-arbeidsbelastningen er inndatatung, så rabatter for bufret inndata slår hardt inn her. Med 70 % prompt-bufring synker mellomsjiktet til ~$2,100/måned.

Kodeassistent: 200 utviklere

Gjennomsnittlig økt: 4 500 inndata-tokens (filkontekst + samtale), 1 200 utdata-tokens. Anta 15 forespørsler/utvikler/dag, 22 arbeidsdager = 66 000 forespørsler/måned = 297M inndata, 79M utdata.

• Budsjettvalg (Qwen 3 32B): 297M × $0.20/M + 79M × $0.80/M = $123/måned.
• Mellomsjiktvalg (Claude Sonnet 4): 297M × $3/M + 79M × $15/M = $2,078/måned.

Utviklere merker kvalitetsforskjeller raskt. For kode er mellomsjiktet vanligvis gulvet. Budsjettmodeller fungerer for autofullfør-forslag, men sliter med refaktorering på tvers av flere filer.

Batch-dokumentbehandling: 1M dokumenter/måned

Gjennomsnittlig dokument: 2 000 inndata-tokens, 300 utdata-tokens (uttrekk, klassifisering, oppsummering). Månedlig: 2B inndata, 300M utdata.

• Budsjettvalg (Gemini 2.5 Flash): 2B × $0.075/M + 300M × $0.30/M = $240/måned.
• Mellomsjiktvalg (GPT-4.1): 2B × $2/M + 300M × $8/M = $6,400/måned.

På dette volumet er prisgapet på 27x mellom nivåene en post på $6,160/måned. Budsjettmodeller håndterer strukturert uttrekk godt. For maskinvaredimensjonering hvis du vurderer å selvhoste dette volumet, sjekk VRAM-krav per modell.

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 eller selvhostet: Når lønner hver seg?

API vinner under ~20K forespørsler/dag, eller når teamet ditt mangler erfaring med ML-infrastruktur. Selvhostet vinner over 200K forespørsler/dag med vedvarende GPU-utnyttelse over 50 %. Break-even-punktet, ifølge analysen til Introl, lander rundt 50-80K forespørsler/dag for en modell i 70B-klassen på en enkelt H100-node. Under den tersken slår leverandørenes flerleietaker-effektivitet matematikken for din enkeltleietaker-maskinvare.

Når API vinner

Du shipper på dager, ikke uker. Ingen ML-ingeniørlønn ($180K-$250K/år), ingen vaktordning for GPU-feil, ingen kapasitetsplanlegging. For de fleste team med under 50 ingeniører er API det riktige standardvalget. Punktum.

Når selvhostet vinner

Du har passert 200K forespørsler/dag, arbeidsbelastningen er forutsigbar, og du har allerede ML-infrastrukturfolk ansatt. Åpen kildekode-modeller (Llama 4, Qwen 3, Mistral) kjører på maskinvaren din til strømkostnad pluss avskrivning. vLLM mot SGLang-benchmarkene viser gjennomstrømningsforskjeller på 15-30 % avhengig av arbeidsbelastningens form, noe som betyr noe på denne skalaen.

Break-even-tallet

Selvhostet lønner seg bare over ~50 % vedvarende GPU-utnyttelse. Under det betaler du for inaktiv silisium. De skjulte personalkostnadene (ML-ingeniørtid, vaktordning, modelloppdateringer, sikkerhetspatching) er den virkelige grunnen til at de fleste team blir på API selv når den rå GPU-matematikken ser gunstig ut. Hvis du først selvhoster, fjerner utrulling av modeller på Modal infrastrukturhåndteringslaget mens per-token-kostnadene holder seg under API-ratene.

De skjulte kostnadene ingen budsjetterer med

Rå tokenforbruk er 60-80 % av den virkelige regningen din. Resten gjemmer seg i seks poster som aldri dukker opp i en priskalkulator. Budsjetter med ekstra 20-40 % på toppen av tokenanslaget ditt for å dekke dem.

• Overvåking og observabilitetsverktøy: $200-$1,500/måned. Dashbord for tokenforbruk, latenssporing, kostnadsfordeling per funksjon. En observabilitetsstack for LLM betaler for seg selv første gang du fanger en prompt-regresjon før den brenner gjennom budsjettet ditt.
• Retries og feilkjøringer: 3-8 % av forespørslene feiler eller trenger retry (timeouts, ratebegrensninger, feilformede svar). Det er 3-8 % av tokenregningen din, brukt på å produsere ingenting.
• Itereringstimer for prompt-engineering: 20-60 timer per kvartal til $100-$200/time i belastet ingeniørkostnad. Hver promptjustering kjører testbatchene på nytt.
• Eval og regresjonstesting: $100-$800/måned i tokenforbruk for automatiske eval-suiter. Du betaler modellen for å gradere seg selv.
• Flerregionsredundans: 1.5-2x infrastrukturkostnad hvis du trenger failover på tvers av regioner for latens eller compliance.
• Straff for kaldstart-latens: Serverløse GPU-utrullinger (Modal, AWS Lambda) tar betalt for inaktiv tid. Kaldstarter legger til 2-8 sekunder og fakturerer deg for oppvarmingen.

Tommelfingerregelen: multipliser det rå tokenanslaget ditt med 1.3 for et realistisk budsjett. Multipliser med 1.4 hvis du er i en regulert bransje med compliance-kostnader.

Hvorfor blir LLM-inferens stadig billigere?

LLM-inferensprisene har falt omtrent 10x per år siden 2023. En arbeidsbelastning som kostet $1,000/måned i 2024, koster nærmere $100 i dag. Tre krefter driver dette: maskinvareforbedringer (NVIDIA Blackwell FP4, Google TPU v6), konkurransepress (DeepSeek, åpen kildekode-modeller som tvinger frem priskriger) og programvareoptimalisering (spekulativ dekoding, kontinuerlig batching, kvantisering). Gartner anslår at inferenskostnadene faller ytterligere 90 % innen 2030, men det er en prognose, ikke en garanti.

Prissporingen til Epoch AI dokumenterer denne nedgangen med harde datapunkter. «LLMflation»-analysen til a16z laget begrepet og rammet inn de økonomiske implikasjonene: inferens deflaterer raskere enn noen tidligere beregningskategori.

Treningskostnad mot inferenskostnad

Å trene en frontiermodell koster $50M-$200M (engangskostnad). Inferens for den samme modellen, på tvers av alle brukere, koster $5M-$50M per år avhengig av skala. For de fleste team er forholdet 10-100x: trening koster 10-100 ganger det ett år med inferens koster. Men trening er en engangs kapitalutgift. Inferens er den løpende driftsregningen som vokser med brukerveksten. Du betaler ikke for trening med mindre du bygger en grunnmodell. Du betaler for inferens hver eneste dag.

Strømposten

En NVIDIA H100 trekker ~700W under last. Til $0.10/kWh (US-gjennomsnitt) er det $0.07 per GPU-time. En 70B-modell på en enkelt H100 genererer omtrent 2 000 utdata-tokens/sekund i batch. På én time: 7.2M tokens. Strømkostnad per million utdata-tokens: ~$0.01. Beregningen vår, merket som sådan. Strøm er 1-3 % av API-regningen din, men 8-15 % av TCO-en for selvhostet. Det betyr mer hvis du kjører dine egne GPU-er i en region med høy strømpris (Tyskland med $0.30/kWh tredobler dette tallet).

Det praktiske poenget: prisene faller raskt nok til at en 12-måneders binding til et bestemt modellnivå er risikabelt. Reevaluer kvartalsvis. 12 måter å kutte LLM-regningen din dekker taktiske grep du kan ta nå, mens makrotrenden gjør grovarbeidet.

Hvordan estimerer DU inferenskostnaden din?

Estimer den månedlige LLM-inferenskostnaden din i fire steg: tell tokens per forespørsel, multipliser med månedlig volum, bruk nivåprising, og legg til 20-40 % overhead. I vår erfaring med å dimensjonere inferensbudsjetter for kunder, hopper de fleste team over steg fire og lurer på hvorfor den faktiske regningen overstiger anslaget med en tredjedel. Her er prosessen vi bruker.

1. Tell tokens per forespørsel. Logg gjennomsnittlige inndata-tokens (systemprompt + kontekst + brukermelding) og utdata-tokens (modellsvar) over 100+ reelle forespørsler. Ikke gjett. Mål.
2. Multipliser med månedlig volum. Forespørsler/dag × 30 = månedlige forespørsler. Multipliser med tokenantallet per forespørsel.
3. Bruk nivåprising. Multipliser totale inndata-tokens med modellens $/M-inndatarate. Samme for utdata. Summer dem.
4. Legg til 20-40 % overhead. Retries, evaler, promptiterering, overvåking. Det er dette tallet som skal inn i budsjettet ditt, ikke steg 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

Når du kjenner tallet ditt, ruter LLM-gateway-verktøy trafikken til den billigste modellen som klarer kvalitetskravet ditt. En gateway med modellvalg per forespørsel kan kutte den blandede kostnaden din 30-50 % uten å røre promptene dine.

Ofte stilte spørsmål

Er LLM-inferens dyrt?

Det avhenger av skala og modellvalg. En million inndata-tokens koster $0.02 på Gemini 2.5 Flash eller $75 på en frontier-resonnementmodell. For en liten app som prosesserer 10K forespørsler/dag, regn med $50-$400/måned. For enterprise-arbeidsbelastninger med 1M+ forespørsler/dag, ligger budsjettene på $5,000-$40,000/måned. Enhetskostnaden er lav; volumet får det til å løpe opp.

Hvor mye er 1 million tokens i en LLM?

Én million tokens tilsvarer omtrent 750 000 ord, eller rundt 10 fullverdige romaner. I juli 2026 koster prosessering av 1M inndata-tokens $0.02 (budsjett) til $75 (frontier). Utdata-tokens for samme volum koster $0.06 til $300. De fleste produksjonsarbeidsbelastninger lander i mellomsjiktet: $2-$15 per million inndata-tokens.

Hvorfor er AI-inferens så dyrt?

Inferens krever å kjøre hvert token gjennom milliarder av modellparametre på GPU-er som koster $25,000-$40,000 hver. Dekodingsfasen genererer tokens sekvensielt, og lar GPU-kjernene stå inaktive mellom stegene. Du betaler for spesialisert maskinvare, strøm, kjøling og leverandørens ingeniørteam som holder serveringsstacken i gang 24/7.

Faller AI-inferenskostnadene?

Ja, omtrent 10x per år siden 2023. GPT-4 lanserte med $30/$60 per million tokens (inndata/utdata). Tilsvarende kapasitet koster nå $2-$10. Dataene fra Epoch AI bekrefter denne banen på tvers av alle leverandører. Gartner anslår ytterligere 90 % nedgang innen 2030, drevet av maskinvareforbedringer og konkurransepress fra åpen kildekode-modeller.

Hvor mye koster LLM-inferens i 2026?

Budsjettmodeller: $0.02-$0.30 per million inndata-tokens. Mellomsjikt: $0.55-$15. Frontier: $15-$75. En typisk produksjonsarbeidsbelastning (kundestøtte-chatbot, RAG-pipeline eller kodeassistent) koster $150-$4,000/måned på mellomsjiktmodeller. Budsjettmodeller håndterer høyvolum-, lavkompleksitetsoppgaver for 10-30x mindre.

Hva er forskjellen mellom treningskostnad og inferenskostnad?

Trening er engangskostnaden ved å lære opp en modell fra bunnen av: $50M-$200M for en frontiermodell, som krever tusenvis av GPU-er i månedsvis. Inferens er den løpende kostnaden ved å bruke den trente modellen: kjøre inndata gjennom den for å få svar, fakturert per token. For de fleste team er inferens den eneste regningen de betaler. Trening er for selskaper som bygger grunnmodeller.

Hvordan beregner jeg LLM-inferenskostnad for appen min?

Multipliser gjennomsnittlige inndata-tokens per forespørsel med det månedlige forespørselsvolumet ditt, deretter med modellens $/M-inndatarate. Gjenta for utdata-tokens. Summer begge. Legg til 30 % for retries, evaler og overvåkings-overhead. Python-snuttene i dette innlegget automatiserer matematikken. Mål reelle tokenantall i stedet for å gjette; logger fra 100+ forespørsler gir et pålitelig gjennomsnitt.

Koster utdata-tokens mer enn inndata-tokens?

Ja, vanligvis 3-5x mer. Inndataprosessering (prefill) paralleliserer på tvers av alle tokens samtidig, og utnytter GPU-kjernene fullt ut. Utdata-generering (decode) produserer ett token om gangen, der hvert token avhenger av det forrige. GPU-en venter på minnebåndbredde mellom stegene. Leverandører priser utdata høyere for å gjenspeile denne lavere maskinvareeffektiviteten.

Er selvhostet inferens billigere enn å bruke et API?

Bare over ~200K forespørsler/dag med vedvarende GPU-utnyttelse over 50 %. Under det slår leverandørenes flerleietaker-effektivitet enkeltleietaker-maskinvaren din. Selvhosting legger også til skjulte kostnader: ML-ingeniørlønner ($180K-$250K/år), vaktordninger, modelloppdateringer og sikkerhetspatching. De fleste team med under 50 ingeniører bør bli på API.

Bruker LLM-inferens mye energi?

En H100-GPU trekker ~700W under last. Til $0.10/kWh er det $0.07/GPU-time, som oversettes til omtrent $0.01 per million utdata-tokens for en 70B-modell. Strøm er 1-3 % av en API-regning, men 8-15 % av TCO-en for selvhostet. I regioner med høy strømpris (Tyskland, $0.30/kWh) tredobles strømandelen og påvirker økonomien i selvhosting merkbart.

Bunnlinjen

Fire tall å huske: $0.02 (budsjettgulv per million inndata-tokens), 3-5x (utdatapåslag mot inndata), 20-40 % (overhead å legge på toppen av den rå tokenmatematikken) og 10x (årlig prisnedgang siden 2023). Den faktiske regningen din avhenger av volum, modellnivå og hvor aggressivt du bufrer, batcher og ruter trafikken.

Hos Techsy dimensjonerer teamet vårt inferensbudsjetter og velger modellnivåer for B2B-kunder som kjører LLM-arbeidsbelastninger i produksjon. Hvis du vil ha et ekstra blikk på kostnadsmodellen din, få en gratis konsultasjon.