BroadRouter
Loslegen

LLM-API-Nutzung loggen: Kosten pro Nutzer und Feature, ohne PII

Vom Team von BroadNet Inference · 4 Min. Lesezeit · Veröffentlicht

Packen Sie jeden LLM-Aufruf in eine Funktion, die Modell, Feature, eine gehashte Nutzer-ID, Prompt-, gecachte, Reasoning- und Output-Tokens, Kosten, Latenz, Status und die Request-ID des Anbieters festhält. Berechnen Sie die Kosten aus einer Preistabelle, nicht aus der Rechnung. Loggen Sie standardmäßig Metadaten; müssen Sie Prompt-Text aufbewahren, schwärzen Sie ihn vor dem Schreiben und setzen Sie eine kurze Aufbewahrungsfrist.

Die Dashboards der Anbieter zeigen Ihnen, was Sie ausgegeben haben. Sie zeigen selten, welches Feature oder welcher Kunde es ausgegeben hat, und sie können nicht erklären, warum eine Rechnung am Dienstag sprunghaft gestiegen ist. Ihr eigenes Nutzungslog kann das. Dieser Beitrag zeigt das Log-Schema, einen Wrapper, der es befüllt, wie Sie die Kosten pro Aufruf berechnen und wie Sie personenbezogene Daten heraushalten. Was Sie mit den Zahlen anfangen, steht an anderer Stelle: Kosten pro Nutzer und SaaS-Preise sowie Budgets und Schleifenschutz.

Was sollte man bei jedem LLM-Aufruf loggen?

Eine Zeile pro Versuch, Retries eingeschlossen:

Feld Beispiel Warum
ts 2026-11-14T09:12:03Z Zeitreihen, Zeitleisten bei Incidents
feature support_reply Kosten pro Feature
user_hash hmac:4f1c… Kosten pro Nutzer, ohne die Identität zu speichern
tenant acme Kosten pro Kunde in B2B-Apps
model broadnet/deepseek-v4.1-flash Preisabfrage, Modellvergleiche
prompt_tokens 18.240 Input-Kosten
cached_tokens 16.384 Gecachter Input ist günstiger; verfolgen Sie die Cache-Rate
reasoning_tokens 612 Versteckte Output-Kosten bei Reasoning-Modellen
completion_tokens 1.104 Output-Kosten (inklusive Reasoning)
cost_usd berechnet Die Zahl, nach der die Buchhaltung fragt
latency_ms, ttft_ms 4.210 / 690 Performance-Regressionen
status 200, 429, 503 Fehler- und Retry-Raten
request_id Wert von X-Request-ID Support-Tickets und Rechnungsreklamationen
prompt_version support-v14 Verknüpft Kostenänderungen mit Prompt-Änderungen

Kein Prompt-Text, kein Antworttext. Die kommen später, und nur mit Schwärzung.

Wie berechnet man die Kosten pro Aufruf?

Lesen Sie den Usage-Block und bepreisen Sie jede Token-Art separat. BroadNet veröffentlicht maschinenlesbare Preise in pricing.json, mit Preisen pro 1 Mio. für Input, gecachten Input und Output pro Modell:

import json, urllib.request

PRICES = {m["id"]: m for m in json.load(urllib.request.urlopen("https://inference.broadnet.ai/pricing.json"))["models"]}

def call_cost(model: str, usage) -> float:
    p = PRICES[model]
    details = getattr(usage, "prompt_tokens_details", None)
    cached = (getattr(details, "cached_tokens", 0) or 0) if details else 0
    new_input = usage.prompt_tokens - cached
    return (
        new_input * (p.get("input_per_m") or 0)
        + cached * (p.get("cached_input_per_m") or p.get("input_per_m") or 0)
        + usage.completion_tokens * (p.get("output_per_m") or 0)
    ) / 1_000_000

Cachen Sie die Preisdatei und aktualisieren Sie sie täglich, statt sie bei jedem Aufruf abzurufen. Zwei typische Fehler: gecachte Tokens wie neuen Input zu berechnen (überschätzt die Kosten) und zu vergessen, dass Reasoning-Tokens bereits in completion_tokens enthalten sind (nicht doppelt addieren).

Wie sieht der Logging-Wrapper aus?

import hashlib, hmac, os, time, logging
from openai import OpenAI

log = logging.getLogger("llm.usage")
client = OpenAI(base_url="https://inference.broadnet.ai/v1", api_key=os.environ["BROADNET_API_KEY"])
HASH_KEY = os.environ["USAGE_HASH_KEY"].encode()

def user_hash(user_id: str) -> str:
    return "hmac:" + hmac.new(HASH_KEY, user_id.encode(), hashlib.sha256).hexdigest()[:16]

def chat(*, feature: str, user_id: str, prompt_version: str, **kwargs):
    t0 = time.perf_counter()
    row = {"feature": feature, "user_hash": user_hash(user_id),
           "model": kwargs["model"], "prompt_version": prompt_version}
    try:
        raw = client.chat.completions.with_raw_response.create(**kwargs)
        resp = raw.parse()
        u = resp.usage
        d = getattr(u, "completion_tokens_details", None)
        row.update(
            status=200,
            request_id=raw.headers.get("x-request-id"),
            prompt_tokens=u.prompt_tokens,
            cached_tokens=getattr(getattr(u, "prompt_tokens_details", None), "cached_tokens", 0) or 0,
            reasoning_tokens=(getattr(d, "reasoning_tokens", 0) or 0) if d else 0,
            completion_tokens=u.completion_tokens,
            cost_usd=round(call_cost(kwargs["model"], u), 6),
        )
        return resp
    except Exception as e:
        row.update(status=getattr(e, "status_code", "error"),
                   request_id=getattr(getattr(e, "response", None), "headers", {}).get("x-request-id"))
        raise
    finally:
        row["latency_ms"] = int((time.perf_counter() - t0) * 1000)
        log.info("llm_call", extra={"llm": row})

with_raw_response liefert Ihnen die Header, sodass Sie die X-Request-ID behalten können. Bei Streaming-Aufrufen ergänzen Sie stream_options={"include_usage": True} und füllen die Zeile aus dem letzten Chunk, wie im Beitrag über SSE-Streaming gezeigt. Halten Sie HASH_KEY geheim und stabil: Derselbe Nutzer ergibt immer denselben Hash, aber ohne den Schlüssel lässt sich der Hash nicht zurückrechnen.

Wie ordnet man Kosten Nutzern und Features zu?

Mit den obigen Zeilen in einem beliebigen SQL-Speicher ist die Zuordnung eine einzige Abfrage:

SELECT feature, model,
       count(*)                          AS calls,
       sum(cost_usd)                     AS cost,
       sum(cached_tokens)::float / nullif(sum(prompt_tokens), 0) AS cache_rate,
       avg(completion_tokens)            AS avg_out
FROM llm_calls
WHERE ts >= now() - interval '7 days'
GROUP BY feature, model
ORDER BY cost DESC;

Tauschen Sie feature gegen user_hash oder tenant, um die Kosten pro Kunde zu sehen. Drei Folgeauswertungen zahlen sich schnell aus:

  1. Das teuerste 1 % der Nutzer. Oft eine einzelne Schleife oder ein Bot. Eine sinkende cache_rate ist das andere Frühwarnsignal; der Rechner für Prompt Caching zeigt, was jeder Prozentpunkt Cache-Rate wert ist.
  2. Kosten pro erfolgreichem Ergebnis, nicht pro Aufruf: Verknüpfen Sie die Daten mit Ihren eigenen Erfolgsereignissen.
  3. Retry-Anteil. Zeilen mit Status 429 oder 5xx zeigen, wie viel Sie für Fehlschläge ausgeben; siehe mit 429-Fehlern umgehen.

Wie hält man PII aus LLM-Logs heraus?

Das sicherste Log enthält gar keinen Prompt-Text. Wenn Sie Text brauchen, zum Debuggen oder für Evals, gehen Sie in dieser Reihenfolge vor:

  1. Stichproben. Bewahren Sie Text nur für einen kleinen Teil der Aufrufe und für Fehler auf, nicht für alles.
  2. Vor dem Schreiben schwärzen. Führen Sie die Schwärzung in dem Prozess aus, der das Log schreibt. Wer später schwärzt, hat den Rohtext bereits auf der Platte und in den Backups.
  3. Detektoren kombinieren. Regex für strukturierte Daten, ein NER-Tool für Namen und Adressen.
  4. Getrennt speichern. Legen Sie Text in eine andere Tabelle oder einen anderen Bucket mit strengerem Zugriff und kurzer Aufbewahrung, verknüpft über request_id.
  5. Nie Secrets loggen. Das OWASP Logging Cheat Sheet zählt Zugriffstokens, Passwörter und Verschlüsselungsschlüssel zu den Daten, die nicht ins Log gehören; der API-Schlüssel gehört auf diese Liste.

Eine minimale Regex-Schicht:

import re
PATTERNS = [
    (re.compile(r"[\w.+-]+@[\w-]+\.[\w.-]+"), "[EMAIL]"),
    (re.compile(r"\+?\d[\d\s().-]{7,}\d"), "[PHONE]"),
    (re.compile(r"\b(?:\d[ -]?){13,19}\b"), "[CARD]"),
    (re.compile(r"\b(sk|key|bearer)[-_ ]?[A-Za-z0-9]{16,}\b", re.I), "[SECRET]"),
]
def redact(text: str) -> str:
    for pat, label in PATTERNS:
        text = pat.sub(label, text)
    return text

Das fängt die offensichtlichen Fälle ab und übersieht Namen, Adressen und alles Ungewöhnliche. Microsoft Presidio ergänzt dafür Entitätserkennung, und seine README sagt klar, dass es keine Garantie gibt, alle sensiblen Informationen zu finden. Planen Sie mit Lücken: Kurze Aufbewahrung und enger Zugriff begrenzen den Schaden, wenn etwas durchrutscht.

Wo BroadNet Inference ins Bild passt

BroadNet Inference liefert den Usage-Block mit gecachten und Reasoning-Tokens, sofern das Modell sie meldet, eine X-Request-ID bei jeder Antwort und eine öffentliche Preisdatei, die Sie für die Kostenberechnung laden können. Auf seiner Seite werden Prompts und Antworten für die Anfrage verarbeitet und nicht gespeichert; aufbewahrt werden nur Datensätze ohne Inhalt wie Zeiten, Token-Zahlen und Kosten (so funktioniert Zero Data Retention). Damit sind Ihre eigenen Logs die einzige Kopie jedes Prompt-Texts, und die Schwärzungsregeln oben bestimmen Ihre tatsächliche Aufbewahrung. Chat-Anfragen bei BroadNet haben kein Metadatenfeld pro Nutzer, die Zuordnung liegt also in Ihrem Wrapper. Für getrennte Budgets pro Team nutzen Sie getrennte Schlüssel; der Leitfaden zu Schlüsseln behandelt Labels und Allowlists.

Häufige Fragen

Wie tracke ich die Kosten einer LLM-API pro Nutzer?

Versehen Sie jeden Aufruf mit einer Nutzerkennung, lesen Sie den Usage-Block aus der Antwort, multiplizieren Sie die Token-Zahlen mit Ihrer Preistabelle und schreiben Sie eine Logzeile pro Aufruf. Gruppieren Sie nach der Nutzerkennung. Verwenden Sie eine gehashte ID statt einer E-Mail-Adresse.

Sollte ich vollständige Prompts und Antworten loggen?

Nicht standardmäßig. Genau dort stecken personenbezogene Daten. Loggen Sie für jeden Aufruf Token-Zahlen und Metadaten und bewahren Sie vollständigen Text nur für Stichproben oder fehlgeschlagene Aufrufe auf, nach der Schwärzung und mit kurzer Aufbewahrungsfrist.

Warum weichen meine berechneten Kosten von der Rechnung des Anbieters ab?

Meist, weil gecachte Tokens wie neuer Input berechnet, Reasoning-Tokens beim Output weggelassen oder Retries nicht geloggt wurden. Loggen Sie jeden Versuch, auch fehlgeschlagene, die Usage-Daten zurückgaben.

Wie bekomme ich den Token-Verbrauch aus einer Streaming-Antwort?

Setzen Sie in stream_options include_usage auf true. Der letzte Chunk enthält dann den Usage-Block mit einer leeren choices-Liste.

Welches Tool zur PII-Schwärzung sollte ich für LLM-Logs nutzen?

Beginnen Sie mit Regex für strukturierte Daten wie E-Mail-Adressen, Telefon- und Kartennummern und ergänzen Sie ein NER-basiertes Tool wie Microsoft Presidio für Namen und Adressen. Die README von Presidio sagt selbst, dass es nicht garantieren kann, alles zu finden.

Als Markdown lesenChatGPT fragenClaude fragenPerplexity fragen