---
title: "LLM-Latenz erklärt: TTFT, Tokens/s und End-to-End | BroadRouter"
description: "Was Time to First Token, Tokens pro Sekunde und End-to-End-Latenz messen, wie Sie jede im Client mit Code messen und welche Maßnahme welche Zahl verbessert."
url: https://broadrouter.com/de/blog/llm-latency-ttft-throughput/
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-latency-ttft-throughput/) (aktualisiert am 2026-11-16).

# LLM-Latenz: TTFT vs. Tokens pro Sekunde vs. End-to-End-Zeit

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

Time to First Token (TTFT) ist die Wartezeit bis zum ersten Output-Token. Tokens pro Sekunde geben an, wie schnell die Antwort danach streamt. Die End-to-End-Latenz ist die Summe: TTFT plus Generierungszeit, also etwa Output-Tokens geteilt durch die Geschwindigkeit pro Nutzer. Prompt-Länge und Warteschlangen bestimmen die TTFT, Modellgröße und Last die Geschwindigkeit, die Antwortlänge die Gesamtzeit. Messen Sie alle drei bei p50 und p95.

## Das Wichtigste in Kürze

-   End-to-End-Latenz ≈ TTFT + (Output-Tokens − 1) × Inter-Token-Latenz, also etwa TTFT + Output-Tokens ÷ Tokens pro Sekunde pro Nutzer. Bei langen Antworten dominieren Geschwindigkeit und Länge, bei kurzen die TTFT.
-   Bei Reasoning-Modellen kommt das erste sichtbare Token erst nach dem Denken; messen Sie die Zeit bis zum ersten Content-Token also getrennt von der Zeit bis zum ersten Token.
-   Lange Prompts erhöhen die TTFT, weil das Modell zuerst den ganzen Prompt liest; gecachte Präfixe helfen meist.
-   Bei etwa 100 Tokens pro Sekunde wächst die Generierungszeit im Gleichschritt mit der Antwortlänge: zehnmal so viele Output-Tokens brauchen etwa zehnmal so lange zum Streamen.
-   Geben Sie p50 und p95 zusammen mit der Prompt-Länge an; ein Durchschnitt ohne Prompt-Größe ist nicht vergleichbar.

**Auf dieser Seite**

1.  Was sind TTFT, Tokens pro Sekunde und End-to-End-Latenz?
2.  Warum brauchen Reasoning-Modelle eine vierte Zahl?
3.  Wie messen Sie die Latenz im Client?
4.  Was verbessert jede Zahl tatsächlich?
5.  Wie verändert die Prompt-Länge den Kompromiss?
6.  Wo BroadNet Inference passt

„Die API ist langsam“ kann drei verschiedene Dinge bedeuten, und jedes hat eine andere Lösung. Ein Chat-Nutzer wartet auf das erste Wort. Ein Agent wartet auf den kompletten Tool-Aufruf. Ein Batch-Job interessiert sich für Tokens pro Stunde. Dieser Beitrag definiert die drei Zahlen, zeigt, wie Sie sie in Ihrem eigenen Code messen, und ordnet jeder Maßnahme die Zahl zu, die sie tatsächlich bewegt.

## Was sind TTFT, Tokens pro Sekunde und End-to-End-Latenz?

Der Benchmarking-Leitfaden von NVIDIA liefert saubere Definitionen, und sie decken sich mit dem, was Sie im Client beobachten können:

| Metrik | Was sie misst | Wer sie spürt | Bestimmt durch |
| --- | --- | --- | --- |
| [Time to First Token](https://broadrouter.com/de/glossary/time-to-first-token/) (TTFT) | Anfrage gesendet → erstes Token empfangen | Chat-Nutzer | Netzwerk, Warteschlange, Prompt-Länge (Prefill), Cache-Treffer |
| Inter-Token-Latenz (ITL) | Durchschnittlicher Abstand zwischen Tokens | Leser einer gestreamten Antwort | Modellgröße, Hardware, Serverlast |
| [Tokens pro Sekunde](https://broadrouter.com/de/glossary/tokens-per-second/) pro Nutzer | Output-Tokens nach dem ersten ÷ Generierungszeit (erstes bis letztes Token); entspricht 1 ÷ durchschnittliche ITL | Leser, Agenten | Wie bei ITL |
| End-to-End-Latenz | Anfrage gesendet → letztes Token empfangen | Agenten, APIs, Batch | TTFT + Generierungszeit |

Die Formel, die sie verbindet:

**End-to-End ≈ TTFT + (Output-Tokens − 1) × ITL ≈ TTFT + Output-Tokens ÷ Tokens pro Sekunde pro Nutzer**

Die Geschwindigkeit pro Nutzer ist nicht dasselbe wie der [Durchsatz](https://broadrouter.com/de/glossary/throughput/) des Servers, also alle Tokens, die ein Server über alle Nutzer hinweg erzeugt; ein Anbieter kann das eine steigern, während das andere sinkt.

Nehmen Sie die typische Geschwindigkeit, die BroadNet für sein Plan-Modell veröffentlicht, etwa 100 Tokens pro Sekunde. Die Generierungszeit wächst mit der Antwortlänge: Eine Code-Datei mit 4.000 Tokens braucht etwa achtzigmal so lange wie eine Klassifizierung mit 50 Tokens, während beide dieselbe TTFT abwarten. Bei kurzen Antworten macht die TTFT den Großteil der Wartezeit aus, bei langen sind es Geschwindigkeit und Länge.

## Warum brauchen Reasoning-Modelle eine vierte Zahl?

Reasoning-Modelle wie [DeepSeek V4.1 Flash](https://broadrouter.com/de/models/deepseek-v4.1-flash/) denken, bevor sie antworten, und auch das Denken besteht aus Output-Tokens. Verbringt das Modell 800 Tokens mit Reasoning bei etwa 100 Tokens pro Sekunde, wartet der Nutzer, bis alle 800 erzeugt sind, bevor das erste sichtbare Wort erscheint, selbst wenn die TTFT auf der Leitung schnell aussieht. Messen Sie die **Zeit bis zum ersten Content-Token** daher separat. Bei BroadNet Inference verkürzt `reasoning_effort: "low"` das Denken für einfache Schritte; der [Leitfaden zu Reasoning](https://broadrouter.com/de/guides/reasoning-tokens-empty-response/) erklärt den Kompromiss.

## Wie messen Sie die Latenz im Client?

Messen Sie dort, wo Ihre Nutzer sind, mit eingeschaltetem [Streaming](https://broadrouter.com/de/glossary/streaming/). Serverseitige Timer übersehen das Netzwerk und jeden Proxy.

```python
import os, time, statistics
from openai import OpenAI

client = OpenAI(base_url="https://inference.broadnet.ai/v1", api_key=os.environ["BROADNET_API_KEY"])

def timed(model, messages, max_tokens=1500):
    t0 = time.perf_counter()
    first = first_content = None
    usage = None
    stream = client.chat.completions.create(
        model=model, messages=messages, max_tokens=max_tokens,
        stream=True, stream_options={"include_usage": True},
    )
    for chunk in stream:
        now = time.perf_counter()
        if chunk.choices:
            if first is None:
                first = now
            if chunk.choices[0].delta.content and first_content is None:
                first_content = now
        if chunk.usage:
            usage = chunk.usage
    end = time.perf_counter()
    out = usage.completion_tokens if usage else 0
    return {
        "ttft": first - t0,
        "ttfct": (first_content or end) - t0,
        "e2e": end - t0,
        "tps": (out - 1) / (end - first) if out > 1 and end > first else 0,
        "prompt_tokens": usage.prompt_tokens if usage else None,
    }

runs = [timed("broadnet/gemma-4-26b-a4b", [{"role": "user", "content": "Summarise SSE in 100 words."}]) for _ in range(50)]
for k in ("ttft", "ttfct", "e2e", "tps"):
    xs = sorted(r[k] for r in runs)
    print(k, "p50", round(statistics.median(xs), 3), "p95", round(xs[int(len(xs) * 0.95) - 1], 3))
```

Fünf Regeln für einen fairen Benchmark:

1.  **Legen Sie die Prompt-Länge fest** und geben Sie sie an. Die TTFT bei 500 Prompt-Tokens und bei 200.000 sind verschiedene Zahlen. Der [Token-Zähler](https://broadrouter.com/tools/token-counter/) zeigt Ihnen, wie lang ein Test-Prompt ist, bevor Sie ihn senden.
2.  **Legen Sie die Output-Länge fest**, mit `max_tokens` und einem Prompt, der sie ausfüllt, damit Tokens pro Sekunde vergleichbar sind.
3.  **Geben Sie p50 und p95 an**, nicht den Mittelwert. An die Ausreißer erinnern sich die Nutzer.
4.  **Verteilen Sie die Läufe zeitlich.** Die Last ändert sich im Tagesverlauf.
5.  **Wärmen Sie zuerst auf.** Der erste Aufruf bezahlt DNS, TLS und Verbindungsaufbau; verwenden Sie einen Client wieder.

## Was verbessert jede Zahl tatsächlich?

| Zu verbessern | Maßnahme | Warum |
| --- | --- | --- |
| TTFT | Prompt-Präfix kürzen oder cachen | Die Prefill-Zeit wächst mit der Prompt-Länge; gecachte Präfixe sparen Arbeit |
| TTFT | Verbindungen warm halten, eine nahe Region nutzen | Entfernt Verbindungsaufbau und Round-Trips |
| Zeit bis zum ersten Content-Token | Reasoning-Aufwand senken oder für einfache Schritte ein Modell ohne Reasoning nutzen | Weniger verstecktes Denken vor der Antwort |
| Tokens pro Sekunde | Für den Schritt ein kleineres oder schnelleres Modell nutzen | Die Decode-Geschwindigkeit hängt von Modellgröße und Serving ab |
| End-to-End | Kürzeren Output anfordern (Schemas, Wortlimits) | Die Output-Länge multipliziert die ITL |
| End-to-End bei vielen Aufrufen | Unabhängige Aufrufe innerhalb Ihres [Parallelitätslimits](https://broadrouter.com/de/glossary/concurrency/) parallel ausführen | Die Gesamtdauer sinkt, auch wenn jeder Aufruf gleich bleibt |
| Gefühlte Latenz | An den Nutzer streamen | Er liest, während das Modell schreibt |

Die Output-Länge ist der am meisten unterschätzte Hebel. Wer „JSON mit diesen vier Feldern“ statt „erkläre deine Antwort“ anfordert, kann die Generierungszeit ohne jede Infrastrukturarbeit um eine Größenordnung senken. [Strukturierte Ausgabe](https://broadrouter.com/de/glossary/structured-output/) hilft dabei.

Den Cache-Hebel behandelt [Prompt-Struktur für Caching](https://broadrouter.com/de/blog/prompt-structure-for-caching/). Der Parallelitäts-Hebel stößt schnell an Rate Limits; siehe [429-Fehler behandeln](https://broadrouter.com/de/blog/handle-llm-api-429-rate-limits/).

## Wie verändert die Prompt-Länge den Kompromiss?

Die TTFT wächst mit dem Prompt, weil das Modell jedes Input-Token verarbeiten muss, bevor es schreiben kann. Das sind die versteckten Kosten sehr langer Prompts und Teil der Entscheidung [Long Context vs. RAG](https://broadrouter.com/de/blog/long-context-vs-rag/): Ein Prompt mit 1 Mio. Tokens beantwortet Fragen, die RAG nicht beantworten kann, beginnt aber langsamer. Wenn interaktive Geschwindigkeit zählt, halten Sie den Hot Path kurz und senden den großen Kontext nur, wenn die Frage ihn braucht.

## Wo BroadNet Inference passt

BroadNet veröffentlicht für sein Plan-Modell eine typische Geschwindigkeit von etwa 100 Tokens pro Sekunde und streamt im Standard-SSE-Format, der Code oben funktioniert also unverändert. Es veröffentlicht weder TTFT-Werte noch Latenz-SLAs; messen Sie daher mit Ihren eigenen Prompts, bevor Sie sich festlegen. Eine [Meteor-Stunde](https://inference.broadnet.ai/plans?utm_source=broadrouter&utm_medium=referral&utm_campaign=de-blog-llm-latency-ttft-throughput&utm_content=body) für $1 reicht für einen Benchmark mit 50 Läufen, und das Startguthaben deckt einen auf Gemma 4 VL 26B. Wenn Sie garantierte Latenz unter einer Sekunde in großem Maßstab brauchen, testen Sie sorgfältig: Ein Pay-as-you-go-Schlüssel erlaubt 4 gleichzeitige Anfragen, was eher zu Apps und Agenten passt als zu Echtzeit-Serving mit hohem Volumen. Modelle und ihre Preise stehen auf den Seiten [Modelle](https://broadrouter.com/de/models/) und [Preise](https://broadrouter.com/de/pricing/).

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

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

[Time to First Token (TTFT)](https://broadrouter.com/de/glossary/time-to-first-token/)

Time to First Token (TTFT) ist die Zeit vom Senden einer Anfrage an ein Sprachmodell bis zum Eintreffen des ersten Output-Tokens. Sie umfasst Netzwerkzeit, Warteschlange auf dem Server und Prefill, den Schritt, in dem das Modell den ganzen Prompt liest; sie wächst daher mit Prompt-Länge und Last.

[Latenz (LLM)](https://broadrouter.com/de/glossary/latency/)

Latenz ist bei einer Sprachmodell-API die Zeit, die eine Anfrage vom Senden bis zum Empfang des letzten Output-Tokens braucht. Sie ist die Summe aus Time to First Token und Generierungszeit und wird meist als Perzentile wie p50 und p95 angegeben statt als Durchschnitt.

[Input- und Output-Tokens](https://broadrouter.com/de/glossary/input-and-output-tokens/)

Input-Tokens sind die Tokens, die ein Sprachmodell in einer Anfrage liest, einschließlich System-Prompt, Gesprächsverlauf, Tool-Definitionen und Bildern. Output-Tokens sind die Tokens, die es als Antwort erzeugt, einschließlich Reasoning. LLM-APIs berechnen beide meist getrennt, und Output ist in der Regel teurer.

[Tokens pro Sekunde (TPS)](https://broadrouter.com/de/glossary/tokens-per-second/)

Tokens pro Sekunde (TPS) sind die Rate, mit der ein Sprachmodell Output-Tokens erzeugt, meist gemessen für eine Anfrage nach Ankunft ihres ersten Tokens. Sie bestimmen, wie schnell eine Antwort streamt, sobald sie begonnen hat. Über alle gleichzeitigen Anfragen addiert ergibt sich der Systemdurchsatz; die Wartezeit bis zum ersten Token wird getrennt gemessen.

[Concurrency (Parallelität)](https://broadrouter.com/de/glossary/concurrency/)

Concurrency (Parallelität) ist die Zahl der Anfragen, die ein Client gleichzeitig offen hat. LLM-APIs begrenzen sie oft pro Schlüssel oder Plan, getrennt von den Anfragen pro Minute, weil jede offene Anfrage GPU-Kapazität belegt, bis ihre Antwort fertig ist.

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

[Durchsatz (Throughput)](https://broadrouter.com/de/glossary/throughput/)

Durchsatz (Throughput) ist beim Betrieb von LLMs die gesamte Arbeit, die ein System pro Zeiteinheit über alle gleichzeitigen Anfragen erledigt, meist gemessen in Output-Tokens pro Sekunde oder Anfragen pro Sekunde. Er unterscheidet sich von der Geschwindigkeit pro Stream, also davon, wie schnell eine einzelne Anfrage ihre Tokens erhält.

## Häufige Fragen

### Was ist eine gute Time to First Token für eine LLM-API?

Für Chat fühlt sich bei kurzen Prompts alles unter etwa einer Sekunde reaktionsschnell an. Lange Prompts und Reasoning-Modelle brauchen konstruktionsbedingt länger. Vergleichen Sie die TTFT nur bei gleicher Prompt-Länge und gleichem Modell.

### Sind Tokens pro Sekunde dasselbe wie Durchsatz?

Nicht ganz. Tokens pro Sekunde pro Nutzer geben an, wie schnell eine Antwort streamt. Durchsatz sind alle Tokens, die ein Server über alle Nutzer hinweg erzeugt. Ein Anbieter kann den Gesamtdurchsatz steigern, während die Geschwindigkeit jedes einzelnen Nutzers sinkt.

### Warum ist die TTFT bei einem Reasoning-Modell so hoch?

Das Modell erzeugt vor der sichtbaren Antwort versteckte Reasoning-Tokens. Das erste Token kann schnell ankommen, aber das erste Content-Token wartet, bis das Denken fertig ist. Senken Sie reasoning\_effort für einfache Aufgaben.

### Verringert Streaming die Latenz?

Die End-to-End-Zeit verkürzt es nicht. Es lässt den Nutzer die Antwort lesen, während sie noch geschrieben wird; die gefühlte Latenz sinkt so auf etwa die TTFT.

### Wie viele Anfragen brauche ich für einen verlässlichen Latenz-Benchmark?

Genug, um die Ausreißer zu sehen. Fünfzig bis hundert Anfragen pro Prompt-Größe ergeben ein brauchbares p95. Verteilen Sie sie über den Tag, weil sich die Last ändert.

## Weiterlesen

-   [LLM-Streaming erklärt: SSE-Chunks, Deltas, Usage und Abbruch](https://broadrouter.com/de/blog/llm-streaming-sse-explained/)
-   [Prompts so strukturieren, dass das Präfix gecacht wird](https://broadrouter.com/de/blog/prompt-structure-for-caching/)
-   [Long Context vs. RAG: Wann 1M Tokens die Vektordatenbank ersetzen](https://broadrouter.com/de/blog/long-context-vs-rag/)
-   [GPU-Hardware und Serving von BroadNet, wie BroadNet sie beschreibt](https://broadrouter.com/de/blog/broadnet-gpu-fleet-and-serving/)
-   [LLM-Antworten cachen, Kosten senken: ein Exact-Match-Cache in Python](https://broadrouter.com/de/blog/cache-llm-responses-cut-cost/)
-   [Anleitung: Chat Completions streamen und abgebrochene Verbindungen behandeln](https://broadrouter.com/de/guides/streaming-chat-completions/)
-   [Anleitung: Warum ein Reasoning-Modell eine leere Antwort liefert](https://broadrouter.com/de/guides/reasoning-tokens-empty-response/)

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-latency-ttft-throughput&utm_content=page-cta) ·

**Quellen**

-   [Benchmarking-Leitfaden von NVIDIA NIM, Metriken für LLM-Latenz und -Durchsatz (abgerufen am 2026-11-14)](https://docs.nvidia.com/nim/benchmarking/llm/metrics)
-   [Pläne von BroadNet Inference, typische Geschwindigkeit (geprüft am 2026-11-15) (auf Englisch)](https://inference.broadnet.ai/plans?utm_source=broadrouter&utm_medium=referral&utm_campaign=de-blog-llm-latency-ttft-throughput&utm_content=sources)
-   [API-Referenz von BroadNet Inference, Streaming und Reasoning (geprüft am 2026-11-15) (auf Englisch)](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=de-blog-llm-latency-ttft-throughput&utm_content=sources)
-   [Baseten Inference Engineering, Latenz und Durchsatz messen (geprüft am 2026-11-16)](https://www.baseten.co/inference-engineering/book/01-prerequisites/measuring-latency-and-throughput/)
