Beregning og forudsigelse af API-omkostninger
Skriv en Python-hjælpefunktion, der estimerer omkostningen, før en forespørgsel sendes, ved at tælle tokens og anvende priser pr. model, så De aldrig får en uventet regning.
Beregning og forudsigelse af API-omkostninger er en gratis AI Engineering Academy-lektion på CoddyKit. Dette er lektion 3 af 4. Du kan læse hele lektionen gratis nedenfor — og derefter øve dig praktisk i browseren med en indbygget kodeeditor og en AI-vejleder, der er tilgængelig døgnet rundt. Den er en del af læringsforløbet i AI Engineering Academy, og dine fremskridt synkroniseres på tværs af nettet og CoddyKit-appen. AI Engineering Academy-kurset indeholder 4 lektioner i alt.
Hvorfor er omkostningsforudsigelse vigtig
API-omkostninger for LLM-applikationer kan blive overraskende store i stor skala. En enkelt forespørgsel, der virker billig til $0,002, bliver til $200, når den køres 100.000 gange. Uden omkostningsforudsigelse og overvågning kan AI-funktioner generere uventede cloudregninger, der overstiger hele din infrastrukturudgift.
Den gode nyhed er, at LLM-omkostninger kan forudsiges fuldstændigt, før du sender en forespørgsel: Du kender modellen, du kan tælle inputtokens med tiktoken, og du kan estimere outputtokens ud fra din indstilling af max_tokens eller historiske gennemsnit. Hvis du indbygger omkostningsforudsigelse i din applikation fra starten, undgår du overraskelser på regningen.
OpenAI's prisstruktur
OpenAI opkræver separat betaling for inputtokens og outputtokens, hvor output typisk koster 3-4 gange mere. Priserne varierer fra model til model. Som vejledning for 2025 (tjek altid den aktuelle prisside, da priserne ændrer sig):
- gpt-4o-mini: cirka $0,15 pr. million inputtokens, cirka $0,60 pr. million outputtokens
- gpt-4o: cirka $2,50 pr. million inputtokens, cirka $10,00 pr. million outputtokens
- text-embedding-3-small: cirka $0,02 pr. million tokens
Prisforskellen mellem modellerne er enorm: gpt-4o er cirka 17 gange dyrere end gpt-4o-mini pr. inputtoken. Valg af model er dit vigtigste middel til omkostningskontrol — start altid med den billigste model, der opfylder dine kvalitetskrav.
En hjælpefunktion til omkostningsestimering
Byg en omkostningsestimator, som du kalder, før du sender en forespørgsel. Den tæller inputtokens med tiktoken, estimerer outputtokens ud fra din max_tokens-parameter, slår prisen pr. model op og returnerer den estimerede pris i dollars. Kald den under udviklingen, og log resultaterne, så du opbygger en fornemmelse for, hvad forskellige typer forespørgsler koster.
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 totalSporing af faktiske omkostninger fra API-svar
Efter hvert API-kald indeholder svarobjektet de faktiske antal tokens, der blev brugt. Udtræk disse oplysninger for at logge de reelle omkostninger og sammenligne dem med dine estimater. Med tiden viser forskellen mellem estimerede og faktiske outputtokens, hvor præcist du forudsiger forbruget, og loggene giver dig en omkostningsopdeling efter funktion eller brugersegment.
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_costFremskrivning af månedlige omkostninger
Når du kender den gennemsnitlige pris pr. forespørgsel og det forventede antal forespørgsler, er det enkelt at fremskrive de månedlige omkostninger. Byg et regneark med en omkostningsmodel eller et enkelt Python-script, som lader dig afprøve forskellige antagelser: Hvad hvis antallet af dagligt aktive brugere fordobles? Hvad hvis vi tilføjer en funktion, der foretager 3 API-kald pr. brugerhandling i stedet for 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
)Omkostningskonsekvensen af modelvalg
Det vigtigste middel til at reducere omkostningerne er at bruge den billigste model, der opfylder dit kvalitetskrav. Til mange opgaver klarer gpt-4o-mini sig omtrent lige så godt som gpt-4o, men til cirka 17 gange lavere pris. Før du vælger den kraftigste model som standard, skal du måle den billigere model på din specifikke opgave og kun skifte til den dyrere, hvis kvaliteten falder under din grænse.
En strategi med niveaudelt routing er endnu mere effektiv: Klassificér indgående forespørgsler efter kompleksitet, og send enkle forespørgsler til billige modeller og komplekse forespørgsler til dyre modeller. Selv hvis du sender 70 % af trafikken til den billige model og 30 % til den dyre, sparer du cirka 70 % af dine AI-omkostninger.
Promptlængde og omkostninger
Hver token i din prompt koster penge. En udførlig systemprompt, der kunne forkortes uden at miste betydning, øger direkte din API-regning for hver forespørgsel. Mål antallet af tokens i dine prompts, og se efter muligheder for at gøre formuleringerne mere kompakte. På samme måde kan lange few-shot-eksempler ofte erstattes af kortere ækvivalenter uden at gå på kompromis med nøjagtigheden.
I RAG-systemer udgør den hentede kontekst ofte den største del af prompten. Hvis du returnerer 10 store tekststykker, selv om 3 velvalgte, mindre stykker ville være nok, spilder du tokens ved hver forespørgsel. Juster din hentning, så overflødig kontekst minimeres, samtidig med at relevansen maksimeres.
Batchbehandling for lavere omkostninger
OpenAI tilbyder en Batch API, der behandler forespørgsler asynkront til 50 % af standardprisen. Hvis dit anvendelsesområde ikke er følsomt over for svartid — dokumentbehandling, natlige analysejob eller masseproduktion af indhold — kan Batch API halvere dine omkostninger med minimale kodeændringer.
Batchforespørgsler indsendes som JSONL-filer, behandles inden for 24 timer, og resultaterne hentes fra API'et. Det er ideelt til forbehandlingspipelines, der kører efter en tidsplan og ikke har brug for 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')Indstilling af forbrugsgrænser
Konfigurer altid forbrugsgrænser for at forhindre løbske omkostninger. I OpenAI-dashboardet kan du angive månedlige forbrugslofter, der afbryder API-adgangen, når grænsen nås. Sæt en hård grænse ved det maksimale beløb, du vil acceptere at bruge, og en blød grænse ved 80 % af dette beløb, så du modtager en advarsel via e-mail, før den hårde grænse nås.
Implementer i din programkode et budget pr. bruger eller funktion, som spores i din database. Kontroller budgettet før hvert API-kald, og returner en fejl, hvis det er opbrugt. Det forhindrer, at en enkelt løbsk bruger eller en fejl i et batchjob bruger hele din månedlige kvote på få timer.
Caching for at undgå overflødige API-kald
Det billigste API-kald er det, du aldrig foretager. Implementer caching på applikationslaget, så identiske forespørgsler kan besvares fra cachen i stedet for at kalde API'et igen. Selv en simpel Redis-cache, der bruger SHA256-hashen af prompten som nøgle, kan eliminere en betydelig andel af overflødige kald i en produktionsapplikation.
For embeddings har caching særlig stor effekt: Den samme tekst bør kun konverteres til en embedding én gang. Gem embeddings i din vektordatabase med den oprindelige tekst som nøgle, og undersøg, om der allerede findes en embedding, før du kalder embeddings-API'et. I en RAG-pipeline beregnes dokumentembeddings én gang ved indeksering og genbruges for hver forespørgsel, der henter 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 responseOpbygning af et omkostningsdashboard
I produktion har du brug for overblik over dine AI-omkostninger fordelt på funktion, bruger og model. Opbyg et omkostningsdashboard ved at logge tokenantallet og de tilknyttede metadata (bruger-id, funktionsnavn og model) for hvert API-kald i en tidsseriedatabase. Aggreger derefter dataene for at besvare spørgsmål som: Hvilken funktion står for det største forbrug? Skaber storforbrugere uforholdsmæssigt høje omkostninger? Stiger omkostningen pr. forespørgsel efter en ændring af en prompt?
Dette overblik er afgørende for at kunne træffe datadrevne optimeringsbeslutninger i stedet for at gætte på, hvor omkostningerne skal reduceres. De fleste virksomheder opdager, at 20 % af deres funktioner står for 80 % af deres AI-forbrug, og at optimering af disse funktioner har en uforholdsmæssigt stor effekt.
Hurtigt tjek
Afprøv din forståelse af begreberne inden for AI Engineering fra denne lektion.
Opsummering af lektionen
I denne lektion har du lært, at API-omkostninger kan forudsiges, før du sender en forespørgsel, ved at tælle inputtokens med tiktoken og estimere outputtokens, at valg af model er den vigtigste omkostningsfaktor — gpt-4o-mini kan være 17 gange billigere end gpt-4o til passende opgaver, og at caching, batchbehandling og forbrugsgrænser forhindrer løbske omkostninger i produktion. Nu ser vi på strategier til håndtering af lange samtaler, der overskrider kontekstvinduet.
Lær Python med en AI-underviser — gratis
Skriv og kør rigtig kode i din browser, få øjeblikkelig hjælp fra en AI-underviser døgnet rundt, og fortsæt, hvor du slap, på web eller i appen.
- Kurser
- 30
- Lektioner
- 120
Ofte stillede spørgsmål
Er lektionen “Beregning og forudsigelse af API-omkostninger” gratis?
Ja — hele teksten til “Beregning og forudsigelse af API-omkostninger” kan læses gratis her på nettet. Hvis du vil øve dig interaktivt med en indbygget kodeeditor og en AI-vejleder døgnet rundt og få adgang til resten af AI Engineering Academy-kurset, skal du opgradere til CoddyKit PRO. AI Engineering Academy-kurset indeholder 4 lektioner i alt.
Hvad lærer jeg i “Beregning og forudsigelse af API-omkostninger”?
Skriv en Python-hjælpefunktion, der estimerer omkostningen, før en forespørgsel sendes, ved at tælle tokens og anvende priser pr. model, så De aldrig får en uventet regning. Du øver dig i AI Engineering Academy med praktisk kode, som du kører direkte i browseren, og en AI-vejleder døgnet rundt besvarer dine spørgsmål, mens du arbejder dig gennem lektionen.
Skal jeg have erfaring for at begynde på AI Engineering Academy?
Der kræves ingen tidligere erfaring. AI Engineering Academy på CoddyKit er tilrettelagt for både begyndere og øvede, så du kan starte her eller fra begyndelsen og lære i dit eget tempo. Dette er lektion 3 af 4.
Hvor lang tid tager lektionen “Beregning og forudsigelse af API-omkostninger”?
De fleste CoddyKit-lektioner tager cirka 5–10 minutter. Hver lektion er kort og interaktiv, så du gør løbende fremskridt og kan fortsætte, hvor du slap – på både web og app.
Kan jeg skrive og køre kode i denne AI Engineering Academy-lektion?
Ja. Alle AI Engineering Academy-lektioner har en indbygget kodeeditor, så du kan skrive og køre rigtig kode direkte i din browser og få øjeblikkelig feedback fra AI – uden lokal opsætning.
Alle lektioner i dette kursus
- Hvad er en token?
- Kontekstvinduer: Størrelse og betydning
- Beregning og forudsigelse af API-omkostninger
- Strategier til at holde sig inden for konteksten