---
title: "JSON Mode vs. JSON Schema: Structured Output mit Code"
description: "JSON Mode liefert gültiges JSON, json_schema Ihre Struktur. So fordern Sie beides bei OpenAI-kompatiblen Modellen an, validieren mit Pydantic und reparieren Fehler."
url: https://broadrouter.com/de/blog/structured-output-json-schema/
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/structured-output-json-schema/) (aktualisiert am 2026-11-14).

# JSON Mode vs. json\_schema: strukturierte Ausgabe, die hält

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

JSON Mode (response\_format json\_object) verspricht nur gültiges JSON. Strukturierte Ausgabe (response\_format json\_schema) verspricht zusätzlich Ihre Felder und Typen, sofern der Anbieter das durchsetzt. In beiden Fällen prüfen Sie finish\_reason, parsen und validieren gegen ein Schema, etwa ein Pydantic-Modell. Schlägt die Validierung fehl, senden Sie den Fehler zurück und fragen erneut, mit einer festen Obergrenze für Versuche.

## Das Wichtigste in Kürze

-   Laut Leitfaden von OpenAI erzeugen beide Modi gültiges JSON, aber „only Structured Outputs ensure schema adherence“ (Übersetzung: „nur Structured Outputs stellen die Einhaltung des Schemas sicher“).
-   Die Unterstützung schwankt zwischen OpenAI-kompatiblen Anbietern. Testen Sie zuerst json\_schema, weichen Sie dann auf json\_object aus, zuletzt auf reine Prompt-Anweisungen.
-   Validieren Sie jede Antwort. Eine von max\_tokens abgeschnittene Antwort ist kaputtes JSON, egal was das Schema sagt.
-   Reparaturschleifen funktionieren, wenn Sie den exakten Validierungsfehler zurücksenden. Begrenzen Sie sie auf zwei oder drei Versuche.
-   Bei BroadNet Inference ist strukturierte Ausgabe für GLM 5.3 und Qwen3.8 27B gelistet.

**Auf dieser Seite**

1.  Was ist der Unterschied zwischen JSON Mode und json\_schema?
2.  Wie fordern Sie json\_schema an?
3.  Welchen Modus unterstützt Ihr Anbieter?
4.  Wie validieren und reparieren Sie fehlerhafte Ausgaben?
5.  Welche Schema-Features machen Probleme?
6.  Wie überwachen Sie strukturierte Ausgabe in der Produktion?
7.  Wann sollten Sie stattdessen ein Tool nutzen?
8.  Wo BroadNet Inference hineinpasst

Ihr Code braucht Daten, und Modelle schreiben Text. [Strukturierte Ausgabe](https://broadrouter.com/de/glossary/structured-output/) schließt diese Lücke, aber „das Modell gibt JSON zurück“ bedeutet drei verschiedene Dinge, je nachdem, wie Sie fragen. Dieser Beitrag vergleicht die Optionen bei OpenAI-kompatiblen offenen Modellen, zeigt, wie Sie jede anfordern, und liefert eine Schleife zum Validieren und Reparieren, die Sie direkt in die Produktion übernehmen können.

## Was ist der Unterschied zwischen JSON Mode und json\_schema?

| Methode | Anfrage | Was Ihnen versprochen wird |
| --- | --- | --- |
| Nur Prompt | „Antworte in JSON mit den Feldern …“ | Nichts; meist JSON, manchmal mit zusätzlichem Text |
| JSON Mode | `response_format: {"type": "json_object"}` | Gültiges JSON, beliebige Struktur |
| Strukturierte Ausgabe | `response_format: {"type": "json_schema", ...}` | JSON passend zu Ihrem Schema, sofern durchgesetzt |

Der Leitfaden zu Structured Outputs von OpenAI formuliert es direkt: „While both ensure valid JSON is produced, only Structured Outputs ensure schema adherence.“ (Übersetzung: „Beide stellen zwar sicher, dass gültiges JSON entsteht, aber nur Structured Outputs stellen die Einhaltung des Schemas sicher.“) Er empfiehlt, wann immer möglich, strukturierte Ausgabe statt JSON Mode.

Bei Anbietern offener Modelle hängt die Garantie davon ab, wie der Server sie umsetzt. Viele nutzen Constrained Decoding, das Tokens blockiert, die das Schema verletzen würden. Manche akzeptieren das Feld, setzen es aber nicht durch. Deshalb validiert der Code unten in jedem Fall.

## Wie fordern Sie json\_schema an?

```python
import os
from openai import OpenAI
from pydantic import BaseModel, Field

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

class Invoice(BaseModel):
    vendor: str
    currency: str = Field(pattern="^[A-Z]{3}$")
    total: float
    line_items: list[float]

schema = Invoice.model_json_schema()
schema["additionalProperties"] = False

response_format = {"type": "json_schema",
                   "json_schema": {"name": "invoice", "strict": True, "schema": schema}}
```

Pydantic erzeugt das JSON Schema aus Ihrer Klasse, sodass Schema und Validator nie auseinanderlaufen. Wenn Sie kein Pydantic nutzen, baut der [JSON-Schema-Generator](https://broadrouter.com/tools/json-schema-generator/) aus einem Beispielobjekt ein Schema für den Strict Mode. Für den Strict Mode verlangt OpenAI `additionalProperties: false` und dass jede Eigenschaft als erforderlich gelistet ist.

## Welchen Modus unterstützt Ihr Anbieter?

Führen Sie diesen Test einmal pro Modell durch, bevor Sie darauf aufbauen:

1.  Senden Sie `json_schema` mit einem Prompt, der zu einem zusätzlichen Feld einlädt („füge auch einen kurzen Kommentar hinzu“).
2.  Liefert die Anfrage einen Fehler, akzeptiert der Anbieter `json_schema` nicht. Versuchen Sie `json_object`.
3.  Enthält die Antwort das zusätzliche Feld, wird das Schema nicht durchgesetzt. Behandeln Sie es wie JSON Mode.
4.  Liefert auch `json_object` einen Fehler, nutzen Sie reine Prompt-Anweisungen mit Validierung.

Bei BroadNet Inference führt die Dokumentation strukturierte Ausgabe 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/) auf ([direkt verglichen](https://broadrouter.com/compare/glm-5.3-vs-qwen3.8-27b/)), nennt aber den Anfrageparameter nicht. Führen Sie den Test oben mit dem Modell durch, das Sie ausliefern.

## Wie validieren und reparieren Sie fehlerhafte Ausgaben?

```python
import json
from pydantic import ValidationError

def extract(text: str, model="broadnet/glm-5.3", attempts=3) -> Invoice:
    messages = [
        {"role": "system", "content": "Extract the invoice. Reply with JSON only."},
        {"role": "user", "content": text},
    ]
    for attempt in range(attempts):
        r = client.chat.completions.create(model=model, messages=messages,
                                           response_format=response_format,
                                           max_tokens=4000)
        choice = r.choices[0]
        if choice.finish_reason == "length":
            raise RuntimeError("Cut off: raise max_tokens")  # retrying won't help
        if getattr(choice.message, "refusal", None):
            raise RuntimeError(f"Refused: {choice.message.refusal}")
        raw = choice.message.content or ""
        try:
            inv = Invoice.model_validate_json(raw)
            if abs(sum(inv.line_items) - inv.total) > 0.01:
                raise ValueError("total must equal the sum of line_items")
            return inv
        except (ValidationError, ValueError) as e:
            messages += [
                {"role": "assistant", "content": raw},
                {"role": "user", "content": f"That JSON is invalid: {e}. Return corrected JSON only."},
            ]
    raise RuntimeError(f"No valid JSON after {attempts} attempts")
```

Was diese Schleife funktionieren lässt:

-   **Zuerst `finish_reason` prüfen.** Eine Antwort, die an [`max_tokens`](https://broadrouter.com/de/glossary/max-tokens/) gestoßen ist, ist abgeschnittenes JSON. Ein Retry mit demselben Limit scheitert auf dieselbe Weise. Beide Modelle oben führen vor der Antwort ein Reasoning durch, und [Reasoning zählt zum Limit](https://broadrouter.com/de/guides/reasoning-tokens-empty-response/); lassen Sie also Spielraum.
-   **Ablehnungen getrennt behandeln.** Der Leitfaden von OpenAI weist darauf hin, dass eine Ablehnung „does not necessarily follow the schema you have supplied“ (Übersetzung: „nicht unbedingt dem von Ihnen angegebenen Schema folgt“).
-   **Den exakten Fehler zurücksenden.** Ein blinder Retry liefert oft denselben Fehler. „line\_items: field required“ gibt dem Modell etwas, das es beheben kann.
-   **Geschäftsregeln im Code prüfen.** Ein Schema kann nicht ausdrücken, dass eine Summe ihren Positionen entsprechen muss. Die Prüfung oben kann es.
-   **Versuche begrenzen.** Jeder Versuch sendet den gesamten Prompt erneut als [Input-Tokens](https://broadrouter.com/de/glossary/input-and-output-tokens/).

## Welche Schema-Features machen Probleme?

Halten Sie Schemas langweilig:

1.  **Flach schlägt verschachtelt.** Zwei Ebenen reichen für die meisten Extraktionen.
2.  **Enums statt freier Strings** für Kategorien.
3.  **Keine offenen Objekte.** Freiform-Felder vom Typ `dict` verfehlen den Zweck.
4.  **Kurze Feldnamen mit Beschreibungen.** Beschreibungen im Schema leiten das Modell.
5.  **Optionale Felder als nullable.** Im Strict Mode listen Sie jedes Feld als erforderlich und erlauben `null`.

Der Leitfaden von OpenAI weist darauf hin, dass manche Features von JSON Schema im Strict Mode nicht unterstützt werden. Server für offene Modelle haben ihre eigenen Grenzen. Wird ein Schema abgelehnt, vereinfachen Sie es, bevor Sie den Modus wechseln.

## Wie überwachen Sie strukturierte Ausgabe in der Produktion?

Eine Schleife, die stillschweigend repariert, kann ein Problem verbergen, das Sie jeden Tag Tokens kostet. Loggen Sie pro Aufrufstelle drei Zahlen:

| Metrik | Was sie Ihnen sagt |
| --- | --- |
| Erfolgsquote beim ersten Versuch | Wie gut Modell und Schema zusammenpassen; ein Rückgang folgt oft auf eine Änderung von Prompt oder Modell |
| Durchschnittliche Versuche pro Erfolg | Die Token-Kosten der Reparaturen |
| Endgültige Fehlschläge | Eingaben, die Ihre Pipeline nicht verarbeiten kann; prüfen Sie sie von Hand |

Fällt die Erfolgsquote beim ersten Versuch unter das gewohnte Niveau, vereinfachen Sie das Schema oder probieren Sie ein anderes Modell, bevor Sie weitere Retries hinzufügen. Bewahren Sie eine Stichprobe fehlgeschlagener Rohantworten auf, damit Sie Korrekturen an echten Fällen testen können.

## Wann sollten Sie stattdessen ein Tool nutzen?

Nutzen Sie strukturierte Ausgabe für die **endgültige Antwort**: eine Extraktion, eine Klassifizierung, einen Plan. Nutzen Sie [Tool Calling](https://broadrouter.com/de/blog/tool-calling-open-models/), wenn das Modell Ihren Code etwas **tun** lassen und danach weitermachen muss. Viele Agenten nutzen beides: Tools während der Schleife, ein Schema für den letzten Schritt. Ein Beispiel von Bild zu JSON finden Sie unter [arabische Rechnungen mit einem Vision-Modell auslesen](https://broadrouter.com/de/guides/read-arabic-invoices-with-vision/).

## Wo BroadNet Inference hineinpasst

BroadNet Inference listet strukturierte Ausgabe für GLM 5.3 und Qwen3.8 27B, hinter dem Standardformat für Chat Completions; der Code oben läuft also unverändert mit dem [OpenAI Python SDK](https://broadrouter.com/de/guides/openai-python-sdk/). Qwen3.8 27B nimmt außerdem Bilder an, was zur Extraktion aus Dokumenten passt. Für DeepSeek V4.1 Flash und Gemma 4 VL 26B nennt die Dokumentation von BroadNet keine strukturierte Ausgabe; nutzen Sie dort den Weg über reine Prompt-Anweisungen mit Validierung. Die Preise pro Token vergleichen Sie auf der [Preisseite](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

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

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

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

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

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

[Vision-Language-Modell (VLM)](https://broadrouter.com/de/glossary/vision-language-model/)

Ein Vision-Language-Modell (VLM) ist ein Modell, das Bilder und Text zusammen als Eingabe nimmt und Text erzeugt. So kann es Bilder beschreiben, Fragen zu ihnen beantworten und Dokumente, Diagramme oder Screenshots lesen. VLMs heißen auch Image-Text-to-Text- oder multimodale Modelle.

## Häufige Fragen

### Was ist der Unterschied zwischen JSON Mode und strukturierter Ausgabe?

JSON Mode, response\_format vom Typ json\_object, verspricht nur, dass sich die Antwort als JSON parsen lässt. Strukturierte Ausgabe, Typ json\_schema, verspricht zusätzlich die von Ihnen definierten Felder und Typen, sofern der Anbieter das durchsetzt. OpenAI empfiehlt, wo möglich, strukturierte Ausgabe statt JSON Mode.

### Unterstützen offene Modelle response\_format mit json\_schema?

Das hängt vom Anbieter ab. Manche akzeptieren json\_schema, manche nur json\_object, und manche ignorieren das Feld. Senden Sie eine Testanfrage mit einem Schema und einem Prompt, der das Modell dazu verleitet, ein zusätzliches Feld hinzuzufügen, und prüfen Sie die Antwort.

### Muss ich strukturierte Ausgabe trotzdem validieren?

Ja. Antworten können von max\_tokens abgeschnitten werden, Ablehnungen sein und Geschäftsregeln verletzen, die ein Schema nicht ausdrücken kann, etwa Summen, die aufgehen müssen.

### Wie oft sollte ich bei ungültigem JSON neu anfragen?

Zwei oder drei Versuche mit dem Validierungsfehler im Prompt reichen meist. Danach loggen Sie die Eingabe und leiten sie an einen Fallback weiter, an ein stärkeres Modell oder an einen Menschen. Unbegrenzte Schleifen verschwenden Tokens.

### Sollte ich strukturierte Ausgabe oder Tool Calling nutzen?

Nutzen Sie strukturierte Ausgabe, wenn Sie die endgültige Antwort in einer festen Form wollen. Nutzen Sie Tool Calling, wenn das Modell Ihren Code etwas ausführen lassen und danach weitermachen muss.

## Weiterlesen

-   [Arabische Textklassifikation mit LLM: Sentiment, Intent, Triage](https://broadrouter.com/de/blog/arabic-text-classification-llm/)
-   [Tool Calling mit offenen Modellen: Schemas, parallele Aufrufe, Retries](https://broadrouter.com/de/blog/tool-calling-open-models/)
-   [Wechsel zu einer OpenAI-kompatiblen API: die Migrations-Checkliste](https://broadrouter.com/de/blog/openai-compatible-api-migration-checklist/)
-   [n8n AI Agent mit günstigem LLM: Setup, Modellwahl, Kosten pro Lauf](https://broadrouter.com/de/blog/n8n-ai-agent-cheap-llm/)
-   [Ungültiges JSON vom LLM reparieren: Ursachen, Reparatur, Retry](https://broadrouter.com/de/blog/fix-invalid-json-from-llm/)
-   [Arabische Named Entity Extraction mit LLM: JSON, Daten, Prüfungen](https://broadrouter.com/de/blog/arabic-named-entity-extraction-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: 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/)
-   [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-structured-output-json-schema&utm_content=page-cta) ·

**Quellen**

-   [OpenAI, Leitfaden zu Structured Outputs (geprüft am 2026-11-14)](https://developers.openai.com/api/docs/guides/structured-outputs)
-   [API-Referenz von OpenAI, Chat Completion erstellen (response\_format)](https://developers.openai.com/api/reference/resources/chat/subresources/completions/methods/create)
-   [Pydantic-Dokumentation, JSON Schema und Validierung](https://docs.pydantic.dev/latest/concepts/json_schema/)
-   [API-Referenz von BroadNet Inference, Modelle (auf Englisch)](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=de-blog-structured-output-json-schema&utm_content=sources#models)
