Skip to content

JSON Diff Vergleich

Zwei JSON-Dateien direkt im Browser vergleichen. Nebeneinander-Hervorhebung, RFC 6902 JSON Patch-Ausgabe, störende Felder wie Zeitstempel und IDs ignorieren. 100 % privat, kein Upload.

Kein Tracking Läuft im Browser Kostenlos
Pfade ignorieren:
Erweiterte Optionen
Array-Modus
Reviewed for RFC 6902/6901 compliance and edge cases including null vs missing keys, type drift, floating-point precision, and array key alignment. — Go Tools API Tooling Team · May 4, 2026

Was ist JSON Diff?

JSON Diff ist ein struktureller Vergleich zweier JSON-Dokumente, der das Datenmodell von JSON respektiert – Schlüssel sind ungeordnet, Typen sind strikt, und Arrays können geordnet oder schlüsselbasiert sein. Anders als ein Text-Diff (der Zeilen vergleicht und Schlüssel-Neuanordnungen oder Leerzeichen als Unterschiede meldet) liefert ein JSON-Diff semantisch bedeutsame Ergebnisse.

Die kanonische maschinenlesbare Form ist JSON Patch (RFC 6902), ein geordnetes Ops-Array (add, remove, replace, move, copy, test), das ein Dokument in ein anderes überführt. Pfade verwenden JSON Pointer (RFC 6901). Eng verwandt: JSON Merge Patch (RFC 7396) – einfacher, kann aber 'Schlüssel entfernen' nicht von 'Schlüssel auf null setzen' unterscheiden. Dieses Werkzeug gibt RFC 6902 aus.

Tiefe Gleichheit bei JSON in JavaScript ist schwieriger als es aussieht. JSON.stringify(a) === JSON.stringify(b) schlägt bei Schlüssel-Neuanordnung fehl und führt bei -0 vs 0 (beide stringifizieren zu "0") in die Irre. Ein korrekter Diff muss beide Bäume parallel durchlaufen und dabei die Schlüsselmengen-Vereinigung nutzen, null von fehlend über den 'in'-Operator unterscheiden und entscheiden, was 'gleich' für Zahlen bedeutet (Object.is als Standard, Epsilon für Toleranz).

Dieses Werkzeug läuft vollständig im Browser. Eingaben verlassen den Rechner nicht. Sicher für API-Antworten, interne Schemata und proprietäre Konfigurationen.

Mit verwandten JSON-Werkzeugen arbeiten? Formatieren mit JSON Formatierer; konvertieren mit JSON zu YAML und YAML zu JSON.

// Two JSON documents that look different but are semantically equal
const a = '{"a":1,"b":2}';
const b = '{"b":2,"a":1}';

// Naive comparison — wrong
JSON.stringify(JSON.parse(a)) === JSON.stringify(JSON.parse(b));
// → false (key order differs)

// JSON Diff (this tool) — correct: key order is irrelevant
// → 0 differences

// JSON Patch (RFC 6902) for { "a": 1 } → { "a": 2 }
// [{ "op": "replace", "path": "/a", "value": 2 }]

Hauptfunktionen

Nebeneinander + JSON Patch

Zwei Ansichten aus einem Diff: visuelle Hervorhebung für die Überprüfung, RFC 6902 Patch für Automatisierung.

Störende Felder ignorieren

Ein-Klick-Presets entfernen /createdAt, /updatedAt, /*Id, /*At, requestId, traceId. Benutzerdefinierte Extended JSON Pointer-Muster werden unterstützt.

Arrays per Schlüssel abgleichen

Arrays von Objekten per id-Feld statt per Index vergleichen – für K8s-Envs, package-lock-Einträge oder jede logisch ungeordnete Liste.

Standardmäßig typenstrikt

1 ≠ "1". null ≠ fehlend. Backend-Serialisierungsdrift erkennen, sobald er in einem Test-Fixture auftaucht.

100 % browserbasiert

Eingaben verlassen den Rechner nicht. Kein Upload, kein localStorage für JSON, keine Analyse des eingefügten Inhalts.

Konfiguration teilen, nicht Daten

'Link teilen' schreibt nur die Konfiguration in die URL. JSON-Eingaben bleiben lokal.

Beispiele

API-Antwort Regression

{"user":{"id":1,"name":"Ada","createdAt":"2024-01-01"}}
{"user":{"id":1,"name":"Ada Lovelace","createdAt":"2024-02-02"}}

Zwei Änderungen (Name + createdAt). /user/createdAt zu den Ignore-Pfaden hinzufügen – dann bleibt nur die Namensänderung übrig.

Konfigurationsdatei-Audit (Schlüsselreihenfolge)

{"a":1,"b":2,"c":3}
{"c":3,"a":1,"b":2}

Gleiche Daten, andere Schlüsselreihenfolge. JSON Diff behandelt die Schlüsselreihenfolge als semantisch irrelevant – der Diff ist leer.

Array von Objekten (Abgleich per Schlüssel)

[{"id":1,"qty":3},{"id":2,"qty":5}]
[{"id":2,"qty":5},{"id":1,"qty":4}]

Array-Modus auf 'Abgleich per Schlüssel' mit key=id umstellen. Ohne Ausrichtung erscheint jedes Element als geändert; mit Ausrichtung ändert sich nur qty bei id=1.

JSON Patch-Ausgabe (RFC 6902)

{"items":[{"id":1,"price":29.99}]}
{"items":[{"id":1,"price":24.99}]}

Zum JSON-Patch-Tab wechseln, um [{"op":"replace","path":"/items/0/price","value":24.99}] zu erhalten – anwendbar mit fast-json-patch.

Anleitung

  1. 1

    Beide JSON-Dokumente einfügen

    Das originale (links) und das geänderte (rechts) JSON einfügen. Der Live-Diff wird während der Eingabe gerendert; bei großen Eingaben (>200 KB) wechselt er zu einem manuellen Diff-Button.

  2. 2

    Rauschen herausfiltern

    Auf ein Preset klicken (Timestamps / IDs / Trace) oder Extended JSON Pointer-Muster in 'Ignore-Pfade' einfügen, um irrelevante Felder auszublenden.

  3. 3

    Gewünschte Ansicht wählen

    Nebeneinander für die menschliche Überprüfung, JSON Patch (RFC 6902) für maschinell anwendbare Ops. 'Link teilen' verwenden, um die Konfiguration an ein Teammitglied zu senden.

Häufige Diff-Fallstricke

Schlüsselreihenfolgen-Rauschen (Text-Diff-Symptom)

Wenn ein Diff-Werkzeug {"a":1,"b":2} vs. {"b":2,"a":1} als unterschiedlich meldet, führt es einen Zeilen-Diff durch, keinen JSON-Diff. JSON-Schlüssel sind ungeordnet – dieses Werkzeug ignoriert die Reihenfolge automatisch.

✗ Falsch
diff a.json b.json   # text diff: 'everything changed'
✓ Richtig
JSON Diff (this tool): 0 differences

null vs. fehlend – Verwechslung

{"a":null} und {} sind nicht gleich. Sie als gleich zu behandeln verdeckt echte Backend-Fehler.

✗ Falsch
{"a": null} == {}   # collapsed by some tools
✓ Richtig
{"a": null} ≠ {}     # type-strict diff

Array-Reihenfolge ohne Schlüssel-Ausrichtung

[{id:1},{id:2}] vs. [{id:2},{id:1}] sind für eine logische Menge keine 'zwei Änderungen'. Sequenziell meldet es so; auf 'Abgleich per Schlüssel' umstellen.

✗ Falsch
Sequential diff: 4 modified
✓ Richtig
Match by key (id): 0 differences

Typdrift (Zahl vs. Zeichenkette)

Backends serialisieren IDs manchmal inkonsistent – 42 vs. "42". Das Werkzeug kennzeichnet diese als 'Typ'-Änderungen, damit der Drift frühzeitig erkannt wird.

✗ Falsch
{"id": 42} vs {"id": "42"}   # serialization bug
✓ Richtig
Diff reports 'modified (type)' with both values

Gleitkomma-Genauigkeit

0.1 + 0.2 !== 0.3 in IEEE 754. Mit Toleranz=0 (Standard) wird dies markiert. Toleranz auf 1e-9 setzen, wenn numerische Äquivalenz beabsichtigt ist.

✗ Falsch
tolerance=0:  0.30000000000000004 ≠ 0.3
✓ Richtig
tolerance=1e-9: equal

Zeitstempel & UUID-Rauschen

createdAt, updatedAt, requestId, traceId ändern sich bei jeder Anfrage. Die Ignore-Pfade-Presets verwenden, um sie herauszufiltern.

✗ Falsch
Diff: 47 modifications (45 are timestamps)
✓ Richtig
Add /createdAt, /updatedAt, /requestId to Ignore paths → 2 real changes

Anwendungsfälle

API-Antwort Regression
Staging- vs. Produktions-Antworten vergleichen; Zeitstempel und Request-IDs ignorieren, um nur bedeutsame Payload-Änderungen sichtbar zu machen.
CI Snapshot-Test-Fehler
Tatsächliche vs. erwartete Werte aus einem fehlgeschlagenen Jest/Vitest-Snapshot einfügen. Rauschen herausfiltern und die echte Änderung in Sekunden finden.
package-lock / yarn.lock Konflikte
Merge-Konflikte auflösen, indem Abhängigkeiten am Namen ausgerichtet werden; Schlüsselreihenfolge und irrelevante Felder werden kein Rauschen mehr.
K8s / Helm Values-Audit
Envs, volumeMounts und Ports am Namen ausrichten. Unbeabsichtigte Reihenfolgeänderungen von echten Konfigurationsänderungen unterscheiden.
i18n Übersetzungsabdeckung
en.json und zh.json strukturell vergleichen, um fehlende oder überzählige Übersetzungsschlüssel zu finden – ohne Werte-Rauschen.
Terraform / CDK Plan-Review
Plan-Ausgaben zwischen Läufen vergleichen; numerische Toleranz behandelt Gleitkomma-Arithmetik, Ignore-Pfade blenden ARNs und Zeitstempel aus.

Technische Details

RFC 6902-konforme Patch-Ausgabe
Erzeugt gültige JSON Patch-Ops (add/remove/replace) mit RFC 6901-Pfaden. Validiert gegen fast-json-patch@3.x und rfc6902 npm-Pakete.
Iterative Traversierung
Explizite Stack-Traversierung (keine Rekursion) begrenzt auf 100.000 Knoten und Tiefe 64, um Stack-Overflow bei ungünstigen Eingaben zu verhindern.
Object.is numerische Gleichheit
Standard-Toleranz ist 0 – verwendet Object.is, sodass -0 und +0 unterschieden werden. Toleranz > 0 für Epsilon-basierte Gleichheit setzen.

Best Practices

Zuerst filtern, dann prüfen
Ignore-Pfade zuerst hinzufügen (Zeitstempel, IDs, Trace-Felder), dann den Diff lesen. Verrauschte Diffs zu überprüfen trainiert das Auge, echte Änderungen zu übersehen.
Abgleich per Schlüssel für logische Mengen
Wenn ein Array eine ungeordnete Menge darstellt (Envs, Benutzer, Abhängigkeiten), 'Abgleich per Schlüssel' verwenden. Sequenzieller Diff auf logischen Mengen ist fast immer falsch.
Konfiguration teilen, nicht Eingaben
'Link teilen' nutzen, um einem Kollegen die Filterkonfiguration zu senden – niemals sensibles JSON in geteilte Dokumente einfügen. Die URL enthält nur die Konfiguration.

Häufig gestellte Fragen

Warum zeigt mein Diff alles als geändert, obwohl ich nur ein Feld geändert habe?
Drei häufige Ursachen: (1) Unterschiedliche Schlüsselreihenfolge – JSON Diff behandelt sie als gleichwertig, Text-Diff-Werkzeuge jedoch nicht; (2) Zeitstempel/UUIDs/Auto-IDs, die sich bei jeder Anfrage ändern – zu den Ignore-Pfaden hinzufügen; (3) Array-Reihenfolge, wenn Index-Vergleich nicht sinnvoll ist – Array-Modus auf 'Abgleich per Schlüssel' umstellen.
Wie ignoriere ich Zeitstempel und IDs im JSON-Diff?
Das Eingabefeld 'Ignore-Pfade' verwenden. Auf 'Timestamps' oder 'IDs' klicken, um /createdAt, /updatedAt, /*Id, /*At, /requestId mit einem Klick zu filtern. Es können auch eigene Extended JSON Pointer-Muster eingefügt werden – eines pro Zeile – für erweiterte Filterung.
Was ist der Unterschied zwischen JSON Patch und einem visuellen Diff?
Der visuelle (nebeneinander) Diff ist für Menschen – Änderungen werden mit dem Auge überprüft. JSON Patch (RFC 6902) ist für Maschinen – ein strukturiertes Ops-Array (add/remove/replace), das mit fast-json-patch oder rfc6902 npm-Paketen angewendet werden kann. Gleicher Diff, zwei Ausgaben.
Behandelt JSON Diff null und fehlende Schlüssel gleich?
Nein. {"a":null} und {} unterscheiden sich – das erste hat einen expliziten null-Wert, das zweite hat keinen Schlüssel. Reale Systeme verhalten sich bei beiden unterschiedlich; dieses Werkzeug hält sie auseinander.
Wie werden Arrays verglichen – per Index oder per Schlüssel?
Standardmäßig per Index (sequenziell). Auf 'Abgleich per Schlüssel' umstellen und ein Schlüsselfeld angeben (häufig id), um Elemente unabhängig von der Reihenfolge auszurichten. Nützlich für K8s-Envs, package-lock-Einträge oder jede Liste, die logisch eine Menge ist.
Kann ich den Diff als RFC 6902 JSON Patch exportieren?
Ja. Der JSON-Patch-Tab gibt ein gültiges RFC 6902 Ops-Array aus. Wenn Ignore-Pfade gesetzt sind, wird der Patch gefiltert (der Tab zeigt '(gefiltert: schließt {n} ignorierte Pfade aus)') und stellt die Originale nicht exakt wieder her. Ignore-Pfade leeren für einen vollständigen Patch.
Ist JSON Patch dasselbe wie JSON Merge Patch (RFC 7396)?
Nein. RFC 6902 (JSON Patch) ist ein geordnetes Ops-Array – explizit und umkehrbar. RFC 7396 (Merge Patch) ist ein einzelnes Merge-Dokument – einfacher, kann aber Löschung nicht von null-Setzen unterscheiden. JSON Diff gibt RFC 6902 aus.
Wie vergleiche ich zwei große JSON-Dateien (>10 MB)?
Dateien über ~5 MB überschreiten den praktischen Browserspeicher. Der Live-Modus deaktiviert sich bei 200 KB; für Dateien im Megabyte-Bereich bitte jq auf der Kommandozeile oder fast-json-patch in Node verwenden.
Sendet das Werkzeug mein JSON an einen Server?
Nein. Alle Vergleiche laufen lokal im Browser. Eingaben werden nie auf Festplatte, Netzwerk, localStorage oder URL-Parameter geschrieben. Beim Aktualisieren der Seite werden sie gelöscht. Der 'Link teilen'-Button schreibt nur die Konfiguration (Array-Modus, Ignore-Pfade) – niemals die Daten.
Warum unterscheiden sich 42 und "42" im Diff?
JSON Diff ist typenstrikt: Zahl 42 und Zeichenkette "42" sind nicht gleich. Dies erkennt Backend-Serialisierungsdrift (manche Endpunkte geben numerische IDs zurück, andere Zeichenketten) – der Diff kennzeichnet es als 'Typ'-Änderung.
Kann ich JSON mit Kommentaren (JSONC) oder abschließenden Kommas verarbeiten?
Standard-JSON (RFC 8259) erlaubt keine Kommentare oder abschließenden Kommas. Dieses Werkzeug verwendet natives JSON.parse, das beides ablehnt. Kommentare zuerst mit dem JSON Formatierer entfernen.
Wie vergleiche ich verschachtelte Arrays von Objekten anhand eines Schlüssels wie id?
Array-Modus auf 'Abgleich per Schlüssel' setzen und id eingeben. Der Diff richtet per id-Wert aus. v1 wendet dasselbe Schlüsselfeld auf jeder Array-Tiefe an; innere Arrays ohne dieses Feld fallen auf sequenziell zurück und zeigen einen Warnhinweis.
Behandelt der Diff Gleitkomma-Genauigkeit (0.1 + 0.2)?
Ja, mit numerischer Toleranz. Standard ist 0 mit Object.is – daher werden -0 vs +0 markiert. Toleranz auf ein kleines Epsilon setzen (z. B. 1e-9), damit 0.1 + 0.2 gleich 0.3 ist. Toleranz gilt nur für numerische Blattknoten.

Verwandte Werkzeuge

Alle Werkzeuge anzeigen →