---
title: "LLM-Nutzung loggen: Kosten pro Nutzer, ohne PII | BroadRouter"
description: "Jeden LLM-API-Aufruf mit Tokens, Kosten, Latenz und Request-ID loggen, Ausgaben Nutzern und Features zuordnen und PII vor dem Schreiben schwärzen. Mit Python-Code."
url: https://broadrouter.com/de/blog/llm-api-usage-logging/
lang: de
updated: 2026-11-14
publisher: BroadRouter (a BroadNet site); API by BroadNet Inference, https://inference.broadnet.ai
---

Mit KI-Unterstützung aus dem Englischen übersetzt. [Englisches Original lesen](https://broadrouter.com/blog/llm-api-usage-logging/) (aktualisiert am 2026-11-14).

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

Vom Team von BroadNet Inference · 4 Min. Lesezeit · Veröffentlicht 2026-11-14

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.

## Das Wichtigste in Kürze

-   Ein Wrapper, eine Logzeile pro Aufruf: Modell, Feature, gehashter Nutzer, Token-Zahlen, Kosten, Latenz, Status, Request-ID.
-   Berechnen Sie die Kosten pro Aufruf aus dem Usage-Block und einer Preistabelle: Neuer Input, gecachter Input und Output haben unterschiedliche Preise.
-   Hashen Sie Nutzer-IDs mit einem geschlüsselten HMAC, dann können Sie nach Nutzer gruppieren, ohne zu speichern, wer er ist.
-   Loggen Sie standardmäßig Metadaten. Prompt-Text ist das größte PII-Risiko; schwärzen Sie vor dem Schreiben, nie danach.
-   Schwärzung per Regex und per NER übersieht beides etwas. Behandeln Sie sie als eine Schicht, nicht als Garantie.

**Auf dieser Seite**

1.  Was sollte man bei jedem LLM-Aufruf loggen?
2.  Wie berechnet man die Kosten pro Aufruf?
3.  Wie sieht der Logging-Wrapper aus?
4.  Wie ordnet man Kosten Nutzern und Features zu?
5.  Wie hält man PII aus LLM-Logs heraus?
6.  Wo BroadNet Inference ins Bild passt

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](https://broadrouter.com/de/blog/llm-cost-per-user-saas/) sowie [Budgets und Schleifenschutz](https://broadrouter.com/de/blog/llm-api-spend-control/).

## 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](https://broadrouter.com/de/blog/cached-input-tokens-explained/) |
| `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](https://broadrouter.com/de/glossary/input-and-output-tokens/)\-Art separat. BroadNet veröffentlicht maschinenlesbare Preise in [pricing.json](https://inference.broadnet.ai/pricing.json?utm_source=broadrouter&utm_medium=referral&utm_campaign=de-blog-llm-api-usage-logging&utm_content=body), mit Preisen pro 1 Mio. für Input, gecachten Input und Output pro Modell:

```python
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?

```python
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](https://broadrouter.com/de/blog/llm-streaming-sse-explained/) 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:

```sql
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](https://broadrouter.com/tools/prompt-caching-calculator/) 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](https://broadrouter.com/de/blog/handle-llm-api-429-rate-limits/).

## 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](https://broadrouter.com/de/glossary/api-key/) gehört auf diese Liste.

Eine minimale Regex-Schicht:

```python
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](https://github.com/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](https://broadrouter.com/de/privacy/)). 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](https://broadrouter.com/de/guides/api-keys-ip-allow-lists/) behandelt Labels und Allowlists.

Kostenlose Tools zum Thema (auf Englisch)

-   [OpenAI to BroadNet migration helper](https://broadrouter.com/tools/openai-to-broadnet-migration/) Paste OpenAI SDK code; get base URL, key and model edits, a diff and the checks that remain.
-   [max\_tokens calculator for reasoning models](https://broadrouter.com/tools/reasoning-token-budget/) Answer length + reasoning budget + margin = a max\_tokens that does not cut the answer off.
-   [JSON schema generator for LLM structured output](https://broadrouter.com/tools/json-schema-generator/) Sample JSON to strict schema, Pydantic, Zod and a ready request.
-   [LLM JSON output validator](https://broadrouter.com/tools/llm-json-output-validator/) Parse errors by line and column, safe repairs, cut-off detection and JSON Schema checks for model output.

[Kostenlose Tools (auf Englisch)](https://broadrouter.com/tools/)

## Begriffe in diesem Artikel

[Gecachte Input-Tokens (Cached Input Tokens)](https://broadrouter.com/de/glossary/cached-input-tokens/)

Gecachte Input-Tokens sind Prompt-Tokens, die ein LLM-Anbieter kürzlich verarbeitet hat und aus einem Cache wiederverwenden kann, statt sie neu zu berechnen, meist ein wiederholtes Präfix wie ein System-Prompt oder ein Dokument. Anbieter berechnen sie günstiger als neue Input-Tokens.

[Token](https://broadrouter.com/de/glossary/token/)

Ein Token ist die Texteinheit, die ein Sprachmodell liest und schreibt: ein Wort, ein Wortteil, ein Satzzeichen oder eine Bytefolge, die der Tokenizer des Modells erzeugt. LLM-APIs zählen, begrenzen und berechnen die Nutzung meist in Tokens.

[Eval (LLM-Evaluierung)](https://broadrouter.com/de/glossary/eval/)

Ein Eval (kurz für Evaluation) ist ein wiederholbarer Test eines Sprachmodells oder Prompts: eine feste Menge an Inputs, eine Beschreibung, wie ein guter Output aussieht, und ein Bewerter (Code, ein Mensch oder ein anderes Modell), der jeden Output benotet, damit sich Versionen vergleichen lassen.

[PII (personenbezogene Daten)](https://broadrouter.com/de/glossary/pii/)

PII (personally identifiable information) sind Informationen, mit denen sich die Identität einer Person unterscheiden oder zurückverfolgen lässt, etwa Name, Ausweisnummer oder biometrische Daten, plus weitere Informationen, die mit dieser Person verknüpft oder verknüpfbar sind. Der weitere Begriff der DSGVO lautet personenbezogene Daten. Bei LLMs entfernt PII-Schwärzung sie aus Prompts, bevor diese Ihre Systeme verlassen.

[Reasoning-Tokens](https://broadrouter.com/de/glossary/reasoning-tokens/)

Reasoning-Tokens sind Tokens, die ein Reasoning-Modell erzeugt, um ein Problem durchzuarbeiten, bevor es seine sichtbare Antwort schreibt. Sie werden meist als Output-Tokens berechnet, zählen zum Output-Limit und zum Kontextfenster und können von der API verborgen oder zusammengefasst werden.

[Tool Calling (Function Calling)](https://broadrouter.com/de/glossary/tool-calling/)

Tool Calling, auch Function Calling genannt, ist eine Funktion von LLM-APIs, bei der das Modell eine strukturierte Anfrage zurückgibt, eine vom Entwickler definierte Funktion mit JSON-Argumenten auszuführen. Die Anwendung führt die Funktion aus und sendet das Ergebnis zurück; das Modell selbst führt nie Code aus.

[Zero Data Retention (ZDR)](https://broadrouter.com/de/glossary/zero-data-retention/)

Zero Data Retention (ZDR) ist eine Datenrichtlinie, bei der ein KI-Anbieter Prompts und Outputs nur zur Bearbeitung einer Anfrage verarbeitet und diese Inhalte danach nicht speichert, weder in Logs noch in Caches oder Trainingsdaten. Inhaltsfreie Daten wie Token-Zahlen und Zeiten werden meist weiterhin aufbewahrt.

[API-Schlüssel (API Key)](https://broadrouter.com/de/glossary/api-key/)

Ein API-Schlüssel ist eine geheime Zeichenfolge, die einen Client beim Aufruf einer API identifiziert und autorisiert. LLM-APIs erwarten ihn meist im Header Authorization: Bearer, und wer den Schlüssel besitzt, kann Anfragen stellen, die dem Konto des Inhabers berechnet werden.

## 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.

## Weiterlesen

-   [LLM-API mit Zero Data Retention: Checkliste mit 10 Fragen](https://broadrouter.com/de/blog/zero-data-retention-llm-api-checklist/)
-   [Gecachte Input-Tokens: So senken Sie die Rechnung Ihrer LLM-API](https://broadrouter.com/de/blog/cached-input-tokens-explained/)
-   [LLM-API-Fehler 429 behandeln: Backoff, Jitter und Limiter](https://broadrouter.com/de/blog/handle-llm-api-429-rate-limits/)
-   [LLM-Streaming erklärt: SSE-Chunks, Deltas, Usage und Abbruch](https://broadrouter.com/de/blog/llm-streaming-sse-explained/)
-   [LLM-Antworten cachen, Kosten senken: ein Exact-Match-Cache in Python](https://broadrouter.com/de/blog/cache-llm-responses-cut-cost/)
-   [GPU-Hardware und Serving von BroadNet, wie BroadNet sie beschreibt](https://broadrouter.com/de/blog/broadnet-gpu-fleet-and-serving/)
-   [Menschliche Prüfung als festen Teil Ihres Dokumenten-KI-Workflows](https://broadrouter.com/de/blog/document-review-queues/)
-   [Anleitung: OpenAI Python SDK mit BroadNet Inference nutzen](https://broadrouter.com/de/guides/openai-python-sdk/)
-   [Anleitung: Chat Completions streamen und abgebrochene Verbindungen behandeln](https://broadrouter.com/de/guides/streaming-chat-completions/)
-   [Anleitung: API-Schlüssel per IP-Allowlist an Ihre Server binden](https://broadrouter.com/de/guides/api-keys-ip-allow-lists/)

Testen Sie es mit Ihrem echten Workload. Neue Konten starten mit USD 5 Guthaben für Gemma und Transkription. DeepSeek, GLM und Qwen3.8 erfordern eine Aufladung.

[Loslegen](https://inference.broadnet.ai/account/?utm_source=broadrouter&utm_medium=referral&utm_campaign=de-blog-llm-api-usage-logging&utm_content=page-cta) ·

**Quellen**

-   [API-Referenz von BroadNet Inference, Usage-Felder, Request-IDs und Aufbewahrung (auf Englisch)](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=de-blog-llm-api-usage-logging&utm_content=sources)
-   [Maschinenlesbare Preise von BroadNet Inference (pricing.json) (auf Englisch)](https://inference.broadnet.ai/pricing.json?utm_source=broadrouter&utm_medium=referral&utm_campaign=de-blog-llm-api-usage-logging&utm_content=sources)
-   [OWASP Logging Cheat Sheet, Daten, die nicht in Logs gehören](https://cheatsheetseries.owasp.org/cheatsheets/Logging_Cheat_Sheet.html)
-   [README von Microsoft Presidio, PII-Erkennung und ihre Grenzen (abgerufen am 2026-11-14)](https://github.com/microsoft/presidio)
-   [README von openai-python, Antwort-Header mit with\_raw\_response lesen](https://github.com/openai/openai-python)
