---
title: "max_tokens bei Reasoning-Modellen richtig budgetieren"
description: "Warum Reasoning-Modelle bei kleinem max_tokens leer antworten und wie Sie das Budget aus Perzentilen, Kontextfenster und eskalierendem Retry bemessen."
url: https://broadrouter.com/de/blog/reasoning-model-max-tokens-budget/
lang: de
updated: 2026-11-15
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/reasoning-model-max-tokens-budget/) (aktualisiert am 2026-11-15).

# max\_tokens für Reasoning-Modelle festlegen: eine Budgetmethode

Vom Team von BroadNet Inference · 6 Min. Lesezeit · Veröffentlicht 2026-11-15

Bei einem Reasoning-Modell begrenzt max\_tokens Denken und Antwort zusammen, ein knappes Limit kann die Antwort also vor jedem sichtbaren Text beenden. Messen Sie die gesamten Completion-Tokens pro Aufgabentyp, setzen Sie max\_tokens auf etwa das 95. Perzentil plus 20 %, halten Sie Prompt plus max\_tokens im Kontextfenster und wiederholen Sie abgeschnittene Antworten mit doppeltem Budget bis zu einer harten Obergrenze.

## Das Wichtigste in Kürze

-   max\_tokens ist eine Obergrenze, keine Gebühr. Sie zahlen für erzeugte Tokens, eine großzügige Obergrenze kostet bei früh endenden Antworten also nichts.
-   Teuer ist eine knappe Obergrenze: Eine abgeschnittene Antwort rechnet ihr Denken ab, liefert keine Antwort und muss erneut gesendet werden.
-   Budgetieren Sie pro Aufgabentyp aus Ihren eigenen Logs: Das 95. Perzentil der Completion-Tokens plus 20 % Puffer ist ein solider Start.
-   Prompt-Tokens plus max\_tokens müssen ins Kontextfenster passen: 262.144 Tokens bei Qwen3.8 27B, 1.048.576 bei GLM 5.3 und DeepSeek V4.1 Flash.
-   Werten Sie finish\_reason „length“ als Signal: Wiederholen Sie mit doppeltem Budget oder niedrigerem reasoning\_effort, mit harter Obergrenze.

**Auf dieser Seite**

1.  Warum ist das Budget vor der Antwort aufgebraucht?
2.  Kostet ein größeres max\_tokens mehr?
3.  Wie messen Sie, was eine Aufgabe braucht?
4.  Wie begrenzt das Kontextfenster das Budget?
5.  Was tun, wenn eine Antwort trotzdem abgeschnitten wird?
6.  Was ändert Streaming?
7.  Welchen Parameternamen sollten Sie senden?
8.  Wo BroadNet Inference passt

Ein Reasoning-Modell denkt nach, bevor es antwortet, und bei den meisten OpenAI-kompatiblen APIs kommt beides aus einem Budget: `max_tokens`. Setzen Sie es wie bei einem Modell ohne Reasoning, also ein paar hundert Tokens für eine kurze Antwort, kommen manche Antworten leer mit `finish_reason: "length"` zurück. Die schnelle Lösung steht unter [warum ein Reasoning-Modell eine leere Antwort liefert](https://broadrouter.com/de/guides/reasoning-tokens-empty-response/). Dieser Beitrag zeigt die Methode hinter einem Budget, dem Sie vertrauen können: messen, aus Perzentilen bemessen, das Kontextfenster beachten und mit den Antworten umgehen, die trotzdem abgeschnitten werden.

Was Reasoning kostet und wie Sie es senken, lesen Sie unter [Reasoning-Tokens: warum Sie für mehr Output zahlen, als Sie sehen](https://broadrouter.com/de/blog/reasoning-tokens-cost/).

## Warum ist das Budget vor der Antwort aufgebraucht?

Das Modell erzeugt der Reihe nach: erst das Reasoning, dann die sichtbare Antwort. Jedes Token von beidem zählt zu `max_tokens`. Die Doku von BroadNet sagt das für DeepSeek V4.1 Flash, GLM 5.3 und Qwen3.8 27B: „the reasoning counts toward max\_tokens“ (Übersetzung: das Reasoning zählt zu max\_tokens), und bei einem kleinen Limit „the answer comes back empty“ (Übersetzung: die Antwort kommt leer zurück). Die Chat-Completions-Referenz von OpenAI definiert `max_completion_tokens` genauso, als Obergrenze „including visible output tokens and reasoning tokens“ (Übersetzung: einschließlich sichtbarer Output-Tokens und Reasoning-Tokens).

Die richtige Frage lautet also nicht „Wie lang ist meine Antwort?“, sondern „Wie lang sind Reasoning und Antwort zusammen, bei dieser Aufgabe, mit diesem Effort?“ Das schwankt stärker, als viele erwarten. Laut dem Leitfaden von OpenAI können seine Modelle je nach Problem „anywhere from a few hundred to tens of thousands of reasoning tokens“ (Übersetzung: zwischen einigen hundert und zehntausenden Reasoning-Tokens) erzeugen.

## Kostet ein größeres max\_tokens mehr?

Nein. Das ist der häufigste Grund für zu knappe Budgets. [`max_tokens`](https://broadrouter.com/de/glossary/max-tokens/) ist eine Obergrenze. Abgerechnet werden die tatsächlich erzeugten Tokens. Eine Antwort, die 1.800 Tokens braucht, kostet bei einer Obergrenze von 4.000 genauso viel wie bei 40.000.

Was eine knappe Obergrenze kostet:

| Obergrenze vs. Bedarf | Was Sie zahlen | Was Sie bekommen |
| --- | --- | --- |
| Obergrenze über dem Bedarf | Erzeugte Tokens | Die Antwort |
| Obergrenze unter dem Bedarf | Die volle Obergrenze, komplett Reasoning | Nichts Brauchbares, dazu ein Retry |

Ein Beispiel: Angenommen, ein Viertel Ihrer Aufrufe braucht mehr als 1.000 Tokens. Mit `max_tokens=1000` rechnet jeder dieser Aufrufe 1.000 Output-Tokens Denken ab, liefert nichts und wird wiederholt. Das sind im Schnitt 250 verschwendete Output-Tokens pro Aufruf über alle Aufrufe, noch vor den Retries selbst, plus die Latenz einer zweiten Anfrage. Mit einer Obergrenze von 4.000 wird nichts verschwendet. Bei [Qwen3.8 27B](https://broadrouter.com/de/models/qwen3.8-27b/) kostet Output $2.17 pro 1 Mio. Tokens, die Verschwendung summiert sich bei Volumen also.

Das eigentliche Risiko einer hohen Obergrenze ist eine ausufernde Antwort: ein Modell, das in eine Schleife gerät oder zu viel nachdenkt und weit mehr als nötig erzeugt. Eine harte Obergrenze begrenzt das. Wählen Sie sie anhand von Daten, wie unten beschrieben.

## Wie messen Sie, was eine Aufgabe braucht?

Lassen Sie echte Prompts eines Aufgabentyps mit großzügiger Obergrenze laufen und erfassen Sie die Completion-Tokens und den Reasoning-Anteil. Wenn das Modell es meldet, liefert `usage.completion_tokens_details.reasoning_tokens` den Reasoning-Teil; die Doku von BroadNet listet dieses Feld.

```python
import os
from openai import OpenAI

client = OpenAI(base_url="https://inference.broadnet.ai/v1", api_key=os.environ["BROADNET_API_KEY"])
MODEL = "broadnet/qwen3.8-27b"

def measure(prompts, ceiling=16_000, **kw):
    """Run real prompts with a generous ceiling and return per-call token counts."""
    rows = []
    for p in prompts:
        r = client.chat.completions.create(model=MODEL, max_tokens=ceiling,
                                           messages=[{"role": "user", "content": p}], **kw)
        u, d = r.usage, r.usage.completion_tokens_details
        reasoning = (d.reasoning_tokens or 0) if d else 0
        rows.append({"reasoning": reasoning, "answer": u.completion_tokens - reasoning,
                     "finish": r.choices[0].finish_reason})
    return rows

def pct(values, q):
    values = sorted(values)
    return values[min(len(values) - 1, int(q * len(values)))]

def recommend(rows, margin=1.2):
    total = [r["reasoning"] + r["answer"] for r in rows]
    return {"p50": pct(total, 0.5), "p95": pct(total, 0.95), "max": max(total),
            "max_tokens": int(pct(total, 0.95) * margin),
            "cut_off": sum(r["finish"] == "length" for r in rows)}

# print(recommend(measure(my_prompts)))                       # default effort
# print(recommend(measure(my_prompts, reasoning_effort="low")))
```

Regeln für eine Zahl, der Sie vertrauen können:

1.  **Ein Aufgabentyp pro Durchlauf.** Klassifikation, Extraktion, Code-Review und Planung haben sehr unterschiedliche Verteilungen. Ein globales `max_tokens` verschwendet entweder Geld für Retries oder lässt ausufernde Antworten durch.
2.  **50 oder mehr echte Prompts.** Das 95. Perzentil von zehn Stichproben ist einfach die größte davon.
3.  **Bei jedem genutzten Effort messen.** `reasoning_effort="low"` verändert die Verteilung. BroadNet dokumentiert `low`; testen Sie andere Werte, bevor Sie sich darauf verlassen.
4.  **Ist `cut_off` nicht null, Obergrenze erhöhen und erneut messen.** Eine abgeschnittene Stichprobe verbirgt ihre wahre Länge.
5.  **Neu messen, wenn sich Modell oder Prompt ändert.** Eine neue Modellversion kann mehr oder weniger nachdenken.

Setzen Sie dann `max_tokens` pro Aufgabe anhand von `recommend()`. Das 95. Perzentil plus 20 % lässt die meisten Aufrufe deutlich unter der Obergrenze und schickt nur den seltenen langen Fall in den Retry-Pfad unten. Das kostenlose [Tool für Reasoning-Token-Budgets](https://broadrouter.com/tools/reasoning-token-budget/) erledigt diese Rechnung in Ihrem Browser, sobald Sie Ihre Zahlen haben.

## Wie begrenzt das Kontextfenster das Budget?

Das Kontextfenster fasst Prompt und Antwort zusammen. Der Preis-Feed von BroadNet definiert `context_length` als „the most tokens one request can hold, prompt and answer together“ (Übersetzung: die maximale Zahl an Tokens, die eine Anfrage fassen kann, Prompt und Antwort zusammen). Also:

**max\_tokens ≤ Kontextlänge − Prompt-Tokens**

| Modell | Kontext | Platz für max\_tokens bei einem Prompt von 200.000 Tokens |
| --- | --- | --- |
| [GLM 5.3](https://broadrouter.com/de/models/glm-5.3/) | 1.048.576 | 848.576 |
| [DeepSeek V4.1 Flash](https://broadrouter.com/de/models/deepseek-v4.1-flash/) | 1.048.576 | 848.576 |
| Qwen3.8 27B | 262.144 | 62.144 |

Das zählt bei Arbeit mit langem Kontext. Ein Agent, dessen Verlauf bei Qwen3.8 27B auf 250.000 Tokens angewachsen ist, hat nur noch etwa 12.000 Tokens für Denken und Antwort. Aufgaben mit langem Kontext brauchen zudem oft mehr Reasoning; prüfen Sie den verbleibenden Platz also im Moment des Aufrufs, nicht einmalig beim Start. [Kontextfenster](https://broadrouter.com/de/glossary/context-window/) und der [Kontextfenster-Rechner](https://broadrouter.com/tools/context-window-calculator/) helfen bei der Einschätzung.

## Was tun, wenn eine Antwort trotzdem abgeschnitten wird?

Prüfen Sie `finish_reason` bei jedem Aufruf. Ist es `length`, fehlt die Antwort oder ist unvollständig, selbst wenn `content` etwas Text enthält. Parsen Sie sie nicht, als wäre sie vollständig; ein abgeschnittenes JSON-Objekt ist eine häufige Fehlerquelle weiter hinten in der Pipeline ([Structured Output](https://broadrouter.com/de/blog/structured-output-json-schema/)).

Wiederholen Sie mit doppeltem Budget, innerhalb des Platzes, den der Kontext lässt, bis zu einer harten Obergrenze:

```python
import json, urllib.request

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

def ask(model, messages, budget=4_000, hard_cap=32_000, **kw):
    """Retry a cut-off reply with a doubled budget, never past the cap or the context window."""
    while True:
        r = client.chat.completions.create(model=model, messages=messages,
                                           max_tokens=budget, **kw)
        if r.choices[0].finish_reason != "length":
            return r
        room = CONTEXT[model] - r.usage.prompt_tokens        # context holds prompt + answer
        nxt = min(budget * 2, hard_cap, room)
        if nxt <= budget:
            raise RuntimeError(f"still cut off at max_tokens={budget}")
        print(f"cut off at {budget}, retrying with {nxt}")
        budget = nxt
```

Zwei Alternativen zum Verdoppeln, je nach Aufgabe:

-   **Retry mit `reasoning_effort="low"`** bei gleichem Budget. Bei einfachen Aufgaben denkt das Modell oft zu viel nach, und weniger Effort löst das ohne höhere Obergrenze.
-   **Die Aufgabe aufteilen.** Stößt eine Antwort immer wieder an eine hohe Obergrenze, verlangt die Anfrage meist zu viel auf einmal.

Loggen Sie jede abgeschnittene Antwort mit dem Aufgabentyp. Eine steigende Rate bedeutet, dass sich Prompt, Modell oder Eingabedaten geändert haben und das Budget neu gemessen werden muss. Retries sind neue Inferenzen und werden erneut abgerechnet; begrenzen Sie die Versuche also, wie unter [lang laufende Agenten: Timeouts und Retries](https://broadrouter.com/de/blog/long-running-agents-timeouts-retries/) beschrieben.

## Was ändert Streaming?

Mit `stream=True` läuft das Reasoning vor dem ersten sichtbaren Token, ein Reasoning-Modell kann am Anfang also wie hängend wirken. Zeigen Sie in einer Chat-Oberfläche einen „Denkt nach“-Zustand, bis Inhalt ankommt, und bemessen Sie Client-Timeouts für die Denkzeit, nicht nur für die Antwort.

Manche Server streamen auch den Reasoning-Text selbst, in einem eigenen Feld. Der Name ist nicht standardisiert: Die API von DeepSeek nutzt `reasoning_content`, und vLLM hat sein Feld von `reasoning_content` in `reasoning` umbenannt, mit der Warnung, dass alter Client-Code „could silently read an empty“ (Übersetzung: stillschweigend ein leeres) Feld lesen könnte. Die Doku von BroadNet dokumentiert kein Feld für Reasoning-Text; bauen Sie also keine Funktionen darauf, ohne die Rohantwort Ihres Modells zu prüfen. Wenn Sie es lesen, dann defensiv:

```python
for chunk in stream:
    if chunk.choices:
        delta = chunk.choices[0].delta
        thinking = getattr(delta, "reasoning", None) or getattr(delta, "reasoning_content", None)
        # log or display `thinking` only if your provider actually sends it
        if delta.content:
            print(delta.content, end="")
    elif chunk.usage:                                  # last chunk, with include_usage
        print("\nreasoning tokens:", getattr(chunk.usage.completion_tokens_details, "reasoning_tokens", None))
```

Die Usage im letzten Chunk erfordert `stream_options={"include_usage": True}`, was BroadNet dokumentiert. Mehr zu Streams im [Streaming-Leitfaden](https://broadrouter.com/de/guides/streaming-chat-completions/) und unter [SSE erklärt](https://broadrouter.com/de/blog/llm-streaming-sse-explained/).

## Welchen Parameternamen sollten Sie senden?

| API | Parameter | Enthält Reasoning |
| --- | --- | --- |
| OpenAI Chat Completions | `max_completion_tokens` (`max_tokens` veraltet) | Ja |
| OpenAI Responses | `max_output_tokens` | Ja |
| BroadNet Inference (Chat Completions) | `max_tokens`, wie dokumentiert | Ja |
| vLLM-Server | `max_tokens`, optional `thinking_token_budget` | Ja |

Wenn Sie Code zwischen Anbietern verschieben, senden Sie den Namen, den der Anbieter dokumentiert, und bestätigen Sie mit einem Testaufruf, dass das Limit greift. Ein stillschweigend ignoriertes Limit sieht gut aus, bis eine ausufernde Antwort kommt. Die [Migrations-Checkliste](https://broadrouter.com/de/blog/openai-compatible-api-migration-checklist/) behandelt die anderen Parameter, die sich ändern.

## Wo BroadNet Inference passt

Die drei Reasoning-Modelle von BroadNet melden Reasoning-Tokens in `usage`, wenn das Modell sie liefert; die Messung oben funktioniert also wie geschrieben. DeepSeek V4.1 Flash und GLM 5.3 bieten mit 1.048.576 Tokens Kontext den meisten Platz. Qwen3.8 27B hat 262.144. Brauchen Sie für eine Aufgabe kein Reasoning, ist [Gemma 4 VL 26B](https://broadrouter.com/de/models/gemma-4-vl-26b/) nicht als Reasoning-Modell gelistet und umgeht die Budgetfrage ganz. Bei einem [DeepSeek-V4.1-Flash-Plan](https://broadrouter.com/de/guides/unlimited-llm-api-sessions/) zum Festpreis kosten Denk-Tokens nichts pro Token, abgeschnittene Antworten kosten aber trotzdem Zeit; dieselbe Budgetierung gilt also. BroadNet dokumentiert keine separate Reasoning-Grenze; wenn Sie eine brauchen, nutzen Sie einen Anbieter oder selbst gehosteten Server, der sie bietet.

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.

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

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

[Kontextfenster (Context Window)](https://broadrouter.com/de/glossary/context-window/)

Das Kontextfenster ist die maximale Anzahl an Tokens, mit der ein Sprachmodell in einer einzelnen Anfrage arbeiten kann. Es umfasst Prompt, Gesprächsverlauf, Tool-Definitionen, Bilder und den erzeugten Output einschließlich Reasoning-Tokens. Was nicht hineinpasst, muss gekürzt, zusammengefasst oder auf mehrere Anfragen verteilt werden.

[max\_tokens](https://broadrouter.com/de/glossary/max-tokens/)

max\_tokens ist ein Parameter von LLM-APIs, der festlegt, wie viele Tokens ein Modell in einer Antwort höchstens erzeugen darf. Erreicht die Generierung das Limit, bricht sie ab, und die Antwort wird als abgeschnitten markiert, zum Beispiel mit finish\_reason „length“.

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

[Chat Completions API](https://broadrouter.com/de/glossary/chat-completions-api/)

Die Chat Completions API ist der HTTP-Endpoint von OpenAI, POST /v1/chat/completions, der einen Modellnamen und eine Liste von Nachrichten mit Rollen entgegennimmt und die nächste Nachricht des Modells zurückgibt. Ihr Format für Anfrage und Antwort wurde zum gemeinsamen Standard, den OpenAI-kompatible Anbieter und SDKs übernehmen.

[Request-Timeout (Zeitüberschreitung)](https://broadrouter.com/de/glossary/request-timeout/)

Ein Request-Timeout ist die längste Zeit, die ein HTTP-Client auf einen Server wartet, bevor er die Anfrage aufgibt. Clients teilen ihn meist in einen Connect-Timeout für den Verbindungsaufbau und einen Read-Timeout für das Warten auf Daten. LLM-Aufrufe brauchen großzügige Read-Timeouts, weil lange Antworten Zeit kosten.

## Häufige Fragen

### Warum gibt mein Reasoning-Modell eine leere Antwort zurück?

Das Modell hat das gesamte max\_tokens-Budget für verdecktes Reasoning verbraucht, bevor es die Antwort schrieb. finish\_reason ist dann „length“. Erhöhen Sie max\_tokens, senken Sie reasoning\_effort oder beides. Ein kurzer Leitfaden mit der schnellen Lösung ist in diesem Beitrag verlinkt.

### Welches max\_tokens sollte ich bei einem Reasoning-Modell setzen?

Erst messen. Lassen Sie 50 oder mehr echte Prompts mit großzügiger Obergrenze laufen, nehmen Sie das 95. Perzentil von completion\_tokens für diese Aufgabe und schlagen Sie etwa 20 % auf. Die Doku von BroadNet nennt 1.000 Tokens oder mehr als Untergrenze; OpenAI empfiehlt, für den Einstieg bei seinen Modellen 25.000 zu reservieren.

### Kostet ein höheres max\_tokens mehr?

Nicht an sich. Abgerechnet werden die Tokens, die das Modell erzeugt, nicht die Obergrenze. Eine höhere Obergrenze kostet nur dann mehr, wenn eine Antwort sonst abgeschnitten worden wäre, und dann hätte Sie die abgeschnittene Antwort ohnehin einen Retry gekostet.

### Ist max\_completion\_tokens dasselbe wie max\_tokens?

Bei OpenAI ersetzt max\_completion\_tokens das veraltete max\_tokens und schließt Reasoning-Tokens ausdrücklich ein. Viele OpenAI-kompatible Anbieter dokumentieren stattdessen max\_tokens. Die Doku von BroadNet verwendet max\_tokens und sagt, dass Reasoning dazu zählt.

### Kann ich das Reasoning getrennt von der Antwort begrenzen?

Nur, wo der Server das unterstützt. vLLM hat einen Parameter thinking\_token\_budget, und manche Anbieter haben eigene. BroadNet dokumentiert reasoning\_effort mit low, aber keine separate Reasoning-Grenze; budgetieren Sie beides also gemeinsam.

## Weiterlesen

-   [Reasoning-Tokens: Warum Sie mehr Output zahlen, als Sie sehen](https://broadrouter.com/de/blog/reasoning-tokens-cost/)
-   [LLM-Streaming erklärt: SSE-Chunks, Deltas, Usage und Abbruch](https://broadrouter.com/de/blog/llm-streaming-sse-explained/)
-   [JSON Mode vs. json\_schema: strukturierte Ausgabe, die hält](https://broadrouter.com/de/blog/structured-output-json-schema/)
-   [Lang laufende Agenten: Timeouts, Retries und Checkpoints, die halten](https://broadrouter.com/de/blog/long-running-agents-timeouts-retries/)
-   [Wechsel zu einer OpenAI-kompatiblen API: die Migrations-Checkliste](https://broadrouter.com/de/blog/openai-compatible-api-migration-checklist/)
-   [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: Warum ein Reasoning-Modell eine leere Antwort liefert](https://broadrouter.com/de/guides/reasoning-tokens-empty-response/)
-   [Anleitung: Chat Completions streamen und abgebrochene Verbindungen behandeln](https://broadrouter.com/de/guides/streaming-chat-completions/)
-   [Anleitung: OpenAI Python SDK mit BroadNet Inference nutzen](https://broadrouter.com/de/guides/openai-python-sdk/)

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-reasoning-model-max-tokens-budget&utm_content=page-cta) ·

**Quellen**

-   [API-Referenz von BroadNet Inference: Reasoning zählt zu max\_tokens, 1.000 Tokens oder mehr, reasoning\_effort low, usage-Felder (geprüft am 2026-11-15) (auf Englisch)](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=de-blog-reasoning-model-max-tokens-budget&utm_content=sources)
-   [Feldreferenz zu pricing.json von BroadNet: context\_length umfasst Prompt und Antwort zusammen (geprüft am 2026-11-15) (auf Englisch)](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=de-blog-reasoning-model-max-tokens-budget&utm_content=sources#pricing-json)
-   [Reasoning-Leitfaden von OpenAI: unvollständige Antworten, zu Beginn mindestens 25.000 Tokens reservieren (geprüft am 2026-11-15)](https://developers.openai.com/api/docs/guides/reasoning)
-   [Chat-Completions-Referenz von OpenAI: max\_completion\_tokens enthält Reasoning-Tokens; max\_tokens veraltet (geprüft am 2026-11-15)](https://developers.openai.com/api/reference/resources/chat/subresources/completions/methods/create)
-   [API-Doku von DeepSeek, Thinking Mode: Feld reasoning\_content, Effort-Stufen (geprüft am 2026-11-15)](https://api-docs.deepseek.com/guides/thinking_mode)
-   [vLLM-Doku, Reasoning Outputs: Feld reasoning (früher reasoning\_content), thinking\_token\_budget (geprüft am 2026-11-15)](https://docs.vllm.ai/en/latest/features/reasoning_outputs.html)
