JSON online validieren: Syntax, Schema & häufige Fehler

JSON (JavaScript Object Notation) hat eine formale Spezifikation, definiert durch RFC 8259 und den ECMA-404-Standard. Ein JSON-Dokument ist gültig, wenn es dieser Spezifikation vollständig entspricht — nicht mehr, nicht weniger. Die Regeln sind strenger, als die meisten erwarten, und mehrere Dinge, die JavaScript erlaubt, sind in JSON ausdrücklich verboten.

Die Regeln der JSON-Spezifikation

• Zeichenketten müssen doppelte Anführungszeichen verwenden — in einfache Anführungszeichen gesetzte Strings (`'value'`) sind kein gültiges JSON, selbst wenn JavaScript sie akzeptiert.
• Keine nachgestellten Kommas — `[1, 2, 3,]` und `{"a": 1,}` sind ungültig; das Komma nach dem letzten Element muss entfernt werden.
• Keine Kommentare — `// Zeilenkommentare` und `/* Blockkommentare */` sind nicht Teil der JSON-Spezifikation.
• Keine undefined-Werte — `undefined` ist ein JavaScript-Konzept; JSON erlaubt nur `null`, Zahlen, Strings, Booleans, Arrays und Objekte.
• Zahlen dürfen keine führenden Nullen haben — `012` ist kein gültiges JSON; verwenden Sie `12`.
• Objektschlüssel müssen Strings sein — `{1: "value"}` ist ungültig; Schlüssel müssen doppelt in Anführungszeichen gesetzte Strings sein.
• Keine Steuerzeichen in Strings — rohe Zeilenumbrüche, Tabs und andere Steuerzeichen müssen escaped werden (`\n`, `\t` usw.).

Syntaktisch gültig vs. semantisch gültig

Ein JSON-Dokument kann syntaktisch gültig (korrekt nach der Spezifikation geformt), aber für Ihre Anwendung semantisch ungültig sein. Beispielsweise ist ein JSON-Objekt mit „age“ = -5 gültiges JSON, aber ein ungültiges Alter für ein Benutzerprofil. Die Syntaxvalidierung ist das, was ein JSON-Parser prüft; die Schema-Validierung findet die semantischen Fehler. Beide Schichten sind wichtig, und dieser Leitfaden deckt beide ab.

Der schnellste Weg zu prüfen, ob ein JSON-String gültig ist, ist das Einfügen in einen Online-JSON-Validator. Keine Installation, keine Konfiguration, kein Konto. Das Ergebnis ist sofort da und — bei einem browserbasierten Werkzeug — verlassen Ihre Daten niemals Ihr Gerät.

Ein JSON-Text ist ein serialisierter Wert. Beachten Sie, dass bestimmte frühere JSON-Spezifikationen einen JSON-Text auf ein Objekt oder ein Array beschränkten.

Den JSON-Formatierer und -Validator verwenden

Der JSON-Formatierer & Validator auf Aback Tools validiert und formatiert JSON gleichzeitig. Fügen Sie einen beliebigen JSON-String ein, und er sagt Ihnen sofort, ob die Eingabe gültig ist. Ist sie ungültig, hebt das Werkzeug die Fehlerposition mit Zeilennummer und einer Klartext-Beschreibung hervor, was schiefgelaufen ist. Ist sie gültig, gibt es sauberes, eingerücktes JSON aus, das Sie direkt in Ihr Projekt kopieren können.

Dieser Doppelnutzen zählt in der Praxis. Wenn Sie JSON von einer API erhalten, es aus einer Konfigurationsdatei kopieren oder aus einer Logzeile ziehen, ist der Rohtext oft minifiziert und schwer lesbar. Ihn als Teil der Validierung zu formatieren gibt Ihnen zwei Dinge zugleich: die Bestätigung, dass das JSON gültig ist, und eine lesbare Version, die Sie tatsächlich inspizieren können.

Die meisten ungültigen JSON-Dokumente scheitern an einem von fünf Gründen. Diese Muster zu kennen, erlaubt es Ihnen, Fehler schnell zu beheben, ohne sich für die Diagnose ganz auf ein Werkzeug zu verlassen.

// ❌ Ungültig - Komma nach der letzten Eigenschaft
{
  "name": "Alice",
  "age": 30,
}

// ✓ Gültig - kein nachgestelltes Komma
{
  "name": "Alice",
  "age": 30
}

// ❌ Ungültig - Schlüssel und Wert in einfachen Anführungszeichen
{'city': 'London'}

// ✓ Gültig - Schlüssel und Wert in doppelten Anführungszeichen
{"city": "London"}

// ❌ Ungültig - Kommentare sind nicht Teil der JSON-Spezifikation
{
  // Dies ist das Benutzerobjekt
  "name": "Alice",
  "role": "admin" /* erweiterte Berechtigungen */
}

// ❌ Ungültig - roher Zeilenumbruch im String-Wert
{"message": "line one
line two"}

// ✓ Gültig - escapeter Zeilenumbruch
{"message": "line one\nline two"}

// ❌ Ungültig - Array geöffnet, aber Objekt geschlossen
{
  "items": [1, 2, 3
}

// ✓ Gültig - passende Klammern
{
  "items": [1, 2, 3]
}

Die Syntaxvalidierung bestätigt, dass das JSON wohlgeformt ist. Die Schema-Validierung bestätigt, dass das JSON die richtigen Daten enthält — die richtigen Felder, die richtigen Typen, die richtigen Wertebereiche. Das sind zwei verschiedene Prüfungen, und beide werden in Produktionssystemen benötigt.

Was ist JSON Schema?

JSON Schema ist ein Vokabular zur Beschreibung der Struktur und der Einschränkungen eines JSON-Dokuments. Ein Schema-Dokument legt fest, welche Felder erforderlich sind, welchen Typ jedes Feld haben muss, Mindest- und Höchstwerte für Zahlen, erlaubte String-Muster und mehr. Wenn Sie ein JSON-Dokument gegen ein Schema validieren, erhalten Sie präzise Fehler wie „Feld ‚email‘ ist erforderlich“ oder „Feld ‚age‘ muss eine positive Ganzzahl sein“ — nicht nur „ungültiges JSON“.

Den JSON-Schema-Validator verwenden

Der JSON-Schema-Validator auf Aback Tools nimmt ein JSON-Payload und ein JSON Schema entgegen und validiert das Payload gegen die Schema-Einschränkungen. Er meldet regelbasierte Fehler mit dem exakten Feldpfad, der fehlgeschlagen ist — Sie wissen also nicht nur, dass die Validierung scheiterte, sondern welches Feld welche Regel verletzte. Das ist das richtige Werkzeug, wenn Sie prüfen müssen, ob eine API-Antwort einem Vertrag entspricht, oder ob eine Konfigurationsdatei alle erforderlichen Einstellungen enthält.

Syntaxvalidierung vs. Schema-Validierung

Ein Schema aus einem bestehenden Payload generieren

Der schnellste Weg, einer bestehenden Anwendung Schema-Validierung hinzuzufügen, ist die Generierung des Schemas aus einem bekannten guten Payload. Fügen Sie ein repräsentatives JSON-Objekt in den JSON-Schema-Generator ein, und er erzeugt ein vollständiges Schema mit Typdefinitionen, Pflichtfeldern und Formathinweisen. Kopieren Sie die Ausgabe in Ihr Projekt und verwenden Sie sie als Validierungsvertrag für alle künftigen Payloads dieses Typs.

Online-Werkzeuge sind die schnellste Wahl für einmalige Prüfungen, aber Produktionssysteme brauchen JSON-Validierung eingebettet in Code. Jede große Programmiersprache hat mindestens eine gepflegte JSON-Parsing-Bibliothek, und die meisten haben zusätzlich dedizierte Schema-Validierungsbibliotheken.

JavaScript und TypeScript

In JavaScript wirft `JSON.parse()` einen `SyntaxError` bei ungültigem JSON — umwickeln Sie ihn mit try/catch, um den Fehler elegant zu behandeln. Für die Schema-Validierung ist AJV (Another JSON Validator) die am weitesten verbreitete Bibliothek, die JSON Schema Draft-07 bis Draft 2020-12 mit hoher Leistung unterstützt. Zod ist eine beliebte TypeScript-first-Alternative, die JSON gegen Laufzeit-Typschemas mit vollständiger TypeScript-Inferenz validiert. Der JSON-zu-Zod-Schema-Konverter auf Aback Tools erzeugt automatisch ein Zod-Schema aus jedem JSON-Payload.

function isValidJson(input: string): boolean {
  try {
    JSON.parse(input);
    return true;
  } catch {
    return false;
  }
}

// Or get the parsed value and the error together:
function parseJson<T>(input: string): { data: T } | { error: string } {
  try {
    return { data: JSON.parse(input) as T };
  } catch (e) {
    return { error: (e as SyntaxError).message };
  }
}

Python

Pythons eingebautes `json`-Modul wirft `json.JSONDecodeError` (eine Unterklasse von `ValueError`), wenn das Parsen fehlschlägt. Das Fehlerobjekt enthält die Zeilennummer, die Spalte und eine Beschreibung. Für die Schema-Validierung sind jsonschema und pydantic die Standardwahl — pydantic ist besonders in FastAPI-Projekten beliebt, weil es JSON in einem Schritt validiert und in typisierte Python-Objekte deserialisiert.

import json

def is_valid_json(text: str) -> bool:
    try:
        json.loads(text)
        return True
    except json.JSONDecodeError as e:
        print(f"Invalid JSON at line {e.lineno}, col {e.colno}: {e.msg}")
        return False

Kommandozeile

Auf jedem System mit installiertem Python validiert und formatiert `python3 -m json.tool input.json` eine JSON-Datei mit einem einzigen Befehl. Der Exit-Code ist bei Fehlschlag ungleich null, was es für Shell-Skripte und CI-Pipelines geeignet macht. Das Werkzeug `jq` ist eine mächtigere Alternative: `jq . input.json` validiert und formatiert, während `jq 'empty' input.json` ohne Ausgabe validiert.

# Validate and pretty-print with Python (built-in, no install)
python3 -m json.tool input.json

# Validate silently with jq (exit code 0 = valid, 1 = invalid)
jq empty input.json && echo "Valid" || echo "Invalid"

# Validate multiple files with a loop
for f in *.json; do
  jq empty "$f" && echo "$f: valid" || echo "$f: INVALID"
done

Die Standard-JSON-Validierung deckt `.json`-Dateien und API-Payloads ab. Aber JSON tritt in mehreren anderen Formaten mit eigenen Validierungsanforderungen auf — Formaten, bei denen ein Standard-JSON-Parser entweder falsche Ergebnisse liefert oder die gesamte Eingabe ablehnt.

JSONL und NDJSON (JSON Lines)

JSON-Lines-Dateien (`.jsonl`) enthalten ein JSON-Objekt pro Zeile ohne umschließendes Array. Dieses Format ist Standard für Logdateien, ML-Trainingsdatensätze und Streaming-APIs. Ein Standard-JSON-Parser lehnt eine JSONL-Datei ab, weil die Datei als Ganzes kein gültiges JSON-Dokument ist — jede Zeile muss einzeln geparst werden. Der JSON-Lines-Validator & Fixer validiert jede Zeile separat, meldet, welche Zeilennummern Fehler haben, und bietet sichere Auto-Korrekturen für häufige Formatierungsprobleme.

JSON mit Duplikatschlüsseln

Die JSON-Spezifikation erlaubt technisch Duplikatschlüssel in Objekten, aber das Verhalten ist undefiniert — verschiedene Parser behandeln es unterschiedlich. Pythons `json.loads()` behält den letzten Wert; manche Parser behalten den ersten; andere werfen einen Fehler. In der Praxis sind Duplikatschlüssel fast immer ein Bug — entweder ein missglücktes Merge oder ein Template-Fehler. Der JSON-Duplikatschlüssel-Detektor findet alle wiederholten Schlüssel und sagt Ihnen genau, wo sie auftreten.

JSON in YAML-Konfigurationsdateien

YAML ist eine Obermenge von JSON, daher ist jedes gültige JSON auch gültiges YAML. Aber in YAML-Dateien eingebettetes JSON — etwa als Wert eines String-Felds — braucht seine eigene Validierung. Wenn Sie mit YAML-Konfigs arbeiten, die eingebettete JSON-Werte enthalten, validieren Sie die JSON-Abschnitte separat mit dem JSON-Formatierer und danach das gesamte YAML mit einem YAML-Validator. Verwendet Ihr Projekt beide Formate und müssen Sie zwei Konfigurationsdateien vergleichen, behandelt der JSON/YAML-Diff-Highlighter beide gleichzeitig.

JSON einmal vor einer wichtigen Operation zu validieren ist gut. Die Validierung an jedem Punkt einzubauen, an dem JSON Ihr System betritt oder verlässt, ist besser. Diese Praktiken gelten, ob Sie eine API bauen, Datenpipelines verarbeiten oder Konfigurationsdateien verwalten.

Bei der Ingestion validieren, nicht beim Konsum

Der richtige Zeitpunkt, JSON zu validieren, ist, wenn es zum ersten Mal in Ihr System eintritt — an der API-Grenze, im Datei-Upload-Handler, beim Message-Queue-Consumer. Beim Konsum zu validieren (in der Funktion, die tief in Ihrem Code einen Wert liest) bedeutet, dass ungültige Daten weiter wandern, bevor sie scheitern — der Fehler wird schwerer nachvollziehbar. Validieren Sie früh und weisen Sie ungültige Eingaben am Eingangspunkt zurück.

Nutzen Sie ein Schema, nicht nur eine Syntaxprüfung

Syntaxvalidierung ist die Mindestanforderung. In jedem System, in dem JSON geschäftskritische Daten transportiert — Benutzerdatensätze, Zahlungs-Payloads, Konfigurationswerte — fügt ein Schema eine zweite Schicht hinzu, die falsche Typen, fehlende Pflichtfelder und außerhalb der Reichweite liegende Werte findet, die die Syntaxvalidierung nicht erkennen kann. Generieren Sie Ihr anfängliches Schema aus einem bekannten guten Payload mit dem JSON-Schema-Generator und verfeinern Sie es, während sich Ihr Datenmodell entwickelt.

Behandeln Sie Validierungsfehler explizit

Ein `JSON.parse()`-Aufruf in einem try/catch, der den Fehler verschluckt und null zurückgibt, ist schlechter als keine Validierung — er versteckt das Problem. Wenn die JSON-Validierung fehlschlägt, loggen Sie den Fehler mit der Eingangsquelle, der exakten Fehlermeldung und genug Kontext, um das Problem zu reproduzieren. Geben Sie dem Aufrufer einen aussagekräftigen Fehler zurück statt eines leeren Ergebnisses, das anderswo einen Sekundärfehler auslöst.

• Loggen Sie die Roheingabe — wenn die JSON-Validierung in der Produktion fehlschlägt, ist die Roheingabe das wertvollste Debug-Artefakt. Loggen Sie eine gekürzte Version (erste 500 Zeichen) zusammen mit dem Fehler.
• Schließen Sie den Quellkontext ein — notieren Sie, woher das JSON kam: welcher API-Endpoint, welche Datei, welche Queue-Nachricht. Das verwandelt einen generischen Analysefehler in einen handhabbaren Vorfall.
• Richten Sie Alarme für Parse-Fehler ein — eine Spitze bei JSON-Validierungsfehlern signalisiert oft einen Breaking Change in einer Upstream-API oder ein Deployment, das einen Serialisierungs-Bug einführte.
• Testen Sie mit ungültigen Eingaben — nehmen Sie ungültiges JSON (nachgestelltes Komma, fehlendes Anführungszeichen, falscher Typ) in Ihre Testsuite auf, um zu bestätigen, dass Ihre Fehlerbehandlung korrekt funktioniert.