Ga naar hoofdinhoud
Nederlands— Kies een taal
Menu

Kosten en gebruik monitoren

Les 16 van 22 Bijgewerkt op 29 juli 2026 Ontwikkelaar
Op deze pagina
  1. Kosten en gebruik monitoren
  2. Facturatie begrijpen
  3. Kostencalculator
  4. Real-time kostentracker
  5. Client met budgetbeheersing
  6. Kosten optimaliseren
  7. Belangrijkste punten

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_tokens in wanneer de responslengte voorspelbaar is
  • Controleer het OpenAI-dashboard voor officiële verbruiksmonitoring