---
title: "Structured Outputs mit JSON Schema · OpenAI-kompatibel, EU"
description: "Erhalten Sie von offenen Modellen gültiges JSON nach Ihrem Schema, mit OpenAI-kompatiblen Structured Outputs. JSON-Modus, json_schema, strict und Stolperfallen."
canonical: "https://inference.eu/de/api/structured-outputs/"
language: "de"
---

Anleitungen · Structured outputs

# Structured Outputs: JSON, das Ihrem Schema entspricht

Mit Structured Outputs antwortet ein Modell mit JSON nach einem von Ihnen definierten Schema statt mit Fließtext, den Sie erst parsen müssten. Das lohnt sich überall, wo ein Programm das Ergebnis liest: Felder aus Dokumenten extrahieren, Tickets klassifizieren, Anfragen weiterleiten oder Formulare füllen. Das Anfrageformat ist das OpenAI-Feld \`response\_format\`, und die Ausgabe wird schon während der Generierung eingeschränkt.

[Vertrieb kontaktieren](https://inference.eu/de/kontakt/)[Beispielanfrage](#example)

1.  01API-Format: OpenAI
2.  02Rechenzentren in der EU
3.  03Durch einen AV-Vertrag abgedeckt

extract\_invoice.py

```
import json, os
from openai import OpenAI

client = OpenAI(base_url="https://api.inference.eu/v1", api_key=os.environ["INFERENCE_EU_API_KEY"])

schema = {
    "type": "object",
    "properties": {
        "supplier": {"type": "string"},
        "invoice_number": {"type": "string"},
        "issue_date": {"type": "string", "description": "ISO 8601 date"},
        "currency": {"type": "string", "enum": ["EUR", "GBP", "CHF", "PLN", "SEK"]},
        "total": {"type": "number"},
        "vat_id": {"type": ["string", "null"]},
    },
    "required": ["supplier", "invoice_number", "issue_date", "currency", "total", "vat_id"],
    "additionalProperties": False,
}

reply = client.chat.completions.create(
    model="gpt-oss-120b",
    messages=[
        {"role": "system", "content": "Extract invoice fields. Use null when a field is missing."},
        {"role": "user", "content": open("invoice.md").read()},
    ],
    response_format={
        "type": "json_schema",
        "json_schema": {"name": "invoice", "schema": schema, "strict": True},
    },
)
invoice = json.loads(reply.choices[0].message.content)
```

## So funktionieren Structured Outputs

Ergänzen Sie `response_format` mit `type: "json_schema"` und einem Objekt `json_schema`, das einen `name`, Ihr `schema` als JSON Schema und `strict: true` enthält. Während das Modell generiert, lässt die API nur Tokens zu, die die Ausgabe gültig gegenüber dem Schema halten. Das Ergebnis in `message.content` ist ein JSON-String, den Sie direkt parsen können.

Das ist zuverlässiger, als im Prompt um JSON zu bitten. Das Modell kann keinen Satz vor die öffnende Klammer setzen, kein Pflichtfeld weglassen und keine undefinierte Eigenschaft erfinden. Die Aufgabe beschreiben Sie weiterhin im Prompt: Das Schema bestimmt die Form, der Prompt den Inhalt.

## JSON-Modus und Schemagestaltung

`response_format: {"type": "json_object"}` ist die lockerere Variante, der JSON-Modus. Die Ausgabe ist garantiert gültiges JSON, folgt aber keiner bestimmten Struktur; nennen Sie die erwarteten Felder daher im Prompt. Bevorzugen Sie `json_schema`, wann immer Sie die Form kennen.

Halten Sie Schemas einfach und eindeutig. Führen Sie jede Eigenschaft in `required` auf und setzen Sie `additionalProperties` auf `false`, wie es der strikte Modus erwartet. Optionale Werte bilden Sie als Typ ab, der `null` erlaubt, wie `vat_id` im Beispiel. So kann das Modell „nicht gefunden“ sagen, statt zu raten. Nutzen Sie `enum` für feste Kategorien und `description` für Felder, deren Bedeutung sich nicht aus dem Namen ergibt.

## Eine bewährte Extraktions-Pipeline

Ein verbreitetes Muster macht aus Dokumenten Daten. Wandeln Sie jedes PDF mit dem Werkzeug zur Dokumentkonvertierung in Markdown um, senden Sie den Text mit kurzem Systemprompt und Ihrem Schema und parsen Sie das Ergebnis. Prüfen Sie das Objekt im Code mit demselben Schema und anschließend Geschäftsregeln, die das Schema nicht abbildet, etwa ob Summen stimmen.

Für Tausende Dokumente bündeln Sie dieselben Anfragen in einem Batch-Job. Ein Feld für die Sicherheit des Modells oder ein kurzer `notes`\-String hilft Prüfern zu verstehen, warum ein Wert gewählt wurde. In der Responses API gehört dasselbe Schema in `text.format` statt in `response_format`.

## Fehler und Sonderfälle

Sehr große oder tief verschachtelte Schemas sowie ungewöhnliche Schlüsselwörter wie komplexe `pattern`\-Ausdrücke oder `oneOf` mit überlappenden Zweigen können mit einem 400-Fehler abgelehnt werden, der den nicht unterstützten Teil nennt. Teilen oder vereinfachen Sie solche Schemas.

Das Schema garantiert das Format, nicht die Fakten. Ein Modell kann ein falsches Datum in ein gültiges Datumsfeld schreiben, prüfen Sie wichtige Werte also. Endet die Generierung bei `max_tokens`, ist das JSON abgeschnitten und nicht parsebar; prüfen Sie `finish_reason` und erhöhen Sie das Limit. Reasoning-Modelle denken vor dem JSON nach und brauchen Platz für beides. Ablehnungen kommen als Text, nicht als Schema-Ausgabe.

## Structured outputs

Kategorie

Anleitungen

API-Format

OpenAI

Base URL

api.inference.eu/v1

Verarbeitung

Rechenzentren in der EU

Training mit Ihren Daten

Nie

## Structured outputs: häufige Fragen

Die Fragen, die uns Einkauf, Entwicklung und Rechtsabteilungen am häufigsten stellen. Etwas fehlt? Fragen Sie uns direkt.

Übergeben Sie in einer Chat-Completions-Anfrage \`response\_format\` mit \`type: "json\_schema"\`, einem \`name\`, Ihrem JSON Schema und \`strict: true\`. Die Antwort in \`message.content\` ist dann JSON, das dem Schema entspricht. Für eine lockerere Garantie nutzen Sie \`type: "json\_object"\` und beschreiben die Felder im Prompt.

Ja. \`response\_format\` mit \`json\_schema\` und \`json\_object\` folgt der OpenAI Chat Completions API, \`text.format\` der Responses API. SDK-Helfer, die das Schema aus einem Pydantic- oder Zod-Modell erzeugen, etwa \`client.chat.completions.parse\` in Python, funktionieren mit inference.eu.

Der JSON-Modus garantiert gültiges JSON, aber nicht, welche Schlüssel es enthält. Structured Outputs mit \`json\_schema\` garantieren, dass die Ausgabe Ihrem Schema folgt: Pflichtfelder vorhanden, Typen korrekt, keine zusätzlichen Eigenschaften. Nutzen Sie Structured Outputs, wann immer Sie die benötigte Form kennen.

Objekte, Arrays, Strings, Zahlen, Ganzzahlen, Booleans, \`null\`, \`enum\`, \`required\`, verschachtelte Objekte, \`additionalProperties: false\` und Beschreibungen funktionieren. Sehr komplexe Konstrukte können mit einem 400-Fehler samt Problembeschreibung abgelehnt werden. Flache, eindeutige Schemas liefern die zuverlässigsten Ergebnisse.

Ja. Definieren Sie in Python ein Pydantic-Modell und übergeben Sie es als \`response\_format\` an \`client.chat.completions.parse\`. Das SDK wandelt es in ein JSON Schema um, sendet es und liefert ein geparstes Objekt in \`message.parsed\`. Mit Zod funktioniert das in TypeScript über den Helfer des SDK genauso.

Das Modell hat \`max\_tokens\` erreicht, bevor es fertig war, und \`finish\_reason\` lautet \`length\`. Erhöhen Sie \`max\_tokens\`, kürzen Sie lange Textfelder im Schema oder extrahieren Sie weniger Einträge pro Anfrage. Reasoning-Modelle brauchen zusätzlichen Platz, weil ihr Nachdenken ebenfalls zum Limit zählt.

Ja. Werkzeuge können in ihrer Funktionsdefinition \`strict: true\` nutzen, damit die Argumente dem Parameterschema folgen, und die endgültige Antwort kann \`response\_format\` verwenden. Häufig ruft das Modell zuerst Nachschlagewerkzeuge auf und liefert dann eine strukturierte Zusammenfassung.

Nein. Garantiert ist die Form, nicht die Richtigkeit jedes Werts. Ein Modell kann ein Dokument falsch lesen oder einen Wert raten. Erlauben Sie \`null\` für fehlende Daten, prüfen Sie wichtige Felder im Code und kontrollieren Sie eine Stichprobe der Ergebnisse von Hand.

[Frage stellen](https://inference.eu/de/kontakt/)

## Verwandte Seiten

[API-Überblick](https://inference.eu/de/api/)

-   [Tool callingLassen Sie offene Modelle Ihre Funktionen und APIs aufrufen, mit OpenAI-kompatiblem Tool Calling. Werkzeuge definieren, Schleife ausführen, in der EU.Anleitungen](https://inference.eu/de/api/tool-calling/)
-   [Document conversionWandeln Sie PDF-, Word-, PowerPoint- und Excel-Dateien in sauberes Markdown für RAG und Prompts um. Tabellen, Überschriften und Scans, verarbeitet in der EU.Tools](https://inference.eu/de/api/document-conversion/)
-   [Chat completionsSenden Sie Chat-Nachrichten im OpenAI-Format an Open-Weight-Modelle. Verarbeitung in Rechenzentren in der EU, keine Nutzung Ihrer Daten für Training.Endpunkte](https://inference.eu/de/api/chat-completions/)
-   [BatchesFühren Sie Tausende Chat- oder Embedding-Anfragen als asynchronen Job aus. OpenAI-kompatible Batch-API mit JSONL-Upload, verarbeitet in der EU.Endpunkte](https://inference.eu/de/api/batches/)

## Verlagern Sie Ihre KI-Workloads auf europäische Infrastruktur

Sagen Sie uns, welche Modelle Sie nutzen und wie viel Verkehr Sie ungefähr haben. Wir antworten innerhalb eines Werktags mit Preisen und nächsten Schritten.

-   Antwort innerhalb eines Werktags
-   Preise für Ihr Volumen
-   AV-Vertrag unterschriftsreif