Kosten en gebruik monitoren
Op deze pagina
Kosten en gebruik monitoren
API-kosten kunnen snel uit de hand lopen als u ze niet in de gaten houdt. In deze les leert u hoe u uw uitgaven in een productieomgeving kunt volgen, schatten en beheersen. Het verhaal herhaalt zich project na project: een functie gaat op donderdag live, niemand controleert het dashboard in het weekend, en maandagochtend komt de factuur overeen met het volledige maandbudget. De onderstaande stappen helpen u om kostenafwijkingen direct op te sporen, niet dertig dagen later.
Facturatie begrijpen
Kosten worden berekend per miljoen tokens, met verschillende prijzen voor input en output. Deze asymmetrie heeft directe gevolgen voor uw ontwerpkeuzes: het verzenden van een lang document als input kost aanzienlijk minder dan het model een lang document laten genereren. Elk antwoord bevat het exacte aantal tokens voor beide richtingen, zodat u nooit hoeft te schatten.
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!
Kostencalculator
Het omzetten van deze tellers naar dollars vereist een prijstabel. Isoleer deze in een aparte structuur in plaats van constanten door uw code te verspreiden: wanneer prijzen wijzigen of u een model toevoegt, hoeft u slechts één regel aan te passen. De onderstaande tarieven zijn indicatief en moeten bij elke budgetbeoordeling worden geverifieerd.
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
Acht tiende van een cent per oproep klinkt geruststellend, totdat u dit vermenigvuldigt met de vijftigduizend dagelijkse oproepen van een productie-chatbot: dat is vierhonderd dollar per dag. Maak er altijd een gewoonte van om in maandvolumes te denken, nooit per oproep.
Real-time kostentracker
Berekeningen per eenheid zijn nutteloos tenzij ze worden geaggregeerd. Deze tracker aggregeert uitgaven langs drie assen: per dag, per model en per aantal oproepen, en vergelijkt het dagtotaal met een door u ingesteld budget. Waarschuwingen zijn getrapt: een waarschuwing wanneer minder dan 20% van het budget over is, gevolgd door een harde waarschuwing bij overschrijding van de limiet. Deze tussenstap is waardevol omdat het u tijd geeft om in te grijpen voordat de service wordt afgesloten.
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))
Client met budgetbeheersing
Monitoren is niet altijd voldoende: geconfronteerd met een foutieve lus die continu de API aanroept, heeft u een financiële stroomonderbreker nodig. Deze client controleert het resterende budget voordat het verzoek wordt verzonden en weigert de oproep ronduit als het budget op is. De service degradeert, maar op een gecontroleerde manier zonder verrassingsfacturen. De kostprijsberekening vindt afterward plaats, zodra het daadwerkelijke gebruik bekend is.
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}")
Kosten optimaliseren
1. Het juiste model kiezen
De meest krachtige hefboom blijft routing op basis van complexiteit. Een classificatietaak met drie categorieën heeft het duurste model niet nodig: voor deze taak loopt het factuurverschuur op tot een factor vijfentwintig bij dezelfde kwaliteit. Maak complexiteit een expliciete parameter van uw functie in plaats van een beslissing die hardgecodeerd is in de logica.
# 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. Antwoorden cachen
De tweede hefboom is vermijden dat u twee keer betaalt voor hetzelfde antwoord. Een FAQ, productcatalogus of standaardformulier genereert tientallen keren per dag exact dezelfde prompts. De cache-sleutel combineert het model, de input en de parameters; het opnemen van allemaal is essentieel, anders zou een wijziging in de temperatuur stilzwijgend het oude antwoord retourneren.
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. Output-tokens beperken
Begrens ten slotte de output wanneer de lengte voorspelbaar is. Aangezien output het dure deel is, laat het vragen om één woord terwijl u tweeduizend tokens toestaat, de deur open staan voor een uitgebreid antwoord dat u betaalt maar niet gebruikt.
# 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
)
Tarieven per 5 augustus 2026 — prijzen wijzigen regelmatig: verifieer voor elke budgetberekening de huidige tabel op de officiële OpenAI-prijs pagina.
Belangrijkste punten
- Kosten hangen af van het model EN de richting (input versus output)
- Implementeer een kostentracker met budgetwaarschuwingen
- Gebruik het juiste model voor elke taak: Luna voor volume, Terra als standaard
- Cachen kan de kosten voor repetitieve verzoeken drastisch verlagen
- Stel
max_output_tokensin wanneer de responslengte voorspelbaar is - Controleer het OpenAI-dashboard voor officiële verbruiksmonitoring