Vad kostar LLM-inferens? En 4-scenariogenomgång med riktig matte

Vad kostar LLM-inferens? En 4-scenariogenomgång med riktig matte

GPT-4 kostade $30 per miljon inputtokens i mars 2023. Tre år senare kör GPT-5.6 samma miljon för $10. Claude Opus 4.5 ligger på $15. Golvet? Två cent. Det är en spridning på 1 500x mellan det billigaste och det dyraste alternativet för exakt samma arbetsenhet. Kostnad för LLM-inferens är den återkommande räkning du betalar varje gång en tränad modell läser din input och genererar en output, prissatt per miljon tokens av alla stora leverantörer. Budgetmodeller kostar $0,02–0,30 per miljon inputtokens. Frontiermodeller tar $15–75 för samma volym. Gapet spelar roll eftersom din arbetslast, inte din ambition, avgör vilken klass du faktiskt behöver.

Det viktigaste i korthet:

• Budgetmodeller kostar $0,02–0,30 per miljon inputtokens; frontiermodeller ligger på $15–75 (juli 2026).
• Outputtokens kostar 3–5x mer än inputtokens eftersom generering sker sekventiellt, inte parallellt.
• En supportchattbot med 50 000 konversationer kostar ungefär $9–420/månad beroende på modellklass.
• Inferenspriserna har sjunkit ~10x per år; Gartner spår 90 % lägre till 2030.

Hur mycket kostar LLM-inferens per miljon tokens?

Prissättning av LLM-inferens följer en struktur med tre klasser från och med juli 2026. Budgetmodeller från leverantörer som Google (Gemini 2.5 Flash) och alternativ med öppen källkod (Llama 4, Qwen 3) kostar $0,02–0,30 per miljon inputtokens. Modeller i mellanklassen (GPT-4.1, Claude Sonnet 4) landar mellan $0,55 och $15. Resonerande frontiermodeller (o3, Claude Opus 4.5) ligger på $15–75. Alla leverantörer publicerar dessa priser på sina officiella prissidor (OpenAI, Anthropic), och PricePerToken.com spårar över 300 modeller i ett live-rutnät.

Från och med juli 2026 kan du köra en miljon inputtokens för så lite som två cent, eller betala sjuttiofem dollar för samma miljon på en frontiermodell.

Rabatter för cachad input sänker din räkning med 50–90 % vid upprepade prompter (prompt-cachning sänker inputkostnader förklarar mekaniken). För det live-uppdaterade 300-modellsrutnätet med alla leverantörers aktuella priser, se vår fullständiga prisjämförelse per token.

Vad driver kostnaden för LLM-inferens? De 4 komponenterna

Din inferensräkning delas upp i fyra kostnadsdrivare: GPU-beräkningstid per token, minne för modellvikter och KV-cachen, input/output-asymmetrin som gör generering dyrare än läsning, samt infrastruktur-overhead (el, kylning, nätverk). Att förstå vilken komponent som dominerar din arbetslast visar var optimering lönar sig.

Beräkning: GPU-tid per token

Varje token passerar genom varje lager i modellen. En 70B-parametermodell i FP16 behöver ungefär 140 GFLOPS per token. Kvantisering till INT4 sänker det till ~35 GFLOPS. NVIDIAS guide för inferensbenchmarking bryter ner den fullständiga TCO-formeln: hårdvaruavskrivning plus el plus drifts-overhead, dividerat med serverade tokens.

Minne: modellvikter + KV-cache

En 70B-modell i FP16 tar ~140 GB VRAM bara för vikterna. KV-cachen växer med kontextlängden och den samtidiga batchstorleken. Vid 128K kontext med 32 samtidiga förfrågningar kan du bränna ytterligare 80 GB. Det är därför VRAM-krav per modell spelar så stor roll för beslut om egenhostning.

Asymmetri mellan input och output

Outputtokens kostar 3–5x mer än inputtokens eftersom modellen genererar dem en i taget, i ordning. Den kan inte parallellisera på samma sätt som när den läser din prompt.

Här är den raka versionen: att läsa din 2 000-tokenprompt ("prefill"-fasen) bearbetar alla tokens samtidigt över GPU-kärnorna. Att generera 500 outputtokens ("decode"-fasen) kör en token per steg, där varje token beror på den föregående. GPU:t står mest stilla och väntar på minnesbandbredd mellan stegen. Den overksamma tiden är vad du betalar för till 3–5x inputpriset.

Infrastruktur-overhead

El, kylning, nätverk och de GPU:er som står overksamma mellan förfrågningarna. Hugging Faces optimeringsdokumentation täcker hur kontinuerlig batchning och spekulativ avkodning pressar ut fler tokens per GPU-timme ur samma hårdvara, vilket direkt sänker denna overhead-andel.

Vad kostar LLM-inferens för 4 riktiga arbetslaster?

En typisk supportchattbot kostar $9–420/månad, en RAG-pipeline kör $168–3 360/månad, ett kodbiträde för 200 utvecklare fakturerar $123–2 078/månad och batchdokumentbearbetning landar mellan $240 och $6 400/månad. Spridningen beror nästan helt på valet av modellklass. Vi byggde dessa fyra scenarier från tokenvolymer i våra kundleveranser, prissatta mot officiella sidor från juli 2026. Varje dollarsiffra nedan är reproducerbar: angivna token-antaganden multiplicerade med publicerade priser. Vår analys, inte leverantörernas påståenden.

Supportchattbot: 50 000 konversationer/månad

Genomsnittlig konversation: 800 inputtokens (systemprompt + användarmeddelanden + hämtad kontext), 400 outputtokens. Månadsvolym: 50 000 konversationer = 40 M inputtokens, 20 M outputtokens.

• Budgetval (Gemini 2.5 Flash): 40 M × $0,075/M + 20 M × $0,30/M = $9/månad. Nästan misstänkt billigt.
• Mellanval (Claude Sonnet 4): 40 M × $3/M + 20 M × $15/M = $420/månad.

För en supportbot som hanterar nivå-1-ärenden klarar budgetmodellen 90 % av frågorna fint. Routa de svåra 10 % till mellanklassen med en klassificerare.

RAG-pipeline: 10 000 förfrågningar/dag

Genomsnittlig förfrågan: 3 200 inputtokens (hämtade chunkar + systemprompt + användarfråga), 600 outputtokens. Månadsvis: 300 000 förfrågningar = 960 M inputtokens, 180 M outputtokens.

• Budgetval (Llama 4 Scout via API): 960 M × $0,10/M + 180 M × $0,40/M = $168/månad.
• Mellanval (GPT-4.1): 960 M × $2/M + 180 M × $8/M = $3 360/månad.

RAG-arbetslasten är inputtung, så rabatter för cachad input slår hårt här. Med 70 % prompt-cachning sjunker mellanklassen till ~$2 100/månad.

Kodbiträde: 200 utvecklare

Genomsnittlig session: 4 500 inputtokens (filkontext + konversation), 1 200 outputtokens. Anta 15 förfrågningar/utvecklare/dag, 22 arbetsdagar = 66 000 förfrågningar/månad = 297 M input, 79 M output.

• Budgetval (Qwen 3 32B): 297 M × $0,20/M + 79 M × $0,80/M = $123/månad.
• Mellanval (Claude Sonnet 4): 297 M × $3/M + 79 M × $15/M = $2 078/månad.

Utvecklare märker kvalitetsskillnader snabbt. För kod är mellanklassen oftast golvet. Budgetmodeller fungerar för autokompletteringsförslag men kämpar med refaktorering över flera filer.

Batchdokumentbearbetning: 1 M dokument/månad

Genomsnittligt dokument: 2 000 inputtokens, 300 outputtokens (extraktion, klassificering, sammanfattning). Månadsvis: 2 miljarder input, 300 M output.

• Budgetval (Gemini 2.5 Flash): 2 miljarder × $0,075/M + 300 M × $0,30/M = $240/månad.
• Mellanval (GPT-4.1): 2 miljarder × $2/M + 300 M × $8/M = $6 400/månad.

Vid den här volymen är prisskillnaden på 27x mellan klasserna en $6 160/månad-post. Budgetmodeller klarar strukturerad extraktion bra. För hårdvarudimensionering om du funderar på att egenhosta den här volymen, kolla 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 egenhostat: när vinner vardera?

API vinner under ~20 000 förfrågningar/dag eller när ditt team saknar erfarenhet av ML-infrastruktur. Egenhostat vinner över 200 000 förfrågningar/dag med ett ihållande GPU-utnyttjande över 50 %. Break-even-punkten, enligt Introls analys, landar runt 50 000–80 000 förfrågningar/dag för en 70B-klassmodell på en enda H100-nod. Under den tröskeln slår API-leverantörens effektivitet i en fleranvändarmiljö din matematik för en ensam användare.

När API vinner

Du levererar på dagar, inte veckor. Ingen ML-ingenjörslön ($180 000–250 000/år), ingen jourtur för GPU-fel, ingen kapacitetsplanering. För de flesta team under 50 ingenjörer är API rätt standardval. Punkt.

När egenhostat vinner

Du har passerat 200 000 förfrågningar/dag, din arbetslast är förutsägbar och du har redan ML-infrastrukturfolk anställda. Modeller med öppen källkod (Llama 4, Qwen 3, Mistral) kör på din hårdvara till elkostnad plus avskrivning. vLLM vs SGLang-benchmarkerna visar skillnader i genomströmning på 15–30 % beroende på arbetslastens form, vilket spelar roll i den här skalan.

Break-even-siffran

Egenhostat vinner bara över ~50 % ihållande GPU-utnyttjande. Under det betalar du för overksam kisel. De dolda personalkostnaderna (ML-ingenjörstid, jour, modelluppdateringar, säkerhetspatchning) är den verkliga anledningen till att de flesta team stannar på API även när den råa GPU-matematiken ser gynnsam ut. Om du egenhostar tar driftsättning av modeller på Modal bort infrastrukturhanteringslagret samtidigt som kostnaden per token hålls under API-priser.

De dolda kostnaderna ingen budgeterar för

De råa tokenutgifterna är 60–80 % av din verkliga räkning. Resten gömmer sig i sex poster som aldrig dyker upp i en priskalkylator. Budgetera ytterligare 20–40 % utöver din tokenuppskattning för att täcka dem.

• Verktyg för övervakning och observerbarhet: $200–1 500/månad. Dashboards för tokenanvändning, latensspårning, kostnadsattribuering per funktion. En LLM-observerbarhetsstack betalar för sig själv första gången du fångar en prompt-regression innan den bränner igenom din budget.
• Omkörningar vid fel och retries: 3–8 % av förfrågningarna misslyckas eller behöver köras om (timeouter, hastighetsbegränsningar, felaktig output). Det är 3–8 % av din tokenräkning, spenderad på att producera ingenting.
• Iterationstimmar för prompt-engineering: 20–60 timmar per kvartal till $100–200/timme i fullt belastad ingenjörskostnad. Varje prompt-justering kör om testbatcher.
• Eval och regressionstestning: $100–800/månad i tokenutgifter för automatiserade eval-sviter. Du betalar modellen för att betygsätta sig själv.
• Flerregionsredundans: 1,5–2x infrastrukturkostnad om du behöver redundans mellan regioner för latens eller efterlevnad.
• Kallstartslatens: Serverlösa GPU-driftsättningar (Modal, AWS Lambda) tar betalt för overksam tid. Kallstarter lägger till 2–8 sekunder och fakturerar dig för uppvärmningen.

Tumregeln: multiplicera din råa tokenuppskattning med 1,3 för en realistisk budget. Multiplicera med 1,4 om du är i en reglerad bransch med efterlevnads-overhead.

Varför fortsätter LLM-inferens att bli billigare?

LLM-inferenspriserna har sjunkit ungefär 10x per år sedan 2023. En arbetslast som kostade $1 000/månad 2024 kostar närmare $100 i dag. Tre krafter driver detta: hårdvaruförbättringar (NVIDIA Blackwell FP4, Google TPU v6), konkurrenstryck (DeepSeek, modeller med öppen källkod som tvingar fram priskrig) och mjukvaruoptimering (spekulativ avkodning, kontinuerlig batchning, kvantisering). Gartner spår att inferenskostnaderna sjunker ytterligare 90 % till 2030, men det är en prognos, inte en garanti.

Epoch AI:s prisspårning dokumenterar denna nedgång med hårda datapunkter. a16z:s "LLMflation"-analys myntade begreppet och ramade in de ekonomiska konsekvenserna: inferens deflerar snabbare än någon tidigare beräkningskategori.

Träning kontra inferenskostnad

Att träna en frontiermodell kostar $50 M–200 M (engångskostnad). Inferens för samma modell, över alla användare, kostar $5 M–50 M per år beroende på skala. För de flesta team är förhållandet 10–100x: träning kostar 10–100 gånger vad ett år av inferens kostar. Men träning är en engångsinvestering. Inferens är den återkommande driftsräkning som växer med användartillväxten. Du betalar inte för träning om du inte bygger en grundmodell. Du betalar för inferens varje dag.

Elposten

Ett NVIDIA H100 drar ~700 W under last. Till $0,10/kWh (USA-snitt) är det $0,07 per GPU-timme. En 70B-modell på ett enda H100 genererar ungefär 2 000 outputtokens/sekund i batch. Under en timme: 7,2 M tokens. Elkostnad per miljon outputtokens: ~$0,01. Vår beräkning, markerad som sådan. El är 1–3 % av din API-räkning men 8–15 % av en egenhostad TCO. Det spelar större roll om du kör dina egna GPU:er i en region med höga elpriser (Tyskland till $0,30/kWh tredubblar den här siffran).

Den praktiska slutsatsen: priserna faller snabbt nog att ett 12-månadersåtagande till en specifik modellklass är riskabelt. Ompröva kvartalsvis. 12 sätt att sänka din LLM-räkning täcker taktiska drag du kan göra direkt medan makrotrenden gör grovjobbet.

Hur uppskattar DU din inferenskostnad?

Uppskatta din månatliga kostnad för LLM-inferens i fyra steg: räkna tokens per förfrågan, multiplicera med månadsvolymen, tillämpa klassprissättning och lägg sedan till 20–40 % overhead. I vår erfarenhet av att dimensionera inferensbudgetar för kunder hoppar de flesta team över steg fyra och undrar varför deras verkliga räkning överstiger uppskattningen med en tredjedel. Här är processen vi använder.

1. Räkna tokens per förfrågan. Logga dina genomsnittliga inputtokens (systemprompt + kontext + användarmeddelande) och outputtokens (modellsvar) över 100+ riktiga förfrågningar. Gissa inte. Mät.
2. Multiplicera med månadsvolymen. Förfrågningar/dag × 30 = månatliga förfrågningar. Multiplicera med dina tokenantal per förfrågan.
3. Tillämpa klassprissättning. Multiplicera totala inputtokens med modellens $/M-inputpris. Samma för output. Summera.
4. Lägg till 20–40 % overhead. Retries, eval, prompt-iteration, övervakning. Det är den här siffran som ska in i din budget, inte 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 väl känner din siffra routar LLM-gatewayverktyg trafiken till den billigaste modell som klarar din kvalitetsnivå. En gateway med modellval per förfrågan kan sänka din blandade kostnad med 30–50 % utan att röra dina prompter.

Vanliga frågor

Är LLM-inferens dyrt?

Det beror på skala och modellval. En miljon inputtokens kostar $0,02 på Gemini 2.5 Flash eller $75 på en resonerande frontiermodell. För en liten app som bearbetar 10 000 förfrågningar/dag, räkna med $50–400/månad. För företagsarbetslaster med 1 M+ förfrågningar/dag ligger budgetar på $5 000–40 000/månad. Enhetskostnaden är låg; volymen gör att det summerar sig.

Hur mycket är 1 miljon tokens i LLM?

En miljon tokens motsvarar ungefär 750 000 ord, eller cirka 10 fullängdsromaner. I juli 2026 kostar bearbetning av 1 M inputtokens $0,02 (budgetklass) till $75 (frontierklass). Outputtokens för samma volym ligger på $0,06 till $300. De flesta produktionsarbetslaster landar i mellanklassen: $2–15 per miljon inputtokens.

Varför är AI-inferens så dyrt?

Inferens kräver att varje token körs genom miljarder modellparametrar på GPU:er som kostar $25 000–40 000 styck. Avkodningsfasen genererar tokens sekventiellt, vilket lämnar GPU-kärnor overksamma mellan stegen. Du betalar för specialiserad hårdvara, el, kylning och leverantörens ingenjörsteam som håller serverstacken igång dygnet runt.

Sjunker kostnaderna för AI-inferens?

Ja, ungefär 10x per år sedan 2023. GPT-4 lanserades till $30/$60 per miljon tokens (input/output). Motsvarande förmåga kostar nu $2–10. Epoch AI:s data bekräftar denna utveckling hos alla leverantörer. Gartner spår ytterligare 90 % nedgång till 2030, driven av hårdvaruförbättringar och konkurrenstryck från modeller med öppen källkod.

Hur mycket kostar LLM-inferens 2026?

Budgetmodeller: $0,02–0,30 per miljon inputtokens. Mellanklass: $0,55–15. Frontier: $15–75. En typisk produktionsarbetslast (supportchattbot, RAG-pipeline eller kodbiträde) kostar $150–4 000/månad på mellanklassmodeller. Budgetmodeller klarar volymstarka, lågkomplexa uppgifter för 10–30x mindre.

Vad är skillnaden mellan träningskostnad och inferenskostnad?

Träning är engångskostnaden för att lära en modell från grunden: $50 M–200 M för en frontiermodell, som kräver tusentals GPU:er i månader. Inferens är den återkommande kostnaden för att använda den tränade modellen: köra input genom den för att få output, fakturerad per token. För de flesta team är inferens den enda räkning de betalar. Träning är för företag som bygger grundmodeller.

Hur beräknar jag LLM-inferenskostnad för min app?

Multiplicera genomsnittliga inputtokens per förfrågan med din månatliga förfrågningsvolym, sedan med modellens $/M-inputpris. Upprepa för outputtokens. Summera båda. Lägg till 30 % för retries, eval och övervaknings-overhead. Python-kodavsnitten i det här inlägget automatiserar matten. Mät riktiga tokenantal istället för att gissa; loggar från 100+ förfrågningar ger ett tillförlitligt genomsnitt.

Kostar outputtokens mer än inputtokens?

Ja, vanligtvis 3–5x mer. Inputbearbetning (prefill) parallelliseras över alla tokens samtidigt och utnyttjar GPU-kärnorna fullt ut. Outputgenerering (decode) producerar en token i taget, där varje token beror på den föregående. GPU:t väntar på minnesbandbredd mellan stegen. Leverantörer prissätter output högre för att avspegla denna lägre hårdvarueffektivitet.

Är egenhostad inferens billigare än att använda API?

Bara över ~200 000 förfrågningar/dag med ihållande GPU-utnyttjande över 50 %. Under det slår API-leverantörernas effektivitet i en fleranvändarmiljö din hårdvara för en ensam användare. Egenhostning lägger också till dolda kostnader: ML-ingenjörslöner ($180 000–250 000/år), jourturer, modelluppdateringar och säkerhetspatchning. De flesta team under 50 ingenjörer bör stanna på API.

Drar LLM-inferens mycket energi?

Ett H100-GPU drar ~700 W under last. Till $0,10/kWh är det $0,07/GPU-timme, vilket motsvarar ungefär $0,01 per miljon outputtokens för en 70B-modell. El är 1–3 % av en API-räkning men 8–15 % av en egenhostad TCO. I regioner med höga elpriser (Tyskland, $0,30/kWh) tredubblas elandelen och påverkar egenhostningsekonomin märkbart.

Slutsatsen

Fyra siffror att komma ihåg: $0,02 (budgetgolv per miljon inputtokens), 3–5x (outputpremien över input), 20–40 % (overhead att lägga ovanpå den råa tokenmatten) och 10x (årlig prissänkning sedan 2023). Din verkliga räkning beror på volym, modellklass och hur aggressivt du cachar, batchar och routar trafiken.

Hos Techsy dimensionerar vårt team inferensbudgetar och väljer modellklasser för B2B-kunder som kör produktionsarbetslaster med LLM. Om du vill ha ett par extra ögon på din kostnadsmodell, boka en gratis konsultation.