Overvågning af omkostninger og forbrug
På denne side
Overvågning af omkostninger og forbrug
API-omkostninger kan hurtigt løbe løbsk, hvis ikke du holder øje med dem. Denne lektion lærer dig, hvordan du sporer, estimerer og styrer dit forbrug i produktion. Historien gentager sig fra projekt til projekt: En funktion går live en torsdag, ingen tjekker dashboardet i weekenden, og mandag morgens regning svarer til hele månedsbudgettet. Trinnene nedenfor hjælper dig med at fange afvigelser i omkostningerne, lige så snart de opstår – ikke tredive dage senere.
Forståelse af fakturering
Omkostninger beregnes per million tokens, med forskellige priser for input og output. Denne asymmetri har direkte konsekvenser for dine designvalg: At sende et langt dokument som input koster betydeligt mindre end at få modellen til at generere et langt svar. Hvert svar returnerer det præcise antal for begge retninger, så du behøver aldrig at gætte.
from openai import OpenAI
client = OpenAI()
# Every response includes usage metrics
response = client.responses.create(
model="gpt-5.6-terra",
input="Explain OpenAI API billing."
)
usage = response.usage
print(f"Input tokens: {usage.input_tokens}")
print(f"Output tokens: {usage.output_tokens}")
print(f"Total tokens: {usage.total_tokens}")
# Output costs more than input!
Omkostningsberegner
At omregne disse tællere til dollars kræver en pristabel. Isolér den i en dedikeret struktur i stedet for at sprede konstanter ud over hele din kode: Når priserne ændrer sig, eller du tilføjer en model, skal du kun ændre én linje. Priserne nedenfor er vejledende og bør verificeres ved hver budgetgennemgang.
from dataclasses import dataclass
@dataclass
class ModelRate:
input_per_million: float
output_per_million: float
# Approximate prices in USD per million tokens
# Always check current prices on platform.openai.com/pricing
RATES = {
"gpt-5.6-luna": ModelRate(input_per_million=0.20, output_per_million=1.20),
"gpt-5.6-terra": ModelRate(input_per_million=2.0, output_per_million=12.0),
"gpt-5.6-sol": ModelRate(input_per_million=5.0, output_per_million=30.0),
}
def calculate_cost(model: str, input_tokens: int,
output_tokens: int) -> float:
"""Calculates the cost of a call in USD."""
rate = RATES.get(model)
if not rate:
raise ValueError(f"Unknown model: {model}")
input_cost = (input_tokens / 1_000_000) * rate.input_per_million
output_cost = (output_tokens / 1_000_000) * rate.output_per_million
return input_cost + output_cost
# Example
cost = calculate_cost("gpt-5.6-terra", input_tokens=1000, output_tokens=500)
print(f"Cost: ${cost:.6f}")
# Result: Cost: $0.008000
Otte tiendedele af en cent per kald lyder beroligende, indtil du ganger det med de halvtreds tusind daglige kald fra en produktions-chatbot – det er fire hundrede dollars om dagen. Væn dig altid til at tænke i månedlige volumener, aldrig per kald.
Realtids-omkostningssporing
Enhedsberegninger er ubrugelige, medmindre de aggregeres. Denne tracker samler forbrug på tværs af tre akser – per dag, per model og per antal kald – og sammenligner dagens total med et budget, du har fastsat. Advarsler er graduerede: En advarsel, når mindre end 20 % af budgettet er tilbage, efterfulgt af en hård alarm, hvis grænsen overskrides. Dette mellemtrin er værdifuldt, fordi det giver dig tid til at gribe ind, før tjenesten bliver afbrudt.
import json
from datetime import datetime, date
from collections import defaultdict
class CostTracker:
"""Real-time API cost tracking."""
def __init__(self, daily_budget_usd: float = 10.0):
self.daily_budget = daily_budget_usd
self.costs_per_day: dict[str, float] = defaultdict(float)
self.costs_per_model: dict[str, float] = defaultdict(float)
self.calls_per_day: dict[str, int] = defaultdict(int)
self.total_tokens = 0
def record(self, model: str, input_tokens: int,
output_tokens: int):
"""Records the costs of a call."""
cost = calculate_cost(model, input_tokens, output_tokens)
today = date.today().isoformat()
self.costs_per_day[today] += cost
self.costs_per_model[model] += cost
self.calls_per_day[today] += 1
self.total_tokens += input_tokens + output_tokens
return cost
def remaining_budget(self) -> float:
"""Returns the remaining budget for today."""
today = date.today().isoformat()
return self.daily_budget - self.costs_per_day[today]
def budget_alert(self) -> bool:
"""Checks if the budget is close to the limit."""
remaining = self.remaining_budget()
if remaining <= 0:
print("ALERT: Daily budget exceeded!")
return True
elif remaining < self.daily_budget * 0.2:
print(f"WARNING: ${remaining:.2f} remaining on daily budget")
return True
return False
def report(self) -> dict:
"""Generates a cost report."""
return {
"total_cost_usd": sum(self.costs_per_day.values()),
"cost_today_usd": self.costs_per_day.get(
date.today().isoformat(), 0
),
"remaining_budget_usd": self.remaining_budget(),
"costs_per_model": dict(self.costs_per_model),
"total_tokens": self.total_tokens,
}
# Usage
tracker = CostTracker(daily_budget_usd=5.0)
response = client.responses.create(
model="gpt-5.6-terra",
input="Hello!"
)
cost = tracker.record(
model="gpt-5.6-terra",
input_tokens=response.usage.input_tokens,
output_tokens=response.usage.output_tokens
)
print(f"Cost of this call: ${cost:.6f}")
print(json.dumps(tracker.report(), indent=2))
Klient med budgetkontrol
Overvågning er ikke altid nok: Står du over for en fejlslagen løkke, der kalder API’et kontinuerligt, har du brug for en finansiel afbryder. Denne klient tjekker det resterende budget før anmodningen sendes og nægter blankt at udføre kaldet, hvis rammen er opbrugt. Tjenesten degraderes, men på en kontrolleret måde uden overraskelsesregninger. Omkostningsregnskabet sker bagefter, når det faktiske forbrug er kendt.
class BudgetControlledClient:
"""Client that refuses calls if the budget is exceeded."""
def __init__(self, daily_budget: float = 10.0):
self.client = OpenAI()
self.tracker = CostTracker(daily_budget_usd=daily_budget)
def create(self, model: str, input: str, **kwargs) -> object:
"""API call with budget control."""
# Check budget before the call
if self.tracker.remaining_budget() <= 0:
raise RuntimeError(
"Daily budget exhausted. "
f"Spent: ${self.tracker.report()['cost_today_usd']:.2f}"
)
response = self.client.responses.create(
model=model,
input=input,
**kwargs
)
cost = self.tracker.record(
model=model,
input_tokens=response.usage.input_tokens,
output_tokens=response.usage.output_tokens
)
# Alert if budget is low
self.tracker.budget_alert()
return response
# Usage
budget_client = BudgetControlledClient(daily_budget=2.0)
try:
response = budget_client.create("gpt-5.6-terra", "Hello!")
print(response.output_text)
except RuntimeError as e:
print(f"Blocked: {e}")
Optimering af omkostninger
1. Valg af den rigtige model
Den mest effektive løftestang forbliver routing baseret på kompleksitet. En klassificeringsopgave i tre kategorier har ikke brug for den dyreste model: For denne opgave kan forskellen i regningen nå en faktor på femogtyve ved identisk kvalitet. Gør kompleksitet til en eksplicit parameter i din funktion i stedet for en beslutning, der er hardcodet i logikken.
# Relative cost per task (approximate, ~300 input tokens / 20 output):
# Simple classification: gpt-5.6-luna ~$0.0001 vs gpt-5.6-sol ~$0.002
# The right model makes a 25x difference in costs!
def optimized_call(prompt: str, complexity: str) -> str:
"""Chooses the most economical suitable model."""
model = {
"simple": "gpt-5.6-luna",
"standard": "gpt-5.6-terra",
"complex": "gpt-5.6-sol",
}.get(complexity, "gpt-5.6-terra")
response = client.responses.create(model=model, input=prompt)
return response.output_text
2. Cachning af svar
Den anden løftestang er at undgå at betale to gange for det samme svar. En FAQ, et produktkatalog eller en standardformular genererer strengt identiske prompts dusinvis af gange om dagen. Cache-nøglen kombinerer model, input og parametre – det er afgørende at inkludere dem alle, ellers vil en ændring i temperaturen stille og roligt returnere det gamle svar.
import hashlib
class CachedClient:
"""Client with cache to avoid redundant calls."""
def __init__(self):
self.client = OpenAI()
self.cache: dict[str, str] = {}
def create(self, model: str, input: str, **kwargs) -> str:
# Create a cache key
cache_key = hashlib.md5(
f"{model}:{input}:{json.dumps(kwargs, sort_keys=True)}".encode()
).hexdigest()
if cache_key in self.cache:
print("Cache hit!")
return self.cache[cache_key]
response = self.client.responses.create(
model=model, input=input, **kwargs
)
self.cache[cache_key] = response.output_text
return response.output_text
3. Begrænsning af output-tokens
Endelig bør du sætte loft over output, når længden er forudsigelig. Da output er den dyre del, åbner det døren for et verbost svar, som du betaler for, men ikke bruger, hvis du beder om ét ord, men tillader to tusind tokens.
# Always set max_output_tokens for predictable tasks
response = client.responses.create(
model="gpt-5.6-terra",
input="Classify this text: positive, negative, or neutral.",
max_output_tokens=10 # Expecting a single word
)
Priser pr. 5. august 2026 – priser ændrer sig regelmæssigt: Før enhver budgetberegning skal du verificere den aktuelle pristabel på OpenAIs officielle prisside.
Vigtige pointer
- Omkostninger afhænger af modellen OG retningen (input vs. output)
- Implementér en omkostningssporing med budgetadvarsler
- Brug den rigtige model til hver opgave: Luna til volumen, Terra som standard
- Cachning kan drastisk reducere omkostninger ved gentagne forespørgsler
- Sæt
max_output_tokens, når svarets længde er forudsigelig - Tjek OpenAI-dashboardet for officiel forbrugssporing