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:
- Das teuerste 1 % der Nutzer. Oft eine einzelne Schleife oder ein Bot. Eine sinkende
cache_rateist das andere Frühwarnsignal; der Rechner für Prompt Caching zeigt, was jeder Prozentpunkt Cache-Rate wert ist. - Kosten pro erfolgreichem Ergebnis, nicht pro Aufruf: Verknüpfen Sie die Daten mit Ihren eigenen Erfolgsereignissen.
- 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:
- Stichproben. Bewahren Sie Text nur für einen kleinen Teil der Aufrufe und für Fehler auf, nicht für alles.
- 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.
- Detektoren kombinieren. Regex für strukturierte Daten, ein NER-Tool für Namen und Adressen.
- Getrennt speichern. Legen Sie Text in eine andere Tabelle oder einen anderen Bucket mit strengerem Zugriff und kurzer Aufbewahrung, verknüpft über
request_id. - 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.
