JSON-Formatierungstool

JSON Eingabe

Einrückungsbreite

Formatierte Ausgabe

Zeilen: 1Zeichen: 0Bytes: 0

Zeilen: 1Zeichen: 0

Was ist JSON-Formatierung?

Der JSON-Formatter macht kompaktes oder unübersichtliches JSON lesbar, indem er Einrückung, Zeilenumbrüche und Struktur sichtbar macht. JSON wird in API-Antworten, Konfigurationen, Logs, Feature-Flags, Testdaten und No-Code-Integrationen verwendet; ein fehlendes Komma, ein falsches Anführungszeichen oder eine unerwartete Verschachtelung kann sofort zu Parse-Fehlern führen. Das Werkzeug hilft, Objekte, Arrays, Schlüssel, Werte und Fehlerstellen schnell zu erkennen und optional wieder zu komprimieren. Formatierung ändert jedoch nicht die Bedeutung der Daten und validiert nicht automatisch ein fachliches Schema. Für produktive Schnittstellen sollten Datentypen, Pflichtfelder, null-Werte und Versionsverträge zusätzlich geprüft werden. Besonders bei produktiven Daten oder Codebasen sollte das Ergebnis anschließend mit Parser, Tests oder Projektregeln geprüft werden.

Anleitung

So geht's

JSON-Daten im linken Eingabefeld einfügen oder eingeben
Einrückungsgröße wählen (2 Leerzeichen, 4 Leerzeichen oder Tabulator)
Auf Formatieren klicken, um zu verschönern, oder auf Komprimieren, um Leerzeichen zu entfernen
Die Ergebnisse erscheinen automatisch rechts mit Syntaxhervorhebung
Auf Kopieren oder Herunterladen klicken, um das Ergebnis zu speichern

Hinweise zur JSON-Validierung

Das Formatieren beweist, dass der Text gültiges JSON ist, aber nicht, dass die Daten Ihrem Geschäfts-Schema entsprechen.
Wenn Fehler angezeigt werden, prüfen Sie die gemeldete Zeile und Spalte auf einfache Anführungszeichen, nachgestellte Kommas, Kommentare oder nicht-escapte Steuerzeichen.

Anwendungsfälle

API-Antworten im Browser prüfenEinen kompakten Response-Body einfügen, um verschachtelte Objekte und Arrays mit zwei Leerzeichen, vier Leerzeichen oder Tabulatoren zu erweitern. Parse-Fehler enthalten nach Möglichkeit eine berechnete Zeile und Spalte, sodass eine fehlerhafte Antwort korrigiert werden kann, ohne das gesamte Dokument manuell durchsuchen zu müssen.

JSON für Commits und Reviews vorbereitenWenn Konfigurationen, Beispiel-Fixtures oder Übersetzungsdaten ein stabiles Layout benötigen, erzeugt der Formatter eine deterministische Ausgabe mit der gewählten Einrückung. Der Komprimierungsmodus steht für die umgekehrte Richtung bereit, wenn dieselben Daten in eine Umgebungsvariable oder ein Anfragefeld kopiert werden müssen.

Sensible Daten lokal bereinigenParser, Formatter, Komprimierer, Kopier- und Download-Schritte laufen alle im Browser und halten Tokens, Kundenfelder, interne Feature-Flags und unveröffentlichte API-Strukturen von externen Verschönerern fern. Die Ausgabe separat gegen die OpenAPI- oder JSON-Schema-Spezifikation validieren, da die Formatierung nur beweist, dass das Dokument parsebar ist, nicht aber dass die Daten dem erwarteten Vertrag entsprechen. Auf stille Typumwandlungen bei großen numerischen Feldern achten.

Zwei JSON-Payloads feldweise vergleichenSowohl eine alte als auch eine neue Antwort mit gleicher Einrückung formatieren und dann in einem Diff-Viewer nebeneinander stellen, um umbenannte Schlüssel, Typänderungen und Unterschiede zwischen null und fehlenden Feldern zu erkennen. Das ist schneller als das Durchsuchen von rohem minifiziertem JSON, besonders bei Webhook-Payloads, bei denen ein einziger vertauschter Feldwert Konsumenten bricht.

Für Umgebungsvariablen oder curl-Payloads komprimierenIn den Komprimierungsmodus wechseln, um ein großes Konfigurationsobjekt in eine einzeilige Umgebungsvariable, eine .datei oder ein curl --data-Argument zu pressen. Anschließend mit dem Ziel-Parser prüfen, da einige HTTP-Clients bei sehr langen einzeiligen Bodies von mehreren hundert Kilobyten noch Probleme haben. Striktes JSON (RFC 8259) verbietet nachgestellte Kommas und Kommentare; wenn die Eingabe JSON5 oder HJSON ist, wird der strenge Parser Zeilen mit // am Anfang oder ,] am Ende ablehnen – in diesem Fall einen toleranten Modus aktivieren oder die Kommentare vor der Formatierung entfernen. Große Ganzzahlen über 2^53 verlieren an Präzision, da JavaScript sie als IEEE-754-Double darstellt.

Technisches Prinzip

JSON (JavaScript Object Notation) ist durch RFC 8259 / ECMA-404 definiert. Die Grammatik ist eine strenge Teilmenge von JavaScript-Objektliteralen: Strings müssen in doppelte Anführungszeichen eingeschlossen sein, Keys müssen gequotet sein, nachgestellte Kommas sind unzulässig und Kommentare sind verboten. Ein Formatter parst das Dokument mit `JSON.parse()` in den Objektgraphen der Hostsprache und serialisiert es anschließend über `JSON.stringify(value, replacer, indent)` neu, wobei indent eine Zahl (1-10 Leerzeichen) oder ein String (`'\t'`) ist. Parsing ist O(n) und im Allgemeinen schneller als die Stringify-Phase, da die Ausgabeeerzeugung neue Strings allokiert. Zahlenverarbeitung folgt IEEE 754 Doppelprecision: Ganzzahlen größer als `Number.MAX_SAFE_INTEGER` (2^53 - 1 = 9007199254740991) verlieren Präzision, sodass `9007199254740993` zu `9007199254740992` round-tripped. Dezimale Wiederholungen wie `0.1 + 0.2` ergeben nach dem Parsen `0.30000000000000004`. Unicode-Strings erlauben `\uXXXX`-Escapes einschließlich Surrogate-Pairs (`\uD83D\uDE00` -> 😀); der Parser lehnt alleinstehende ungepaarte Surrogate ab. Whitespace ist nur innerhalb von Strings signifikant – jede Kombination aus Leerzeichen, Tab, LF, CR zwischen Tokens wird identisch geparst. Häufige nicht-standardmäßige Entspannungen sind JSON5 (Kommentare, nachgestellte Kommas, unquoted Keys) und JSONC (VS-Code-Konfiguration). Standard-JSON erlaubt sie nicht, und `JSON.parse` löst bei Begegnung einen `SyntaxError` aus. Streaming-Alternativen wie NDJSON (ein Objekt pro Zeile) und JSON Lines vermeiden das Laden ganzer Dokumente in den Speicher. Bei tief verschachtelter Eingabe begrenzt das V8-Stack-Limit (~10.000 Frames) rekursionsbasierte Parser; Produktionsparser verwenden iterative Zustandsmaschinen, um diese Grenze anzuheben.

RFC 8259 / ECMA-404-Grammatik – sechs Werttypen (object, array, string, number, true/false, null); Strings in doppelten Anführungszeichen; Keys müssen gequotet sein; keine nachgestellten Kommas; keine Kommentare.
`JSON.parse(text)` läuft in O(n) und wirft `SyntaxError` mit Zeichenoffset bei ungültiger Eingabe; `JSON.stringify(value, replacer, indent)` erzeugt formatierte Ausgabe mit 2-10 Leerzeichen oder `'\t'`-Einrückung.
IEEE-754-Zahlenpräzision: `Number.MAX_SAFE_INTEGER = 2^53 - 1`; Ganzzahlen darüber werden auf den nächsten darstellbaren Double gerundet, daher müssen Chat-IDs und Twitter-Snowflake-IDs als Strings transportiert werden.
Unicode-`\uXXXX`-Escapes unterstützen das gesamte BMP; Nicht-BMP-Zeichen erfordern Surrogate-Pair-Kodierung `\uD83D\uDE00`; der Parser lehnt alleinstehende ungepaarte Surrogate gemäß RFC 8259 §8.2 ab.
Häufige Parse-Fehler: Einfache Anführungszeichen (`'foo'`), nachgestelltes Komma nach dem letzten Array-/Objekt-Element, unescaped Steuerzeichen innerhalb von Strings, unescaped Backslash, fehlendes schließendes `}`/`]`, BOM (`\uFEFF`) am Anfang.
Zirkuläre Referenzen werfen `TypeError: cyclic object value` in `JSON.stringify`; verwenden Sie einen `replacer`-Callback mit WeakSet, um Zyklen zu durchbrechen, oder Bibliotheken wie `flatted` / `json-stringify-safe`.
Nicht-standardmäßige Varianten: JSON5 (`.json5`, erlaubt Kommentare und nachgestellte Kommas), JSONC (VS-Code-Konfiguration), NDJSON / JSON Lines (ein Objekt pro Zeile, streaming-freundlich) – alle werden von strengem `JSON.parse` abgelehnt.

Beispiele

Objekt-Beispiel

Eingabe:
{
  "name": "ToolAct",
  "type": "web tool",
  "active": true
}

Ausgabe: schön formatiert mit 2 Leerzeichen Einrückung und stabiler Schlüsselreihenfolge

Array-Beispiel

Eingabe:  [1,2,3,"a","b","c"]
Ausgabe: formatiert mit 2 Leerzeichen Einrückung; Zahlen bleiben numerisch, Zeichenketten behalten ihre Anführungszeichen

Verschachtelte Struktur

Eingabe:
{"user":{"name":"Alex","skills":["JavaScript","Python"]}}

Ausgabe:
{
  "user": {
    "name": "Alex",
    "skills": [
      "JavaScript",
      "Python"
    ]
  }
}
Hinweis: verschachtelte Objekte und Arrays werden rekursiv eingerückt; die Einrückungsbreite kann in der Symbolleiste gewählt werden

FAQ

Was macht der Formatter?

Er formatiert JSON neu: Pretty-Print mit gewählter Einrückung (2 oder 4 Leerzeichen) oder Minify zu einer einzelnen Zeile. Beim Parsen wird zugleich validiert – Syntaxfehler werden mit Zeile und Spalte gemeldet.

Warum wird mein JSON als ungültig abgelehnt?

Häufige Ursachen: nachgestellte Kommas (in JS erlaubt, in JSON nicht), Strings in einfachen Anführungszeichen (müssen doppelt sein), unquotierte Schlüssel, Kommentare (// oder /* */) oder fehlende Klammern. Die Seite zeigt die Fehlerstelle. JSON5 und JSONC (JSON mit Kommentaren) sind Obermengen von JSON – dafür brauchst du einen anderen Parser.

Bleibt die Schlüsselreihenfolge erhalten?

Die JSON-Spezifikation sagt, dass die Schlüsselreihenfolge nicht relevant ist, doch die meisten Parser bewahren sie beim Round-Trip. Dieses Tool behält die Einfügereihenfolge bei – meist das, was du für lesbare Diffs willst.

Verarbeitet das Tool sehr große JSON-Dateien?

Moderne Browser bewältigen 10–50 MB JSON-Dateien, auch wenn der Editor dabei langsamer wird. Für Dateien im Hunderte-MB-Bereich brauchst du einen Streaming-Parser (jq auf der Kommandozeile, ndjson-Tools); Browser-Parser laden den ganzen Baum in den Speicher.

Wird mein JSON hochgeladen?

Nein. Parsen und Formatieren laufen im Browser über JSON.parse und JSON.stringify. Eingefügtes JSON wird nicht übertragen.

Warum verlieren große Zahlen an Präzision?

JSON.parse in JavaScript nutzt Number, also IEEE-754-Double-Precision. Ganzzahlen oberhalb von 2^53 verlieren an Genauigkeit (z. B. wird 9007199254740993 stillschweigend gerundet). Für BigInt oder das Erhalten als String brauchst du einen eigenen Parser oder markierst große Zahlen schon im Erzeuger als Strings.

Was ist mit JSONC (JSON mit Kommentaren)?

Striktes JSON verbietet Kommentare. Manche IDEs (VS-Code-Konfigurationsdateien) nutzen JSONC, das // und /* */ Kommentare erlaubt. Der Formatter bietet meist einen JSONC-Modus, der Kommentare bewahrt; im strikten Modus sind Kommentare ein Syntaxfehler.