Zum Hauptinhalt springen
Deutsch— Sprache auswählen
Menü

Kosten und Nutzung überwachen

Lektion 16 von 22 Aktualisiert am 29. Juli 2026 Entwickler
Auf dieser Seite
  1. Kosten und Nutzung überwachen
  2. Verständnis der Abrechnung
  3. Kostenrechner
  4. Echtzeit-Kostenverfolger
  5. Client mit Budgetkontrolle
  6. Kostenoptimierung
  7. Kernaussagen

Kosten und Nutzung überwachen

API-Kosten können schnell außer Kontrolle geraten, wenn Sie sie nicht im Blick behalten. In dieser Lektion erfahren Sie, wie Sie Ihre Ausgaben in der Produktion verfolgen, schätzen und steuern können. Die Geschichte wiederholt sich von Projekt zu Projekt: Eine Funktion geht am Donnerstag live, niemand prüft das Dashboard über das Wochenende, und die Rechnung am Montagmorgen entspricht dem gesamten Monatsbudget. Die folgenden Schritte helfen Ihnen, Kostenabweichungen genau dann zu erkennen, wenn sie auftreten, und nicht erst nach dreißig Tagen.

Verständnis der Abrechnung

Kosten werden pro Million Tokens berechnet, wobei für Eingabe und Ausgabe unterschiedliche Preise gelten. Diese Asymmetrie hat direkte Konsequenzen für Ihre Designentscheidungen: Das Senden eines langen Dokuments als Eingabe kostet deutlich weniger als die Generierung eines langen Outputs durch das Modell. Jede Antwort gibt die genaue Anzahl für beide Richtungen zurück, sodass Sie niemals schätzen müssen.

from openai import OpenAI
client = OpenAI()

# Jede Antwort enthält Nutzungsmetriken
response = client.responses.create(
    model="gpt-5.6-terra",
    input="Erkläre die OpenAI API-Abrechnung."
)

usage = response.usage
print(f"Eingabetokens: {usage.input_tokens}")
print(f"Ausgabetokens: {usage.output_tokens}")
print(f"Gesamttokens: {usage.total_tokens}")

# Ausgaben für die Ausgabe sind höher als für die Eingabe!

Kostenrechner

Das Umrechnen dieser Zähler in Dollar erfordert ein Preisschema. Isolieren Sie es in einer dedizierten Struktur, statt Konstanten im gesamten Code zu streuen: Wenn sich Preise ändern oder Sie ein Modell hinzufügen, müssen Sie nur noch eine Zeile anpassen. Die untenstehenden Raten sind Richtwerte und sollten bei jeder Budgetprüfung verifiziert werden.

from dataclasses import dataclass

@dataclass
class ModelRate:
    input_per_million: float
    output_per_million: float

# Näherungsweise Preise in USD pro Million Tokens
# Prüfen Sie immer die aktuellen Preise auf 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:
    """Berechnet die Kosten eines Aufrufs in USD."""
    rate = RATES.get(model)
    if not rate:
        raise ValueError(f"Unbekanntes Modell: {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

# Beispiel
cost = calculate_cost("gpt-5.6-terra", input_tokens=1000, output_tokens=500)
print(f"Kosten: ${cost:.6f}")
# Ergebnis: Kosten: $0.008000

Acht Zehntel eines Zent pro Aufruf klingt beruhigend, bis man es mit den fünfzigtausend täglichen Aufrufen eines Produktions-Chatbots multipliziert – das sind vierhundert Dollar pro Tag. Gewöhnen Sie sich immer an, in monatlichen Volumina zu denken, niemals pro Aufruf.

Echtzeit-Kostenverfolger

Einzelne Berechnungen sind nutzlos, wenn sie nicht aggregiert werden. Dieser Verfolger aggregiert Ausgaben über drei Achsen – nach Tag, nach Modell und nach Anzahl der Aufrufe – und vergleicht das Tagesgesamt mit einem von Ihnen festgelegten Budget. Warnungen sind gestuft: Eine Warnung, wenn weniger als 20 % des Budgets verbleiben, gefolgt von einer harten Alarmierung bei Überschreitung des Limits. Dieser Zwischenschritt ist wertvoll, da er Ihnen Zeit gibt, einzugreifen, bevor der Dienst unterbrochen wird.

import json
from datetime import datetime, date
from collections import defaultdict

class CostTracker:
    """Echtzeit-Verfolgung der API-Kosten."""

    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):
        """Verzeichnet die Kosten eines Aufrufs."""
        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:
        """Gibt das verbleibende Budget für heute zurück."""
        today = date.today().isoformat()
        return self.daily_budget - self.costs_per_day[today]

    def budget_alert(self) -> bool:
        """Prüft, ob das Budget dem Limit nahe kommt."""
        remaining = self.remaining_budget()
        if remaining <= 0:
            print("ALARM: Tägliches Budget überschritten!")
            return True
        elif remaining < self.daily_budget * 0.2:
            print(f"WARNUNG: ${remaining:.2f} verbleibend im täglichen Budget")
            return True
        return False

    def report(self) -> dict:
        """Generiert einen Kostenbericht."""
        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,
        }

# Nutzung
tracker = CostTracker(daily_budget_usd=5.0)

response = client.responses.create(
    model="gpt-5.6-terra",
    input="Hallo!"
)

cost = tracker.record(
    model="gpt-5.6-terra",
    input_tokens=response.usage.input_tokens,
    output_tokens=response.usage.output_tokens
)
print(f"Kosten dieses Aufrufs: ${cost:.6f}")
print(json.dumps(tracker.report(), indent=2))

Client mit Budgetkontrolle

Überwachung reicht nicht immer aus: Angesichts eines fehlerhaften Loops, der die API kontinuierlich aufruft, benötigen Sie einen finanziellen Sicherungsautomaten. Dieser Client prüft das verbleibende Budget vor der Ausgabe des Requests und lehnt den Aufruf kategorisch ab, wenn das Kontingent erschöpft ist. Der Service degradiert, aber auf kontrollierte Weise ohne überraschende Rechnungen. Die Kostenbuchhaltung erfolgt nachträglich, sobald die tatsächliche Nutzung bekannt ist.

class BudgetControlledClient:
    """Client, der Aufrufe ablehnt, wenn das Budget überschritten ist."""

    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-Aufruf mit Budgetkontrolle."""
        # Budget vor dem Aufruf prüfen
        if self.tracker.remaining_budget() <= 0:
            raise RuntimeError(
                "Tägliches Budget erschöpft. "
                f"Ausgegeben: ${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
        )

        # Alarmieren, wenn das Budget niedrig ist
        self.tracker.budget_alert()

        return response

# Nutzung
budget_client = BudgetControlledClient(daily_budget=2.0)

try:
    response = budget_client.create("gpt-5.6-terra", "Hallo!")
    print(response.output_text)
except RuntimeError as e:
    print(f"Blockiert: {e}")

Kostenoptimierung

1. Das richtige Modell wählen

Der mächtigste Hebel bleibt die Routierung nach Komplexität. Eine Klassifizierungsaufgabe mit drei Kategorien benötigt nicht das teuerste Modell: Für diese Aufgabe erreicht die Differenz in der Rechnung bei gleicher Qualität einen Faktor von fünfundzwanzig. Machen Sie Komplexität zu einem expliziten Parameter Ihrer Funktion, statt sie als fest codierte Entscheidung in die Logik zu integrieren.

# Relative Kosten pro Aufgabe (näherungsweise, ~300 Eingabetokens / 20 Ausgabe):
# Einfache Klassifizierung: gpt-5.6-luna ~$0.0001 vs gpt-5.6-sol ~$0.002
# Das richtige Modell macht einen Unterschied von 25x in den Kosten!

def optimized_call(prompt: str, complexity: str) -> str:
    """Wählt das wirtschaftlichste geeignete Modell."""
    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. Antworten zwischenspeichern

Der zweite Hebel besteht darin, nicht zweimal für dieselbe Antwort zu zahlen. Eine FAQ, ein Produktkatalog oder ein Standardformular generiert strikt identische Prompts dutzende Male am Tag. Der Cache-Schlüssel kombiniert das Modell, die Eingabe und die Parameter – einschließlich aller davon ist essenziell, sonst würde eine Änderung der Temperatur stumm die alte Antwort zurückgeben.

import hashlib

class CachedClient:
    """Client mit Cache, um redundante Aufrufe zu vermeiden."""

    def __init__(self):
        self.client = OpenAI()
        self.cache: dict[str, str] = {}

    def create(self, model: str, input: str, **kwargs) -> str:
        # Einen Cache-Schlüssel erstellen
        cache_key = hashlib.md5(
            f"{model}:{input}:{json.dumps(kwargs, sort_keys=True)}".encode()
        ).hexdigest()

        if cache_key in self.cache:
            print("Cache-Treffer!")
            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. Ausgabetokens begrenzen

Schließlich begrenzen Sie die Ausgabe immer dann, wenn ihre Länge vorhersehbar ist. Da die Ausgabe der teure Teil ist, lässt das Anfordern eines einzelnen Wortes bei einer Autorisierung von zweitausend Tokens die Tür offen für eine ausufernde Antwort, für die Sie zahlen, die Sie aber nicht nutzen.

# Setzen Sie max_output_tokens immer für vorhersehbare Aufgaben
response = client.responses.create(
    model="gpt-5.6-terra",
    input="Klassifizieren Sie diesen Text: positiv, negativ oder neutral.",
    max_output_tokens=10  # Erwartung eines einzelnen Wortes
)

Raten vom 5. August 2026 — Preise ändern sich regelmäßig: Bevor Sie eine Budgetberechnung durchführen, überprüfen Sie das aktuelle Schema auf der offiziellen OpenAI-Preissseite.

Kernaussagen

  • Kosten hängen vom Modell UND der Richtung (Eingabe vs. Ausgabe) ab
  • Implementieren Sie einen Kostenverfolger mit Budgetalarmen
  • Nutzen Sie das richtige Modell für jede Aufgabe: Luna für Volumen, Terra als Standard
  • Caching kann Kosten für wiederholte Anfragen drastisch senken
  • Setzen Sie max_output_tokens, wenn die Antwortlänge vorhersehbar ist
  • Prüfen Sie das OpenAI-Dashboard für die offizielle Verbrauchserfassung