---
title: "Ungültiges JSON vom LLM: Ursachen, Reparatur und Retry"
description: "Warum LLMs kaputtes JSON liefern (Code-Fences, Fließtext, Abbruch bei max_tokens, Kommas) und eine getestete Python-Funktion, die nur Eindeutiges repariert."
url: https://broadrouter.com/de/blog/fix-invalid-json-from-llm/
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/fix-invalid-json-from-llm/) (aktualisiert am 2026-11-16).

# Ungültiges JSON vom LLM reparieren: Ursachen, Reparatur, Retry

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

Prüfen Sie zuerst finish\_reason: Eine bei max\_tokens abgeschnittene Antwort lässt sich nicht sicher reparieren, also Limit erhöhen und neu senden. Sonst entfernen Sie Code-Fences und umgebenden Text, dekodieren den ersten JSON-Wert und beheben nur eindeutige Fehler wie nachgestellte Kommas. Validieren Sie gegen ein Schema und senden Sie bei einem Fehler ein- oder zweimal die exakte Meldung zurück. Structured Output verhindert das meiste davon, wo unterstützt.

## Das Wichtigste in Kürze

-   Meist ist nicht das JSON kaputt, sondern die Verpackung: eine Code-Fence, ein Satz davor oder danach, ein Reasoning-Block. raw\_decode in Python liest den ersten Wert und ignoriert den Rest.
-   finish\_reason "length" bedeutet, dass das JSON abgeschnitten wurde. Klammern zu schließen macht es parsebar, verliert aber still Daten. Senden Sie stattdessen mit mehr Platz neu.
-   Reparieren Sie nur, was genau eine Bedeutung hat: nachgestellte Kommas, Python-Syntax wie True/None und einfache Anführungszeichen. Alles andere ablehnen und neu anfragen.
-   Das json-Modul von Python akzeptiert standardmäßig NaN und Infinity; RFC 8259 nicht. Lehnen Sie sie ab, sonst scheitern nachgelagerte Parser.
-   Bei BroadNet Inference dokumentieren nur GLM 5.3 und Qwen3.8 27B strukturierte Ausgabe. Bei den anderen Modellen nutzen Sie JSON per Prompt plus diese Reparatur und Validierung.

**Auf dieser Seite**

1.  Warum liefern LLMs ungültiges JSON?
2.  Warum kein abgeschnittenes JSON reparieren?
3.  Eine Reparaturfunktion, die nur die sicheren Fälle behebt
4.  Wie sollten Sie neu anfragen, wenn die Reparatur scheitert?
5.  Macht strukturierte Ausgabe das überflüssig?
6.  Wo BroadNet Inference ins Bild passt

Ihr Code ruft `json.loads()` auf einer Modellantwort auf und bekommt `JSONDecodeError: Expecting value: line 1 column 1`. Oder das Parsen klappt, aber ein Feld ist ein String, wo Sie eine Zahl erwartet haben. Dieser Beitrag sortiert die Ursachen danach, was Sie jeweils gefahrlos tun können, liefert eine getestete Python-Funktion, die nur die eindeutigen Fälle repariert, und zeigt eine Retry-Schleife, die weiß, wann ein neuer Versuch nichts bringt.

Die Wahl zwischen [JSON Mode](https://broadrouter.com/de/glossary/json-mode/) und `json_schema` behandelt [JSON Mode vs. json\_schema](https://broadrouter.com/de/blog/structured-output-json-schema/). Hier geht es darum, was Sie mit der Antwort anfangen, die Sie tatsächlich bekommen haben.

## Warum liefern LLMs ungültiges JSON?

Ein Modell schreibt Text Token für Token. Solange der Server das Dekodieren nicht einschränkt, hindert es nichts daran, einen freundlichen Satz anzuhängen oder keinen Platz mehr zu haben. Die häufigsten Fehler:

| Was Sie sehen | Ursache | Im Code sicher reparierbar? |
| --- | --- | --- |
| ` ```json ` … ` ``` ` um das Objekt | Gewohnheit aus der Chat-Formatierung | Ja: Fence entfernen |
| „Here is the JSON:“ davor, „Let me know…“ danach | Dieselbe Gewohnheit | Ja: nur den ersten Wert lesen |
| `<think>...</think>` vor dem Objekt | Reasoning-Text im content-Feld bei manchen Servern | Ja: Block entfernen |
| Endet mitten im String, Klammern offen | `max_tokens` erreicht | Nein: mit mehr Platz neu senden |
| Leerer Inhalt | Reasoning hat das ganze Budget verbraucht | Nein: mit mehr Platz neu senden |
| `{"a": 1,}` | Nachgestelltes Komma; JavaScript erlaubt es, [RFC 8259](https://www.rfc-editor.org/rfc/rfc8259) nicht | Ja: eine Bedeutung |
| `{'a': True, 'b': None}` | Python-Syntax | Ja: `ast.literal_eval` liest es sicher |
| `NaN`, `Infinity` | Kein JSON; Python akzeptiert es standardmäßig | Nein: ablehnen |
| Gültiges JSON, falsche Typen oder fehlende Felder | Schema nicht durchgesetzt | Nein: mit der Fehlermeldung neu anfragen |

Die Trennlinie ist Mehrdeutigkeit. Gibt es genau eine Sache, die das Modell gemeint haben kann, beheben Sie sie im Code und loggen, dass Sie es getan haben. Müssten Sie raten, lehnen Sie die Antwort ab.

## Warum kein abgeschnittenes JSON reparieren?

Weil die reparierte Version richtig aussieht und es nicht ist. Wir haben [json\_repair](https://github.com/mangiucugna/json_repair) 0.64.9, eine verbreitete Bibliothek unter MIT-Lizenz, auf eine Antwort angewendet, die mitten im Wort abbrach:

```text
'{"name": "Omar", "city": "Jed'  ->  {'name': 'Omar', 'city': 'Jed'}
```

Zurück kam gültiges JSON mit der Stadt „Jed“. Das README sagt das offen: Die Bibliothek „automatically completes missing values in JSON fields with reasonable defaults“ (Übersetzung: „ergänzt fehlende Werte in JSON-Feldern automatisch mit sinnvollen Standardwerten“). Zum Lesen von Logs ist das nützlich. Bei Daten, die Sie speichern oder auf deren Grundlage Sie handeln, wird aus einem sichtbaren Fehler ein stiller.

Prüfen Sie `finish_reason`, bevor Sie parsen. `"length"` bedeutet, dass die Antwort [`max_tokens`](https://broadrouter.com/de/glossary/max-tokens/) erreicht hat. Dieselbe Anfrage mit demselben Limit scheitert genauso, also verdoppeln Sie das Limit oder fordern pro Aufruf weniger an. Reasoning-Modelle machen das häufiger: Laut der [API-Referenz](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=de-blog-fix-invalid-json-from-llm&utm_content=body) von BroadNet denken DeepSeek V4.1 Flash, GLM 5.3 und Qwen3.8 27B nach, bevor sie antworten, und das Reasoning zählt zu `max_tokens`. Bei einem kleinen Limit kann die Antwort leer zurückkommen. Lassen Sie 1.000 Tokens oder mehr frei oder setzen Sie `reasoning_effort` auf `low`; die Zahlen stehen im [Beitrag zum Reasoning-Budget](https://broadrouter.com/de/blog/reasoning-model-max-tokens-budget/).

## Eine Reparaturfunktion, die nur die sicheren Fälle behebt

Sie nutzt nur die Standardbibliothek. Sie gibt den geparsten Wert und eine Liste der vorgenommenen Reparaturen zurück, sodass Sie diese zählen können.

```python
import ast, json, re

class Truncated(Exception): pass
class NotJSON(Exception): pass

FENCE = re.compile(r"```(?:json|JSON)?\s*\n(.*?)```", re.S)
THINK = re.compile(r"<think>.*?</think>", re.S)

def _reject_constant(name):                 # NaN, Infinity: Python accepts them, JSON does not
    raise NotJSON(f"non-standard constant {name}")

_decoder = json.JSONDecoder(parse_constant=_reject_constant)

def _first_value(s):
    """Decode the first JSON object or array in s, ignoring prose before and after it."""
    for i, ch in enumerate(s):
        if ch in "{[":
            try:
                return _decoder.raw_decode(s, i)[0]
            except json.JSONDecodeError:
                continue                    # a stray brace in prose; try the next one
    raise NotJSON("no JSON object or array found")

def _scan(s):
    """Drop commas before } or ] outside strings; report brackets left open."""
    out, stack, in_str, esc = [], [], False, False
    for i, ch in enumerate(s):
        if in_str:
            if esc:
                esc = False
            elif ch == "\\":
                esc = True
            elif ch == '"':
                in_str = False
        elif ch == '"':
            in_str = True
        elif ch in "{[":
            stack.append(ch)
        elif ch in "}]" and stack:
            stack.pop()
        elif ch == ",":
            rest = s[i + 1:].lstrip()
            if rest[:1] in ("}", "]"):
                continue                    # trailing comma: skip it
        out.append(ch)
    return "".join(out), len(stack) + (1 if in_str else 0)

def _python_literal(s):
    """Output in Python syntax: single quotes, True/False/None, trailing commas."""
    start = min((i for i in (s.find("{"), s.find("[")) if i >= 0), default=-1)
    end = max(s.rfind("}"), s.rfind("]"))
    if start < 0 or end <= start:
        raise NotJSON("no braces")
    value = ast.literal_eval(s[start:end + 1])       # literals only; never runs code
    if not isinstance(value, (dict, list)):
        raise NotJSON("not an object or array")
    json.dumps(value, allow_nan=False)               # must round-trip as strict JSON
    return value

def parse_llm_json(content, finish_reason=None):
    """Return (value, repairs). Raises Truncated or NotJSON."""
    if finish_reason == "length":
        raise Truncated("hit max_tokens; raise the limit or shorten the output")
    if not content or not content.strip():
        raise NotJSON("empty content (reasoning may have used the whole budget)")
    repairs = []
    s = content.strip().lstrip("\ufeff")
    if THINK.search(s):
        s = THINK.sub("", s).strip(); repairs.append("removed <think> block")
    m = FENCE.search(s)
    if m:
        s = m.group(1).strip(); repairs.append("removed code fence")
    try:
        value = _decoder.decode(s)
        return value, repairs
    except json.JSONDecodeError:
        pass
    try:
        value = _first_value(s); repairs.append("ignored text around JSON")
        return value, repairs
    except NotJSON:
        pass
    fixed, open_count = _scan(s)
    if open_count:
        raise NotJSON(f"incomplete JSON, {open_count} bracket(s) or string left open: treat as truncated")
    if fixed != s:
        try:
            value = _first_value(fixed); repairs.append("removed trailing commas")
            return value, repairs
        except NotJSON:
            pass
    try:
        value = _python_literal(s); repairs.append("parsed Python-style literal")
        return value, repairs
    except (ValueError, SyntaxError, TypeError, MemoryError, RecursionError, NotJSON) as e:
        raise NotJSON(f"unrepairable: {e}") from None
```

So arbeitet jeder Schritt:

1.  **Abgeschnittene und leere Antworten** lösen vor jedem Parsen eine Ausnahme aus, sie werden also nie zu Daten.
2.  **Fences und Reasoning-Blöcke** werden mit zwei regulären Ausdrücken entfernt.
3.  **`raw_decode`** ist das zentrale Werkzeug. Laut Python-Doku dekodiert es ein Dokument „from a string that may have extraneous data at the end“ (Übersetzung: „aus einem String, der am Ende überzählige Daten enthalten kann“) und gibt zurück, wo es aufgehört hat. Ab dem ersten `{` oder `[` überspringt es Text vor dem Objekt und ignoriert Text danach. Lässt sich eine Klammer im Fließtext nicht dekodieren, versucht es die nächste.
4.  **Der Klammer-Scan** geht den Text durch und verfolgt dabei Strings und Escapes. Offene Klammern bedeuten, dass die Antwort abgeschnitten wurde, auch wenn `finish_reason` das nicht gemeldet hat; das löst eine Ausnahme aus. Kommas direkt vor `}` oder `]` außerhalb von Strings werden entfernt.
5.  **`ast.literal_eval`** liest Ausgaben in Python-Syntax mit einfachen Anführungszeichen, `True` und `None`. Es wertet nur Literale aus und führt nie Code aus. Das Ergebnis muss sich danach als striktes JSON serialisieren lassen.
6.  **`NaN` und `Infinity`** lösen über `parse_constant` eine Ausnahme aus. Das `json`\-Modul von Python akzeptiert sie standardmäßig; RFC 8259 sagt, sie „are not permitted“ (Übersetzung: „sind nicht erlaubt“), und `JSON.parse` in JavaScript lehnt sie ab.

Wir haben die Funktion mit 17 Test-Strings geprüft: sauberes JSON, JSON in einer Fence, arabische Schlüssel und Werte in einer Fence, Text davor und danach, ein Platzhalter `{name}` im Text vor dem Objekt, ein `<think>`\-Block, nachgestellte Kommas in Objekten und Arrays, Kommas und Klammern innerhalb von Strings, escapte Anführungszeichen, ein Windows-Pfad mit Backslash am Ende, Python-Literale, `NaN`, eine leere Antwort, eine abgeschnittene Antwort mit und ohne `finish_reason: "length"` sowie zwei Objekte hintereinander. Alle verhielten sich wie in der Tabelle oben beschrieben. Ein Test fand einen echten Bug: Eine frühe Version kippte ihr Escape-Flag, bevor sie auf das schließende Anführungszeichen prüfte, sodass `"he said \"hi,]\""` sein Komma verlor. Testen Sie Ihren eigenen Reparaturcode mit escapten Anführungszeichen.

Zwei Grenzen sollten Sie kennen. Bei zwei Objekten hintereinander gibt die Funktion das erste zurück; wenn Sie mehrere Einträge wollen, fordern Sie ein JSON-Array an. Und Python-Ausgaben in einfachen Anführungszeichen, die innerhalb eines Strings ein doppeltes Anführungszeichen enthalten, kann der Klammer-Scan falsch lesen und ablehnen. Ablehnen ist der sichere Fehlerfall.

## Wie sollten Sie neu anfragen, wenn die Reparatur scheitert?

Die Reparatur kümmert sich ums Format. Die Validierung kümmert sich um den Inhalt: richtige Felder, richtige Typen, plausible Werte. Diese Schleife validiert mit dem Paket `jsonschema` und wählt den neuen Versuch nach Ursache:

```python
import json, os
from jsonschema import Draft202012Validator
from openai import OpenAI
from llm_json import parse_llm_json, Truncated, NotJSON

client = OpenAI(base_url=os.environ.get("BASE_URL", "https://inference.broadnet.ai/v1"),
                api_key=os.environ["BROADNET_API_KEY"])
SCHEMA = {"type": "object", "additionalProperties": False,
          "required": ["name", "city", "amount"],
          "properties": {"name": {"type": "string", "minLength": 1},
                         "city": {"type": ["string", "null"]},
                         "amount": {"type": "number", "minimum": 0}}}
validator = Draft202012Validator(SCHEMA)

def extract(text, model="broadnet/qwen3.8-27b", max_tokens=1500, attempts=3, log=print):
    messages = [{"role": "system", "content": "Extract name, city and amount. Reply with one JSON object only, no code fence. "
                                              "Schema: " + json.dumps(SCHEMA)},
                {"role": "user", "content": text}]
    for attempt in range(1, attempts + 1):
        r = client.chat.completions.create(model=model, messages=messages, max_tokens=max_tokens,
                                           reasoning_effort="low", temperature=0)
        c = r.choices[0]
        try:
            value, repairs = parse_llm_json(c.message.content, c.finish_reason)
            errors = [f"{'/'.join(map(str, e.path)) or '(root)'}: {e.message}" for e in validator.iter_errors(value)]
            if not errors:
                log({"attempt": attempt, "repairs": repairs, "ok": True})
                return value
            problem = "The JSON does not match the schema: " + "; ".join(errors)
        except Truncated:
            log({"attempt": attempt, "ok": False, "why": "truncated"})
            max_tokens *= 2                 # same prompt, more room; a re-ask would be cut off too
            continue
        except NotJSON as e:
            problem = f"That reply was not valid JSON ({e})."
        log({"attempt": attempt, "ok": False, "why": problem})
        messages += [{"role": "assistant", "content": c.message.content or ""},
                     {"role": "user", "content": problem + " Return the corrected JSON object only."}]
    raise RuntimeError(f"no valid JSON after {attempts} attempts")
```

Die Regeln in dieser Schleife:

-   **Abgeschnitten: dieselben Nachrichten mit doppeltem Limit neu senden.** Eine zusätzliche „bitte korrigieren“-Nachricht würde den Prompt länger machen, die Ausgabe aber nicht kürzer.
-   **Kein JSON oder falsche Form: die exakte Fehlermeldung zurücksenden.** „amount: ‘1200’ is not of type ‘number’“ gibt dem Modell etwas Konkretes zu beheben. Ein bloßer Retry wiederholt den Fehler oft.
-   **Höchstens drei Versuche.** Jeder Retry sendet die ganze Konversation erneut als [Input-Tokens](https://broadrouter.com/de/glossary/input-and-output-tokens/). Nach drei Versuchen loggen Sie die Eingabe und leiten sie anderswohin.
-   **Die Reparaturliste loggen.** Steigt nach einer Prompt-Änderung die Zahl von „removed code fence“, ist der Prompt schlechter geworden, auch wenn nichts gescheitert ist.

Wir haben diese Schleife gegen einen lokalen Mock-Server laufen lassen, der vorbereitete Antworten abspielte. Eine Antwort in einer Fence mit nachgestelltem Komma und `"amount": "1200"` als String wurde repariert, fiel bei der Validierung durch und wurde beim zweiten Aufruf korrigiert, nachdem der Fehler zurückgesendet wurde. Eine mit `finish_reason: "length"` abgeschnittene Antwort wurde mit von 1.500 auf 3.000 erhöhtem `max_tokens` neu gesendet und war erfolgreich. Der Mock zeichnete jede Anfrage auf und bestätigte so die Zahl der Nachrichten und das Limit, die die Schleife sendete. Ein echtes Modell kann anders scheitern, also lassen Sie die Schleife über 100 Ihrer eigenen Eingaben laufen, bevor Sie den Zahlen trauen.

## Macht strukturierte Ausgabe das überflüssig?

Sie beseitigt das meiste. Ein Server, der das Dekodieren auf Ihr Schema einschränkt, kann keine Fence, kein nachgestelltes Komma und kein fehlendes Feld ausgeben. vLLM, ein verbreiteter Server für offene Modelle, macht das mit den Backends xgrammar oder guidance. Zwei Fehler bleiben selbst dann: Abschneiden bei `max_tokens` und Ablehnungen. OpenAI weist darauf hin, dass die Ausgabe im JSON Mode gültig ist „except for in some edge cases“ (Übersetzung: „außer in einigen Grenzfällen“) und dass Ihre Anwendung Ausgaben, die kein vollständiges Objekt sind, „must detect and handle“ (Übersetzung: „erkennen und behandeln muss“). Behalten Sie also die Prüfung von `finish_reason` und den Validator bei, auch mit `json_schema`.

Was jeder Ansatz verhindert:

| Ansatz | Fences und Fließtext | Syntaxfehler | Falsche Form | Abschneiden |
| --- | --- | --- | --- | --- |
| Nur Prompt („antworte mit JSON“) | Seltener | Seltener | Seltener | Nein |
| JSON Mode (`json_object`) | Ja | Ja | Nein | Nein |
| Strukturierte Ausgabe (`json_schema`, durchgesetzt) | Ja | Ja | Ja | Nein |

Für den JSON Mode sagt OpenAI außerdem, dass Sie das Modell in einer Nachricht „must always instruct the model to produce JSON“ (Übersetzung: „immer anweisen müssen, JSON zu erzeugen“); andernfalls gibt es womöglich Leerzeichen aus, bis das Token-Limit erreicht ist. Andere OpenAI-kompatible Server verhalten sich unterschiedlich, testen Sie den Modus also mit dem Modell, das Sie ausliefern. Der Test steht im [Beitrag zur strukturierten Ausgabe](https://broadrouter.com/de/blog/structured-output-json-schema/).

Um eine Antwort von Hand zu prüfen, fügen Sie sie in den [LLM-JSON-Validator](https://broadrouter.com/tools/llm-json-output-validator/) ein, oder bauen Sie mit dem [JSON-Schema-Generator](https://broadrouter.com/tools/json-schema-generator/) aus einem Beispielobjekt ein striktes Schema.

## Wo BroadNet Inference ins Bild passt

BroadRouter ist die Website von BroadNet. Die API-Referenz von BroadNet listet strukturierte Ausgabe nur für [GLM 5.3](https://broadrouter.com/de/models/glm-5.3/) und [Qwen3.8 27B](https://broadrouter.com/de/models/qwen3.8-27b/) und nennt den Anfrageparameter nicht. Testen Sie `json_schema` also mit dem Modell, bevor Sie sich darauf verlassen. Bei [DeepSeek V4.1 Flash](https://broadrouter.com/de/models/deepseek-v4.1-flash/) und [Gemma 4 VL 26B](https://broadrouter.com/de/models/gemma-4-vl-26b/) nutzen Sie JSON per Prompt mit der Reparaturfunktion und dem Validator von oben. Drei der vier Modelle denken vor dem Antworten nach, planen Sie `max_tokens` also dafür ein. Für Extraktion in großen Mengen zeigt der [Beitrag zum Batch-Runner](https://broadrouter.com/de/blog/llm-batch-processing-without-batch-api/), wie Sie `finish_reason` pro Eintrag loggen. Prompts und Antworten werden nach jeder Anfrage nicht gespeichert.

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

[JSON-Modus (JSON mode)](https://broadrouter.com/de/glossary/json-mode/)

Der JSON-Modus ist eine Einstellung von LLM-APIs, in APIs im OpenAI-Stil response\_format {"type": "json\_object"}, die dafür sorgt, dass die Antwort des Modells gültiges, parsebares JSON ist. Anders als Structured Outputs mit einem JSON Schema garantiert er nicht, welche Keys, Typen oder Werte das Objekt enthält.

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

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

[Strukturierte Ausgabe (Structured Output)](https://broadrouter.com/de/glossary/structured-output/)

Strukturierte Ausgabe (Structured Output) ist eine Funktion von LLM-APIs, die die Antwort eines Modells auf ein vom Entwickler vorgegebenes Format beschränkt, meist ein JSON Schema, damit Code sie zuverlässig parsen kann. Sie ist strenger als der JSON-Modus, der gültiges JSON garantiert, aber keine bestimmte Struktur.

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

[JSON Schema](https://broadrouter.com/de/glossary/json-schema/)

JSON Schema ist ein in JSON geschriebenes Vokabular, mit dem Sie die Struktur von JSON-Daten beschreiben und validieren: Typen, Pflichtfelder, erlaubte Werte und Verschachtelung. Die aktuelle Version ist 2020-12. LLM-APIs definieren damit Tool-Parameter und die genaue Struktur, der eine strukturierte Ausgabe folgen muss.

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

[Modelllizenz (Model License)](https://broadrouter.com/de/glossary/model-license/)

Eine Modelllizenz sind die rechtlichen Bedingungen, unter denen Gewichte, Code und Ausgaben eines Modells genutzt, verändert und weitergegeben werden dürfen. Open-Weight-Modelle nutzen Standard-Softwarelizenzen wie Apache 2.0 oder MIT oder eigene Modelllizenzen, die Bedingungen hinzufügen können, etwa Grenzen für große kommerzielle Dienste.

## Häufige Fragen

### Warum gibt mein LLM JSON in einem Markdown-Codeblock zurück?

Chat-Modelle formatieren Code meist für Menschen, und eine Code-Fence ist die Art, wie Chat-Oberflächen ihn anzeigen. Bitten Sie um „nur JSON, keine Code-Fence“, entfernen Sie Fences im Code aber trotzdem: Die Anweisung senkt die Häufigkeit, beseitigt sie aber nicht.

### Wie behebe ich einen JSONDecodeError bei LLM-Ausgaben?

Schauen Sie zuerst auf finish\_reason. Steht dort "length", wurde die Antwort abgeschnitten: max\_tokens erhöhen und neu senden. Wenn nicht, entfernen Sie Code-Fences und dekodieren den ersten JSON-Wert mit raw\_decode, das Text danach ignoriert. Beheben Sie nachgestellte Kommas und validieren Sie dann. Scheitert es weiterhin, fragen Sie mit der Fehlermeldung neu an.

### Sollte ich eine Bibliothek zur JSON-Reparatur verwenden?

Für Logs und Debugging ja. Bei Daten, auf deren Grundlage Sie handeln, vorsichtig. Bibliotheken wie json\_repair ergänzen fehlende Werte mit Standardwerten, sodass eine abgeschnittene Stadt "Jed" als gültiges "Jed" zurückkommt. Lehnen Sie abgeschnittene Ausgaben ab und senden Sie stattdessen neu.

### Warum ist die JSON-Ausgabe meines LLM abgeschnitten?

Die Antwort hat max\_tokens erreicht. Bei Reasoning-Modellen wie DeepSeek V4.1 Flash, GLM 5.3 und Qwen3.8 27B zählt das Reasoning zu diesem Limit, sodass langes Nachdenken zu wenig Platz übrig lassen kann. Erhöhen Sie das Limit, setzen Sie reasoning\_effort auf low oder fordern Sie pro Aufruf weniger Ausgabe an.

### Garantiert JSON Mode gültiges JSON?

Fast. Laut OpenAI ist die Ausgabe im JSON Mode gültiges JSON „except for in some edge cases“ (Übersetzung: „außer in einigen Grenzfällen“), etwa beim Erreichen des Token-Limits, und Ihr Schema wird nicht durchgesetzt. Strukturierte Ausgabe mit json\_schema ergänzt Schema-Treue, sofern der Anbieter sie durchsetzt. Validieren Sie in jedem Fall.

### Welche BroadNet-Modelle unterstützen strukturierte Ausgabe?

Die API-Referenz von BroadNet listet strukturierte Ausgabe für GLM 5.3 und Qwen3.8 27B, geprüft am 15. November 2026. Für DeepSeek V4.1 Flash und Gemma 4 VL 26B ist sie nicht gelistet; nutzen Sie dort JSON per Prompt mit Reparatur und Validierung.

## Weiterlesen

-   [JSON Mode vs. json\_schema: strukturierte Ausgabe, die hält](https://broadrouter.com/de/blog/structured-output-json-schema/)
-   [Tool Calling mit offenen Modellen: Schemas, parallele Aufrufe, Retries](https://broadrouter.com/de/blog/tool-calling-open-models/)
-   [max\_tokens für Reasoning-Modelle festlegen: eine Budgetmethode](https://broadrouter.com/de/blog/reasoning-model-max-tokens-budget/)
-   [Arabische Textklassifikation mit LLM: Sentiment, Intent, Triage](https://broadrouter.com/de/blog/arabic-text-classification-llm/)
-   [LLM-Batch-Verarbeitung ohne Batch API: ein fortsetzbarer Runner](https://broadrouter.com/de/blog/llm-batch-processing-without-batch-api/)
-   [App-Strings per LLM ins Arabische übersetzen: Platzhalter und Plurale](https://broadrouter.com/de/blog/translate-app-strings-to-arabic-llm/)
-   [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: OpenAI Python SDK mit BroadNet Inference nutzen](https://broadrouter.com/de/guides/openai-python-sdk/)
-   [Anleitung: Arabische Rechnungen und Belege mit einem Vision-Modell auslesen](https://broadrouter.com/de/guides/read-arabic-invoices-with-vision/)

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-fix-invalid-json-from-llm&utm_content=page-cta) ·

**Quellen**

-   [API-Referenz von BroadNet Inference: Tools und strukturierte Ausgabe nur für GLM 5.3 und Qwen3.8 27B gelistet; DeepSeek V4.1 Flash, GLM 5.3 und Qwen3.8 27B denken nach, und Reasoning zählt zu max\_tokens (geprüft am 2026-11-16) (auf Englisch)](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=de-blog-fix-invalid-json-from-llm&utm_content=sources)
-   [Leitfaden zu Structured Outputs von OpenAI: JSON Mode vs. Schema-Treue, Modell zur JSON-Ausgabe anweisen, Leerzeichen bis zum Token-Limit, unvollständige Ausgabe, Ablehnungen (geprüft am 2026-11-15)](https://developers.openai.com/api/docs/guides/structured-outputs)
-   [IETF RFC 8259, The JSON Data Interchange Format: Objekt-Grammatik, Strings in doppelten Anführungszeichen, Infinity und NaN nicht erlaubt (geprüft am 2026-11-15)](https://www.rfc-editor.org/rfc/rfc8259)
-   [Python-Dokumentation, json-Modul: JSONDecoder.raw\_decode, NaN und Infinity standardmäßig akzeptiert, parse\_constant (geprüft am 2026-11-15)](https://docs.python.org/3/library/json.html)
-   [json\_repair auf GitHub (MIT): repariert fehlerhaftes JSON und füllt fehlende Werte mit Standardwerten (Version 0.64.9 getestet; geprüft am 2026-11-15)](https://github.com/mangiucugna/json_repair)
-   [vLLM-Dokumentation, Structured Outputs: json\_schema, Regex, Choice und Grammatik mit den Backends xgrammar oder guidance (geprüft am 2026-11-15)](https://docs.vllm.ai/en/latest/features/structured_outputs.html)
