Hvad koster LLM-inferens? 4 scenarier med rigtige tal

Hvad koster LLM-inferens? 4 scenarier med rigtige tal

GPT-4 kostede $30 pr. million input-tokens i marts 2023. Tre år senere kører GPT-5.6 den samme million for $10. Claude Opus 4.5 ligger på $15. Gulvet? To cent. Det er en 1.500x-forskel mellem den billigste og dyreste mulighed for den præcis samme enhed arbejde. LLM-inferenspris er den tilbagevendende regning, du betaler, hver gang en trænet model læser dit input og genererer et output, prissat pr. million tokens af alle store udbydere. Budgetmodeller kører $0,02-$0,30 pr. million input-tokens. Frontier-modeller tager $15-$75 for samme volumen. Forskellen betyder noget, fordi din arbejdsbyrde, ikke din ambition, afgør hvilket niveau du reelt har brug for.

Nøglepointer:

• Budgetmodeller koster $0,02-$0,30 pr. million input-tokens; frontier-modeller kører $15-$75 (juli 2026).
• Output-tokens koster 3-5x mere end input-tokens, fordi generering er sekventiel, ikke parallel.
• En support-chatbot med 50K samtaler koster cirka $9-$420/måned afhængigt af modelniveau.
• Inferenspriser er faldet ~10x om året; Gartner projicerer 90% lavere inden 2030.

Hvad koster LLM-inferens pr. million tokens?

LLM-inferensprissætning følger en tre-niveaus struktur pr. juli 2026. Budgetmodeller fra udbydere som Google (Gemini 2.5 Flash) og open-source-alternativer (Llama 4, Qwen 3) koster $0,02-$0,30 pr. million input-tokens. Mellemklasse-modeller (GPT-4.1, Claude Sonnet 4) lander mellem $0,55 og $15. Frontier-reasoningmodeller (o3, Claude Opus 4.5) koster $15-$75. Alle udbydere offentliggør disse satser på deres officielle prissider (OpenAI, Anthropic), og PricePerToken.com tracker 300+ modeller i et live-grid.

Pr. juli 2026 kan du køre en million input-tokens for så lidt som to cent, eller betale femoghalvfjerds dollar for den samme million på en frontier-model.

Cachelagret-input-rabatter skærer din regning 50-90% på gentagne prompts (prompt-caching skærer input-omkostninger forklarer mekanikken). For det live 300-model-grid med alle udbyderes aktuelle satser, se vores fulde token-pristabel.

Hvad driver LLM-inferenspris? De 4 komponenter

Din inferensregning deles i fire omkostningsdrivere: GPU-beregningstid pr. token, hukommelse til modelvægte og KV-cachen, input/output-asymmetrien der gør generering dyrere end læsning, og infrastruktur-overhead (strøm, køling, netværk). At forstå hvilken komponent der dominerer din arbejdsbyrde, fortæller dig hvor optimering betaler sig.

Beregning: GPU-tid pr. token

Hvert token passerer gennem hvert lag i modellen. En 70B-parameter-model på FP16 kræver cirka 140 GFLOPs pr. token. Kvantiseret til INT4 skærer det til ~35 GFLOPs. NVIDIAs inferens-benchmarkingguide gennemgår den fulde TCO-formel: hardwareafskrivning plus el plus driftsoverhead, divideret med betjente tokens.

Hukommelse: Modelvægte + KV-cache

En 70B-model på FP16 fylder ~140 GB VRAM bare til vægte. KV-cachen vokser med kontekstlængde og samtidig batchstørrelse. Ved 128K kontekst med 32 samtidige forespørgsler kan du brænde yderligere 80 GB af. Derfor betyder VRAM-krav pr. model så meget for self-hosting-beslutninger.

Input vs. output-asymmetri

Output-tokens koster 3-5x mere end input-tokens, fordi modellen genererer dem ét ad gangen, i rækkefølge. Den kan ikke parallelisere, som når den læser din prompt.

Her er den enkle version: at læse din 2.000-token prompt ("prefill"-fasen) behandler alle tokens simultant på tværs af GPU-kerner. At generere 500 output-tokens ("decode"-fasen) kører ét token pr. trin, hvor hvert afhænger af det foregående. GPU'en sidder mest inaktiv og venter på hukommelsesbåndbredde mellem trinnene. Den inaktive tid er det, du betaler for til 3-5x input-satsen.

Infrastruktur-overhead

Strøm, køling, netværk og de GPU'er der sidder inaktive mellem forespørgsler. Hugging Faces optimeringsdokumentation dækker hvordan continuous batching og speculative decoding presser flere tokens pr. GPU-time ud af det samme hardware, hvilket direkte skærer denne overhead-andel.

Hvad koster LLM-inferens for 4 rigtige arbejdsbyrder?

En typisk support-chatbot koster $9-$420/måned, en RAG-pipeline kører $168-$3.360/måned, en kodeassistent til 200 udviklere fakturerer $123-$2.078/måned, og batch-dokumentbehandling lander mellem $240 og $6.400/måned. Spredningen afhænger næsten udelukkende af modelniveauvalget. Vi byggede disse fire scenarier ud fra token-volumener fra vores klientimplementeringer, prissat mod officielle juli 2026-sider. Hvert dollarbeløb nedenfor er reproducerbart: angivne token-antagelser ganget med offentliggjorte satser. Vores analyse, ikke leverandørpåstande.

Kundesupport-chatbot: 50K samtaler/måned

Gennemsnitlig samtale: 800 input-tokens (systemprompt + brugerbeskeder + hentet kontekst), 400 output-tokens. Månedligt volumen: 50.000 samtaler = 40M input-tokens, 20M output-tokens.

• Budgetvalg (Gemini 2.5 Flash): 40M × $0,075/M + 20M × $0,30/M = $9/måned. Næsten mistænkeligt billigt.
• Mellemvalg (Claude Sonnet 4): 40M × $3/M + 20M × $15/M = $420/måned.

For en support-bot der håndterer tier-1-sager, klarer budgetmodellen 90% af forespørgslerne fint. Rut de svære 10% til mellemklasse med en klassificeringsmodel.

RAG-pipeline: 10K forespørgsler/dag

Gennemsnitlig forespørgsel: 3.200 input-tokens (hentede chunks + systemprompt + brugerquestion), 600 output-tokens. Månedligt: 300K forespørgsler = 960M input-tokens, 180M output-tokens.

• Budgetvalg (Llama 4 Scout via API): 960M × $0,10/M + 180M × $0,40/M = $168/måned.
• Mellemvalg (GPT-4.1): 960M × $2/M + 180M × $8/M = $3.360/måned.

RAG-arbejdsbyrden er input-tung, så cachelagret-input-rabatter slår hårdt her. Med 70% prompt-caching falder mellemklassen til ~$2.100/måned.

Kodeassistent: 200 udviklere

Gennemsnitlig session: 4.500 input-tokens (filkontekst + samtale), 1.200 output-tokens. Antag 15 forespørgsler/udvikler/dag, 22 arbejdsdage = 66.000 forespørgsler/måned = 297M input, 79M output.

• Budgetvalg (Qwen 3 32B): 297M × $0,20/M + 79M × $0,80/M = $123/måned.
• Mellemvalg (Claude Sonnet 4): 297M × $3/M + 79M × $15/M = $2.078/måned.

Udviklere mærker kvalitetsforskelle hurtigt. Til kode er mellemklasse som regel gulvet. Budgetmodeller fungerer til autofuldførelse-forslag, men kæmper med multi-fil refaktoreringer.

Batch-dokumentbehandling: 1M dokumenter/måned

Gennemsnitligt dokument: 2.000 input-tokens, 300 output-tokens (ekstraktion, klassificering, opsummering). Månedligt: 2B input, 300M output.

• Budgetvalg (Gemini 2.5 Flash): 2B × $0,075/M + 300M × $0,30/M = $240/måned.
• Mellemvalg (GPT-4.1): 2B × $2/M + 300M × $8/M = $6.400/måned.

Ved dette volumen er 27x-prisforskellen mellem niveauer en $6.160/måned-post. Budgetmodeller håndterer struktureret ekstraktion godt. Til hardware-dimensionering hvis du overvejer self-hosting af dette volumen, se VRAM-krav pr. 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 eller self-hosted: Hvornår vinder hver især?

API vinder under ~20K forespørgsler/dag, eller når dit team mangler ML-infrastrukturerfaring. Self-hosted vinder over 200K forespørgsler/dag med vedvarende GPU-udnyttelse over 50%. Break-even-punktet, ifølge Introls analyse, lander omkring 50-80K forespørgsler/dag for en 70B-klasse model på en enkelt H100-node. Under den tærskel slår API-udbyderens multi-tenant-effektivitet din single-tenant-hardware-matematik.

Hvornår API vinder

Du shipper på dage, ikke uger. Ingen ML-ingeniørløn ($180K-$250K/år), ingen vagtordning for GPU-nedbrud, ingen kapacitetsplanlægning. For de fleste teams under 50 ingeniører er API'en det korrekte udgangspunkt. Punktum.

Hvornår self-hosted vinder

Du har passeret 200K forespørgsler/dag, din arbejdsbyrde er forudsigelig, og du beskæftiger allerede ML-infrastrukturfolk. Open-source-modeller (Llama 4, Qwen 3, Mistral) kører på dit hardware til elpris plus afskrivning. vLLM vs SGLang-benchmarks viser throughput-forskelle på 15-30% afhængigt af arbejdsbyrdens form, hvilket betyder noget i denne skala.

Break-even-tallet

Self-hosted vinder kun over ~50% vedvarende GPU-udnyttelse. Under det betaler du for inaktivt silicium. De skjulte personaleomkostninger (ML-ingeniørtid, vagtordning, modelopdateringer, sikkerhedsrettelser) er den reelle grund til, at de fleste teams bliver på API, selv når den rå GPU-matematik ser fordelagtig ud. Hvis du self-hoster, fjerner implementering af modeller på Modal infrastrukturhåndteringslaget, mens token-priserne holdes under API-satser.

De skjulte omkostninger ingen budgetterer med

Rå token-forbrug er 60-80% af din reelle regning. Resten gemmer sig i seks poster, der aldrig dukker op i en priskalkulator. Budgettér med ekstra 20-40% oven i dit token-estimat for at dække dem.

• Overvågnings- og observabilitetsværktøjer: $200-$1.500/måned. Token-forbrugsdashboards, latenssporing, omkostningsattribuering pr. funktion. En LLM-observabilitetsstak betaler sig selv tilbage første gang, du fanger en prompt-regression, før den brænder dit budget af.
• Retry og fejl-genkørsler: 3-8% af forespørgsler fejler eller kræver retry (timeouts, rate limits, fejlformaterede outputs). Det er 3-8% af din token-regning, brugt på at producere ingenting.
• Prompt-engineering-iterationstimer: 20-60 timer pr. kvartal til $100-$200/time i belastet ingeniøromkostning. Hver prompt-justering genkører testbatches.
• Eval- og regressionstest: $100-$800/måned i token-forbrug til automatiserede eval-suites. Du betaler modellen for at bedømme sig selv.
• Multi-region redundans: 1,5-2x infrastrukturpris hvis du har brug for failover på tværs af regioner for latens eller compliance.
• Cold-start-latensstraffe: Serverless GPU-implementeringer (Modal, AWS Lambda) fakturerer for inaktiv tid. Cold starts tilføjer 2-8 sekunder og fakturerer dig for opvarmningen.

Tommelfingerreglen: gang dit rå token-estimat med 1,3 for et realistisk budget. Gang med 1,4 hvis du er i en reguleret branche med compliance-overhead.

Hvorfor bliver LLM-inferens ved med at blive billigere?

LLM-inferenspriser er faldet cirka 10x om året siden 2023. En arbejdsbyrde der kostede $1.000/måned i 2024, koster nærmere $100 i dag. Tre kræfter driver dette: hardwareforbedringer (NVIDIA Blackwell FP4, Google TPU v6), konkurrencepres (DeepSeek, open-source-modeller der tvinger priskrige), og softwareoptimering (speculative decoding, continuous batching, kvantisering). Gartner projikerer at inferensomkostninger falder yderligere 90% inden 2030, dog er det en projektion, ikke en garanti.

Epoch AIs prisovervågning dokumenterer dette fald med hårde datapunkter. a16z' "LLMflation"-analyse opfandt begrebet og indrammede de økonomiske implikationer: inferens deflaterer hurtigere end nogen tidligere beregningskategori.

Træning vs. inferenspris

Træning af en frontier-model kører $50M-$200M (engang). Inferens for den samme model, på tværs af alle brugere, kører $5M-$50M om året afhængigt af skala. For de fleste teams er forholdet 10-100x: træning koster 10-100 gange hvad ét års inferens koster. Men træning er en engangskapitaludgift. Inferens er den tilbagevendende driftsregning der vokser med brugervæksten. Du betaler ikke for træning, medmindre du bygger en fundamentmodel. Du betaler for inferens hver eneste dag.

Elregningen

En NVIDIA H100 trækker ~700W under belastning. Til $0,10/kWh (US-gennemsnit) er det $0,07 pr. GPU-time. En 70B-model på en enkelt H100 genererer cirka 2.000 output-tokens/sekund ved batch. Over én time: 7,2M tokens. Elpris pr. million output-tokens: ~$0,01. Vores beregning, markeret som sådan. Energi er 1-3% af din API-regning, men 8-15% af en self-hosted TCO. Det betyder mere hvis du kører dine egne GPU'er i en region med høj elpris (Tyskland til $0,30/kWh tredobler dette tal).

Den praktiske pointe: priserne falder hurtigt nok til, at en 12-måneders binding til et bestemt modelniveau er risikabel. Gen-evaluér kvartalsvis. 12 måder at skære din LLM-regning dækker taktiske træk du kan lave nu, mens makrotrenden gør det tunge arbejde.

Hvordan estimerer DU din inferenspris?

Estimér din månedlige LLM-inferenspris i fire trin: tæl tokens pr. forespørgsel, gang med månedligt volumen, anvend niveau-prissætning, tilføj derefter 20-40% overhead. I vores erfaring med at dimensionere inferensbudgetter for klienter, springer de fleste teams trin fire over og undrer sig over, hvorfor deres reelle regning overstiger estimatet med en tredjedel. Her er den proces vi bruger.

1. Tæl tokens pr. forespørgsel. Log dit gennemsnitlige input-tokenantal (systemprompt + kontekst + brugerbesked) og output-tokens (modelsvar) over 100+ reelle forespørgsler. Gæt ikke. Mål.
2. Gang med månedligt volumen. Forespørgsler/dag × 30 = månedlige forespørgsler. Gang med dit tokenantal pr. forespørgsel.
3. Anvend niveau-prissætning. Gang totale input-tokens med modellens $/M-input-sats. Samme for output. Summér dem.
4. Tilføj 20-40% overhead. Retries, evals, prompt-iteration, overvågning. Det er dette tal der skal i dit budget, ikke trin 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 kender dit tal, dirigerer LLM-gateway-værktøjer trafikken til den billigste model der klarer din kvalitetsgrænse. En gateway med modelvalg pr. forespørgsel kan skære din blandede pris 30-50% uden at røre dine prompts.

Ofte stillede spørgsmål

Er LLM-inferens dyrt?

Det afhænger af skala og modelvalg. En million input-tokens koster $0,02 på Gemini 2.5 Flash eller $75 på en frontier-reasoningmodel. For en lille app der behandler 10K forespørgsler/dag, forvent $50-$400/måned. For enterprise-arbejdsbyrder på 1M+ forespørgsler/dag kører budgetter $5.000-$40.000/måned. Enhedsprisen er lav; volumen får det til at løbe op.

Hvor meget er 1 million tokens i LLM?

Én million tokens svarer til cirka 750.000 ord, eller omkring 10 fuldlængde romaner. I juli 2026 koster behandling af 1M input-tokens $0,02 (budgetniveau) til $75 (frontierniveau). Output-tokens for samme volumen kører $0,06 til $300. De fleste produktionsarbejdsbyrder lander i mellemklassen: $2-$15 pr. million input-tokens.

Hvorfor er AI-inferens så dyrt?

Inferens kræver at køre hvert token gennem milliarder af modelparametre på GPU'er der koster $25.000-$40.000 hver. Decode-fasen genererer tokens sekventielt, hvilket efterlader GPU-kerner inaktive mellem trinnene. Du betaler for specialiseret hardware, el, køling og udbyderens ingeniørteam der holder serving-stakken kørende 24/7.

Falder AI-inferensomkostninger?

Ja, cirka 10x om året siden 2023. GPT-4 lanceredes til $30/$60 pr. million tokens (input/output). Tilsvarende kapacitet koster nu $2-$10. Epoch AIs data bekræfter denne bane på tværs af alle udbydere. Gartner projikerer yderligere 90% fald inden 2030, drevet af hardwareforbedringer og konkurrencepres fra open-source-modeller.

Hvad koster LLM-inferens i 2026?

Budgetmodeller: $0,02-$0,30 pr. million input-tokens. Mellemklasse: $0,55-$15. Frontier: $15-$75. En typisk produktionsarbejdsbyrde (support-chatbot, RAG-pipeline eller kodeassistent) koster $150-$4.000/måned på mellemklasse-modeller. Budgetmodeller håndterer højvolumen, lav-kompleksitets opgaver for 10-30x mindre.

Hvad er forskellen mellem træningspris og inferenspris?

Træning er engangsomkostningen ved at lære en model op fra bunden: $50M-$200M for en frontier-model, kræver tusindvis af GPU'er i måneder. Inferens er den tilbagevendende omkostning ved at bruge den trænede model: at køre input gennem den for at få outputs, faktureret pr. token. For de fleste teams er inferens den eneste regning de betaler. Træning er for virksomheder der bygger fundamentmodeller.

Hvordan beregner jeg LLM-inferenspris for min app?

Gang gennemsnitlige input-tokens pr. forespørgsel med dit månedlige forespørgselsvolumen, derefter med modellens $/M-input-sats. Gentag for output-tokens. Summér begge. Tilføj 30% til retries, evals og overvågnings-overhead. Python-uddragene i dette indlæg automatiserer matematikken. Mål reelle tokenantal i stedet for at gætte; logs fra 100+ forespørgsler giver et pålideligt gennemsnit.

Koster output-tokens mere end input-tokens?

Ja, typisk 3-5x mere. Inputbehandling (prefill) paralleliserer på tværs af alle tokens simultant og udnytter GPU-kerner fuldt ud. Outputgenerering (decode) producerer ét token ad gangen, hvor hvert afhænger af det foregående. GPU'en venter på hukommelsesbåndbredde mellem trinnene. Udbydere prissætter output højere for at afspejle denne lavere hardwareeffektivitet.

Er self-hosted inferens billigere end at bruge en API?

Kun over ~200K forespørgsler/dag med vedvarende GPU-udnyttelse over 50%. Under det slår API-udbydernes multi-tenant-effektivitet dit single-tenant-hardware. Self-hosting tilføjer også skjulte omkostninger: ML-ingeniørlønninger ($180K-$250K/år), vagtordninger, modelopdateringer og sikkerhedsrettelser. De fleste teams under 50 ingeniører bør blive på API.

Bruger LLM-inferens meget energi?

En H100-GPU trækker ~700W under belastning. Til $0,10/kWh er det $0,07/GPU-time, hvilket omsættes til cirka $0,01 pr. million output-tokens for en 70B-model. Energi er 1-3% af en API-regning, men 8-15% af self-hosted TCO. I regioner med høj elpris (Tyskland, $0,30/kWh) tredobles energiandelen og påvirker self-hosting-økonomien materielt.

Konklusion

Fire tal at huske: $0,02 (budgetgolv pr. million input-tokens), 3-5x (output-præmie over input), 20-40% (overhead at lægge oven i rå token-matematik), og 10x (årligt prisfald siden 2023). Din reelle regning afhænger af volumen, modelniveau og hvor aggressivt du cachelagrer, batcher og dirigerer trafik.

Hos Techsy dimensionerer vores team inferensbudgetter og vælger modelniveauer for B2B-klienter der kører produktions-LLM-arbejdsbyrder. Hvis du vil have et ekstra par øjne på din omkostningsmodel, få en gratis konsultation.