Beräkna och förutsäga API-kostnader
Skriv en Python-hjälpfunktion som uppskattar kostnaden innan en begäran skickas genom att räkna tokens och tillämpa priset för respektive modell, så att ni slipper oväntade fakturor.
Beräkna och förutsäga API-kostnader är en gratis lektion i AI Engineering Academy på CoddyKit. Detta är lektion 3 av 4. Ni kan läsa hela lektionen gratis nedan och sedan öva praktiskt i webbläsaren med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt. Den ingår i lärvägen för AI Engineering Academy, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i AI Engineering Academy innehåller totalt 4 lektioner.
Varför kostnadsprognoser är viktiga
API-kostnader för LLM-applikationer kan bli förvånansvärt stora i stor skala. En enskild fråga som verkar billig vid 0,002 USD kostar 200 USD när den körs 100 000 gånger. Utan kostnadsprognoser och övervakning kan AI-funktioner skapa oväntade molnräkningar som överstiger hela kostnaden för er infrastruktur.
Det positiva är att LLM-kostnader går att förutsäga helt innan ni skickar en förfrågan: ni vet vilken modell som används, ni kan räkna indatatoken med tiktoken och ni kan uppskatta antalet utdatatoken utifrån inställningen max_tokens eller historiska genomsnitt. Genom att bygga in kostnadsprognoser i applikationen från första dagen undviker ni överraskningar på fakturan.
OpenAI:s prismodell
OpenAI tar separat betalt för indatatoken och utdatatoken, där utdata vanligtvis kostar 3–4 gånger mer. Priserna varierar mellan modeller. Som vägledning för 2025 (kontrollera alltid den aktuella prissidan eftersom priserna ändras):
- gpt-4o-mini: cirka 0,15 USD per miljon indatatoken, cirka 0,60 USD per miljon utdatatoken
- gpt-4o: cirka 2,50 USD per miljon indatatoken, cirka 10,00 USD per miljon utdatatoken
- text-embedding-3-small: cirka 0,02 USD per miljon token
Kostnadsskillnaden mellan modellerna är enorm: gpt-4o är ungefär 17 gånger dyrare än gpt-4o-mini per indatatoken. Modellvalet är ert viktigaste verktyg för kostnadskontroll – börja alltid med den billigaste modell som uppfyller era kvalitetskrav.
En hjälpfunktion för kostnadsuppskattning
Bygg en kostnadsuppskattare som ni anropar innan ni skickar en förfrågan. Den räknar indatatoken med tiktoken, uppskattar antalet utdatatoken utifrån parametern max_tokens, slår upp priset för den aktuella modellen och returnerar den uppskattade kostnaden i dollar. Anropa den i utvecklingsmiljön och logga resultaten, så att ni får en känsla för vad olika typer av frågor kostar.
import tiktoken
# Prices per million tokens as of early 2025
PRICING = {
'gpt-4o': {'input': 2.50, 'output': 10.00},
'gpt-4o-mini': {'input': 0.15, 'output': 0.60},
'gpt-4-turbo': {'input': 10.00, 'output': 30.00},
'text-embedding-3-small': {'input': 0.02, 'output': 0.0},
}
def estimate_cost(messages, model='gpt-4o-mini', expected_output_tokens=500):
enc = tiktoken.encoding_for_model(model)
input_tokens = sum(
len(enc.encode(m.get('content', ''))) + 4
for m in messages
) + 3
if model not in PRICING:
raise ValueError(f'Unknown model: {model}')
rates = PRICING[model]
input_cost = (input_tokens / 1_000_000) * rates['input']
output_cost = (expected_output_tokens / 1_000_000) * rates['output']
total = input_cost + output_cost
print(f'Model: {model}')
print(f'Input tokens: {input_tokens} (${input_cost:.6f})')
print(f'Est. output tokens: {expected_output_tokens} (${output_cost:.6f})')
print(f'Estimated total: ${total:.6f}')
return totalFölj faktiska kostnader från API-svar
Efter varje API-anrop innehåller svarsobjektet de faktiska tokenmängderna som användes. Hämta dessa för att logga verkliga kostnader och jämföra dem med era uppskattningar. Med tiden visar skillnaden mellan uppskattat och faktiskt antal utdatatoken hur träffsäkert ni förutsäger användningen, och loggarna ger er en kostnadsuppdelning per funktion eller användarsegment.
import openai
client = openai.OpenAI()
PRICING = {
'gpt-4o-mini': {'input': 0.15, 'output': 0.60},
}
def chat_with_cost_tracking(model, messages):
response = client.chat.completions.create(
model=model, messages=messages
)
usage = response.usage
rates = PRICING.get(model, {'input': 0, 'output': 0})
actual_cost = (
(usage.prompt_tokens / 1_000_000) * rates['input'] +
(usage.completion_tokens / 1_000_000) * rates['output']
)
print(f'Input: {usage.prompt_tokens} tokens')
print(f'Output: {usage.completion_tokens} tokens')
print(f'Total: {usage.total_tokens} tokens')
print(f'Actual cost: ${actual_cost:.6f}')
return response, actual_costPrognostisera månadskostnader
När ni känner till den genomsnittliga kostnaden per förfrågan och den förväntade volymen av förfrågningar är det enkelt att prognostisera månadskostnaderna. Skapa ett kostnadsmodellkalkylblad eller ett enkelt Python-skript som låter er testa olika antaganden: Vad händer om antalet dagliga aktiva användare fördubblas? Vad händer om vi lägger till en funktion som gör 3 API-anrop per användaråtgärd i stället för 1?
def project_monthly_cost(
avg_cost_per_request,
requests_per_day,
days=30
):
daily_cost = avg_cost_per_request * requests_per_day
monthly_cost = daily_cost * days
print(f'Avg cost/request: ${avg_cost_per_request:.6f}')
print(f'Requests/day: {requests_per_day:,}')
print(f'Daily cost: ${daily_cost:.2f}')
print(f'Monthly cost: ${monthly_cost:.2f}')
# Growth scenarios
for multiplier in [2, 5, 10]:
scaled = monthly_cost * multiplier
print(f' At {multiplier}x traffic: ${scaled:.2f}/month')
# Example: customer support bot
project_monthly_cost(
avg_cost_per_request=0.002, # 2 cents per support query
requests_per_day=5000
)Modellvalets kostnadseffekt
Det viktigaste sättet att minska kostnaderna är att använda den billigaste modell som uppfyller era kvalitetskrav. För många uppgifter presterar gpt-4o-mini ungefär lika bra som gpt-4o, men till cirka 17 gånger lägre kostnad. Innan ni väljer den mest kraftfulla modellen som standard bör ni testa den billigare modellen på just er uppgift och endast byta till den dyrare om kvaliteten hamnar under er tröskel.
En strategi med nivåindelad routing är ännu effektivare: klassificera inkommande förfrågningar efter komplexitet och dirigera enkla frågor till billiga modeller och komplexa frågor till dyra modeller. Om ni dirigerar 70 % av trafiken till den billiga modellen och 30 % till den dyra sparar ni ungefär 70 % av AI-kostnaderna.
Promptlängd och kostnad
Varje token i er prompt kostar pengar. En utförlig systemprompt som kan kortas ned utan att betydelsen går förlorad ökar direkt er API-kostnad för varje förfrågan. Mät tokenantalet i era prompter och leta efter möjligheter att formulera dem mer koncist. På samma sätt kan långa few-shot-exempel ofta ersättas med kortare motsvarigheter utan att noggrannheten försämras.
I RAG-system utgör den hämtade kontexten ofta den största delen av prompten. Att returnera 10 stora textblock när 3 väl valda, mindre block skulle räcka slösar tokens vid varje fråga. Justera hämtningen så att redundant kontext minimeras samtidigt som relevansen maximeras.
Batchbearbetning för kostnadseffektivitet
OpenAI erbjuder ett Batch API som behandlar förfrågningar asynkront till 50 % av standardpriset. Om ert användningsfall inte är känsligt för svarstid – dokumentbearbetning, nattliga analysjobb eller generering av stora mängder innehåll – kan Batch API halvera era kostnader med minimala kodändringar.
Batchförfrågningar skickas som JSONL-filer, behandlas inom 24 timmar och resultaten hämtas från API:et. Detta passar utmärkt för förbehandlingspipelines som körs enligt ett schema och inte behöver svar i realtid.
import openai
import json
client = openai.OpenAI()
# Create batch request file
requests = [
{'custom_id': f'doc-{i}',
'method': 'POST',
'url': '/v1/chat/completions',
'body': {
'model': 'gpt-4o-mini',
'messages': [{'role': 'user', 'content': f'Summarize document {i}'}],
'max_tokens': 200
}}
for i in range(100)
]
# Write to JSONL
with open('/tmp/batch_input.jsonl', 'w') as f:
for req in requests:
f.write(json.dumps(req) + '\n')
# Upload and submit (50% off list price)
print('Would submit batch for 100 documents at 50% discount')
# batch_file = client.files.create(file=open('/tmp/batch_input.jsonl','rb'), purpose='batch')
# batch = client.batches.create(input_file_id=batch_file.id, endpoint='/v1/chat/completions', completion_window='24h')Ange utgiftsgränser
Konfigurera alltid utgiftsgränser för att förhindra skenande kostnader. I OpenAI-instrumentpanelen kan ni ange månatliga utgiftstak som stoppar API-åtkomsten när gränsen nås. Sätt en hård gräns vid den högsta kostnad ni kan acceptera och en mjuk gräns vid 80 % av detta värde, så får ni en e-postvarning innan det hårda taket nås.
Implementera i applikationskoden en budget per användare eller funktion som följs upp i databasen. Kontrollera budgeten före varje API-anrop och returnera ett fel om den är förbrukad. På så sätt kan inte en enskild användare som löper amok eller ett fel i ett batchjobb förbruka hela er månadskvot på några timmar.
Cachning för att undvika redundanta API-anrop
Det billigaste API-anropet är det ni aldrig gör. Implementera cachning på applikationsnivå, så att identiska förfrågningar besvaras från cachen i stället för att API:et anropas igen. Även en enkel Redis-cache med promptens SHA256-hash som nyckel kan eliminera en betydande andel redundanta anrop i en produktionsapplikation.
För embeddings är cachning särskilt effektivt: samma text bör bara bäddas in en gång. Lagra embeddings i er vektordatabas med den ursprungliga texten som nyckel och kontrollera om en embedding redan finns innan embeddings-API:et anropas. I en RAG-pipeline beräknas dokumentembeddings en gång vid indexeringen och återanvänds för varje fråga som hämtar dem.
import hashlib
import json
# Simple in-memory cache (use Redis in production)
_cache = {}
def cached_completion(client, model, messages, **kwargs):
cache_key = hashlib.sha256(
json.dumps({'model': model, 'messages': messages}).encode()
).hexdigest()
if cache_key in _cache:
print('Cache HIT - no API call made')
return _cache[cache_key]
response = client.chat.completions.create(
model=model, messages=messages, **kwargs
)
_cache[cache_key] = response
print('Cache MISS - API call made')
return responseBygg en kostnadsinstrumentpanel
I produktion behöver ni insyn i era AI-kostnader uppdelade efter funktion, användare och modell. Bygg en kostnadsinstrumentpanel genom att logga tokenantalet för varje API-anrop samt tillhörande metadata (användar-ID, funktionsnamn och modell) i en tidsseriedatabas. Aggregera sedan informationen för att besvara frågor som: vilken funktion står för de största utgifterna? Genererar storkonsumenter oproportionerligt höga kostnader? Ökar kostnaden per fråga efter en ändring av prompten?
Denna insyn är avgörande för att kunna fatta datadrivna beslut om optimering i stället för att gissa var kostnaderna ska minskas. De flesta företag upptäcker att 20 % av funktionerna står för 80 % av deras AI-utgifter, och att optimering av dessa funktioner får oproportionerligt stor effekt.
Snabbtest
Testa era kunskaper om AI Engineering-begreppen från den här lektionen.
Sammanfattning av lektionen
I den här lektionen har ni lärt er att API-kostnader kan förutsägas innan en förfrågan skickas genom att räkna indatatokens med tiktoken och uppskatta antalet utdatatokens, att valet av modell är den viktigaste kostnadsreglaget – gpt-4o-mini kan vara 17 gånger billigare än gpt-4o för lämpliga uppgifter, samt att cachning, batchbearbetning och utgiftsgränser förhindrar skenande kostnader i produktion. Nästa avsnitt handlar om strategier för att hantera långa konversationer som överskrider kontextfönstret.
Lär dig Python med en AI-lärare – gratis
Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.
- Kurser
- 30
- Lektioner
- 120
Vanliga frågor
Är lektionen ”Beräkna och förutsäga API-kostnader” gratis?
Ja – hela texten till ”Beräkna och förutsäga API-kostnader” kan läsas gratis här på webben. Om Ni vill öva interaktivt med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt och låsa upp resten av kursen i AI Engineering Academy, kan Ni uppgradera till CoddyKit PRO. Kursen i AI Engineering Academy innehåller totalt 4 lektioner.
Vad lär jag mig i ”Beräkna och förutsäga API-kostnader”?
Skriv en Python-hjälpfunktion som uppskattar kostnaden innan en begäran skickas genom att räkna tokens och tillämpa priset för respektive modell, så att ni slipper oväntade fakturor. Ni övar på AI Engineering Academy med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.
Behöver jag någon erfarenhet för att börja lära mig AI Engineering Academy?
Du behöver inga förkunskaper. Utbildningen i AI Engineering Academy på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 3 av 4.
Hur lång tid tar lektionen ”Beräkna och förutsäga API-kostnader”?
De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.
Kan jag skriva och köra kod i den här AI Engineering Academy-lektionen?
Ja. Varje AI Engineering Academy-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.
Alla lektioner i den här kursen
- Vad är en token?
- Kontextfönster: storlek och konsekvenser
- Beräkna och förutsäga API-kostnader
- Strategier för att hålla sig inom kontextgränsen