KI-API-Ausgaben deckeln: max_tokens, Budgets pro Nutzer und ehrliche Abrechnung

Ein KI-Feature ohne Ausgabendeckel ist ein Feature, das dir einen unbegrenzten Betrag in Rechnung stellen kann. Eine außer Kontrolle geratene Agent-Schleife, ein Nutzer, der einen ganzen Roman ins Chatfeld einfügt, ein Prompt, der das Modell 4.000 Tokens lang schwafeln lässt — jedes davon vervielfacht still und leise deine Rechnung. Die Lösung sind zwei billige, langweilige Kontrollen: begrenze jeden Call mit max_tokens und erfasse den Verbrauch pro Nutzer aus dem usage-Objekt, damit du jemanden kappen kannst, bevor er mehr kostet, als er wert ist.

Nichts davon ist schwer. Der schwere Teil ist, den Zahlen zu vertrauen, gegen die du deckelst. Ein Budget ist nur so gut wie die Token-Zahlen, die es speisen — bläht dein Gateway usage auf oder berechnet dir fehlgeschlagene Calls, dann ist deine sorgfältig errechnete Obergrenze von $1/Nutzer/Tag in Wahrheit $1,40, und du würdest es nie merken. Dieser Beitrag tut deshalb zwei Dinge: Er zeigt dir die Mechanik und erklärt, warum erst ehrliche Abrechnung diese Mechanik überhaupt funktionieren lässt.

Schritt 1 — begrenze jeden Call mit max_tokens

Output ist bei den meisten Rechnungen die teure Hälfte. Bei Claude Sonnet 4.6 kostet Output $12,75 pro 1M Tokens — fünfmal so viel wie der Input-Tarif von $2,55. Eine Antwort, die du als drei Sätze erwartet hast und die stattdessen als zwölf Absätze zurückkommt, ist kein Qualitätsproblem; sie ist ein Kostenproblem. max_tokens ist die harte Obergrenze, die den schlimmsten Fall vorab kalkulierbar macht.

# Deckle die Kosten jedes einzelnen Calls mit max_tokens.
# Es begrenzt den *Output* — die teure Hälfte der meisten Rechnungen — auf
# eine harte Obergrenze. Das Modell stoppt am Limit, statt auszuufern.
from openai import OpenAI

client = OpenAI(
    api_key="sk-brievio-...",
    base_url="https://api.brievio.com/v1",
)

# Claude Sonnet 4.6: $2,55 in / $12,75 out pro 1M Tokens.
# Ohne Deckel kann eine geschwätzige Antwort 4.000+ Output-Tokens erreichen.
# Mit max_tokens=500 begrenzt du die Output-Kosten DIESES Calls auf:
#   500 × $12,75 / 1M = $0,0064 — egal, was das Modell alles "sagen will".
resp = client.chat.completions.create(
    model="claude-sonnet-4-6",
    max_tokens=500,                 # nativ respektiert — ein echter harter Stopp
    messages=[
        {"role": "system", "content": "Answer in at most 3 sentences."},
        {"role": "user", "content": user_question},
    ],
)

# Prüfe immer, warum gestoppt wurde. "length" heißt, du hast die Obergrenze
# erreicht und die Antwort ist womöglich abgeschnitten — das Signal, den Deckel
# für DIESE Aufgabenklasse anzuheben, nicht global.
if resp.choices[0].finish_reason == "length":
    print("Am Deckel abgeschnitten — hier ein höheres max_tokens erwägen.")

print(resp.choices[0].message.content)
print(resp.usage)  # ehrliche Input-/Output-Zahlen — siehe nächster Abschnitt

Brievio respektiert max_tokens nativ gegen das echte Modell — es ist ein echter Stopp, kein Hinweis. Setze es pro Aufgabenklasse, nicht einmal global: Ein Klassifizierer braucht vielleicht 5 Tokens, eine Chat-Antwort 500, eine lange Zusammenfassung 2.000. Die Disziplin besteht darin, für jede Aufrufstelle eine Zahl zu wählen und finish_reason zu beobachten. Kommt es als "length" zurück, hast du eine echte Antwort abgeschnitten und solltest den Deckel für diesen Pfad anheben — nicht überall pauschal erhöhen und den Schutz verlieren.

Schritt 2 — bepreise das usage-Objekt selbst

Jede Brievio-Antwort trägt ein usage-Objekt mit den echten Input- und Output-Token-Zahlen für diesen Call, und jeder Request wird mit seinen echten Tokens und Kosten protokolliert. Das heißt, du musst nicht auf eine Monatsendrechnung warten, um zu wissen, was etwas gekostet hat — du kannst jeden Call in dem Moment bepreisen, in dem er zurückkommt:

• usage.prompt_tokens — tatsächlich gesendete Input-Tokens.
• usage.completion_tokens — tatsächlich generierte Output-Tokens (das ist es, was max_tokens begrenzt).
• usage.total_tokens — die Summe, für einen schnellen Plausibilitätscheck.

Multipliziere jede Zahl mit dem veröffentlichten Tarif pro Modell, und du hast die exakten Kosten des Calls, in deinem eigenen Code, in Echtzeit. Die Tarife pro Modell sind auf der Pricing-Seite gegen die offizielle Referenz veröffentlicht, sodass die Konstanten in deinem Code überprüfbar sind — keine Zahl, die du auf gut Glück hinnehmen musst.

Schritt 3 — erfasse den Verbrauch pro Nutzer und kappe bei einem Budget

Deckel pro Request schützen dich vor einem einzelnen schlechten Call. Budgets pro Nutzer schützen dich vor einem einzelnen schlechten Akteur — dem einen Account, der täglich Tausende Calls fährt, ob aus Begeisterung, Automatisierung oder Missbrauch. Das Muster ist eine dauerhafte Zahl pro Nutzer, die du vor dem Call prüfst und danach hochzählst:

# Erfasse den Verbrauch pro Nutzer aus dem usage-Objekt und kappe bei einem Budget.
# usage liefert die ECHTEN Input-/Output-Token-Zahlen des Calls. Du bepreist sie
# lokal gegen den veröffentlichten Tarif pro Modell und addierst sie zu einem
# laufenden, je Nutzer geführten Zähler.
from decimal import Decimal

# Veröffentlichte Brievio-Tarife, USD pro 1M Tokens (≈15% unter offizieller Liste).
RATES = {
    "claude-sonnet-4-6": {"in": Decimal("2.55"), "out": Decimal("12.75")},
    "claude-haiku-4-5":  {"in": Decimal("0.85"), "out": Decimal("4.25")},
}

def cost_usd(model: str, usage) -> Decimal:
    r = RATES[model]
    million = Decimal("1000000")
    return (usage.prompt_tokens     * r["in"]  / million +
            usage.completion_tokens * r["out"] / million)

# Dein Speicher der Wahl — Redis-Counter, eine SQL-Spalte, was auch immer. Es geht
# um eine dauerhafte Zahl pro Nutzer. Fehlgeschlagene 4xx/5xx-Calls sind bei Brievio
# kostenlos, du addierst also nur Kosten für Calls, die wirklich ein Ergebnis lieferten.
DAILY_BUDGET = Decimal("1.00")  # $1/Nutzer/Tag

def chat_for_user(user_id: str, question: str, model="claude-sonnet-4-6"):
    spent = get_spent_today(user_id)            # Decimal, Standardwert 0
    if spent >= DAILY_BUDGET:
        raise BudgetExceeded(f"{user_id} hit ${DAILY_BUDGET}/day")

    resp = client.chat.completions.create(
        model=model,
        max_tokens=500,
        messages=[{"role": "user", "content": question}],
    )

    add_spent_today(user_id, cost_usd(model, resp.usage))  # echte Kosten verbuchen
    return resp.choices[0].message.content

Wähle den Schwellenwert aus deiner Unit Economics: Kostet ein bezahlter Sitz $20/Monat und soll KI darunter bleiben, sagen wir unter 20% des Umsatzes, dann ergibt das ein Budget von rund $0,13/Nutzer/Tag. Sanfte Warnung bei 80% (ein Banner, eine E-Mail), harter Schnitt bei 100% (derBudgetExceeded-Pfad oben). Für Nutzer im Free-Tier setze den Deckel niedrig und stufe das Modell herunter — verlagerst du nicht-kritischen Traffic von Sonnet auf Haiku 4.5 mit $0,85 in / $4,25 out, senkt das die Kosten pro Token um rund zwei Drittel, bei gleichbleibend ehrlicher Messung.

Warum ehrliche Abrechnung die Rechnung vertrauenswürdig macht

Hier kommt der Teil, den die meisten Kostenkontroll-Guides überspringen. Beide Kontrollen oben — die Obergrenze pro Call und das Budget pro Nutzer — sind Arithmetik auf Token-Zahlen. Sind diese Zahlen aufgebläht, ist jede nachgelagerte Zahl um denselben Faktor falsch, und das still und leise. Zwei Abrechnungsverhalten entscheiden, ob deine Deckel das bedeuten, was sie sagen:

• Fehlgeschlagene Calls sind kostenlos. Bei Brievio kostet eine 4xx- oder 5xx-Antwort nichts — dir werden Ergebnisse berechnet, nicht Versuche. Das ist speziell für Budgets wichtig: Ein Retry-Sturm gegen einen wackeligen Downstream sollte das Tagesguthaben eines Nutzers nicht leeren. Weil du Kosten nur für Calls verbuchst, die ein Ergebnis lieferten, folgt deine Verbrauchskurve dem gelieferten Wert, nicht den abgefangenen Fehlern.
• Die Zahlen sind nicht aufgebläht. Das usage-Objekt spiegelt die Tokens wider, die das echte Modell tatsächlich verarbeitet hat — kein aufgepolsterter Prompt, kein Phantom-Output, der dem Zähler hinzugefügt wird. Der ehrliche Schritt ist, das nicht auf Vertrauen hinzunehmen: Sende einen bekannten festen Prompt, lies prompt_tokens zurück und bestätige, dass es zu dem passt, was der Tokenizer sagt. Wir haben einen 20-zeiligen Token-Inflation-Selbsttest geschrieben, der genau das tut — lass ihn gegen jedes beliebige Gateway laufen, auch unseres, bevor du seinen Zahlen vertraust.

Der Zusammenhang ist direkt: Ein Budget, das aus aufgepolsterten Zahlen errechnet wird, kappt Nutzer zu früh und überzeichnet deine Kosten; eines, das fehlgeschlagene Calls einbezieht, bestraft Nutzer für die schlechten Tage deiner Infrastruktur. Ehrliche Messung ist das, was eine Obergrenze von $1/Tag tatsächlich einen Dollar bedeuten lässt. Brievio bepreist Chat rund 15% unter offizieller Liste, pay-as-you-go, mit einem Guthaben, das nie verfällt — so ist der Deckel, den du setzt, auch der Deckel, den du bekommst, und ungenutztes Budget bleibt deins.

Alles zusammengesetzt

Eine produktionsreife Ausgabenhaltung sind vier kleine Gewohnheiten, von denen keine mehr als einen Nachmittag braucht:

• Jede Aufrufstelle setzt max_tokens, bemessen nach ihrer Aufgabe. Nirgends unbegrenzte Outputs.
• Jede Antwort wird aus usage bepreist zum veröffentlichten Tarif und einem Zähler pro Nutzer hinzugefügt.
• Jeder Nutzer hat ein Budget mit einer sanften Warnung und einem harten Schnitt, abgeleitet aus deiner Unit Economics.
• Günstigerer Traffic stuft herunter auf ein kleineres Modell (Haiku, Mini-Klasse), statt Flaggschiff-Tarife für Arbeit zu zahlen, die sie nicht braucht.

Tu diese vier Dinge, und deine schlimmstmögliche Rechnung ist eine Zahl, die du gewählt hast, nicht eine Zahl, die du entdeckst. Für die tieferen Hebel — Prompt-Caching, Batching, Modellauswahl, Prompt-Trimming — siehe das Kostenoptimierungs-Playbook, und die Docs für das vollständige usage-Schema und die OpenAI-kompatiblen Parameter, die Brievio unterstützt. Kostenkontrolle ist kein Feature, das du nachrüstest, nachdem dich die Rechnung erschreckt hat — sie sind zwei Zeilen und ein Zähler, und sie funktioniert am besten auf einem Zähler, dem du vertrauen kannst.