Plak, formatteer en vergelijk twee JSON-fragmenten naast elkaar. Validatie, pretty-print en minify ingebouwd.
Een gratis tool in de browser om twee JSON-documenten te vergelijken. Plak een oude versie links, de nieuwe rechts, en de verschillen lichten teken voor teken op. Niets verlaat je machine.
De tool gebruikt de native JSON.parse van je browser voor validatie. Er is een Format-knop wanneer je JSON één lange geminificeerde regel is, een Minify-knop voor het tegenovergestelde, en live validatie die syntaxfouten markeert terwijl je typt.
Als je ooit naar een diff van 6.000 regels in een openapi.json in een GitHub PR hebt gestaard, op zoek naar dat ene veld dat een downstream client brak, dan is dit de tool die je daar in seconden brengt.
De diff werkt op tekenniveau, en wordt vervolgens opgeschoond met semantische nabewerking, zodat de markeringen op betekenisvolle stukken vallen in plaats van willekeurige tekens. Toevoegingen zijn groen in het rechterpaneel, verwijderingen rood in het linker.
JSON heeft zijn eigen eigenaardigheden die de specificatie benoemt. De JSON-specificatie in RFC 8259 definieert objecten als ongeordend, dus het herschikken van sleutels is technisch gezien zonder effect, ook al markeert een tekstdiff dit. We lossen dat op door je aan elke kant een Format-knop te geven: formatteer beide, vergelijk dan, en de volgorde is consistent. Voor diepgaander structureel werk, kijk dan eens naar JSON Patch (RFC 6902) of het eenvoudigere JSON Merge Patch-formaat (RFC 7396), de twee standaardmanieren om een JSON-wijziging als data te beschrijven.
Wanneer volgorde belangrijk is voor hashing of ondertekening, is RFC 8785 (JSON Canonicalization Scheme) de relevante specificatie. Sorteer sleutels, normaliseer de getalnotatie, en doe dan de diff.
Twee tekstpanelen, één diff. Geen aanmelding, geen upload, geen server-rondreis.
Plak de oude JSON links, de nieuwe JSON rechts. Of klik aan beide kanten op Upload om een .json-bestand direct in te laden. De Sample-knop vult beide panelen met een klein voorbeeld als je de tool eerst in actie wilt zien.
Klik op Format in elk paneel om met inspringing van twee spaties pretty te printen. Dit normaliseert witruimte en regeleinden zodat de diff echte datawijzigingen markeert, geen opmaakverschillen. De validatiebadge wordt groen wanneer je JSON correct parseert.
Verwijderingen verschijnen met een rode markering links, toevoegingen met een groene markering rechts. Scroll aan een kant en de andere volgt. De wijzigingstellingen in elke header vertellen je hoeveel afzonderlijke bewerkingen de diff heeft gevonden.
Plak de huidige output van aws iam get-policy-version tegenover de voorgestelde JSON om precies te zien welke Action-vermeldingen zijn toegevoegd, of dat iemand stiekem "Resource": "*" in een eerder specifieke statement heeft gezet. De AWS-console herschikt statements bij opslaan, waardoor een GitHub diff misleidend wordt; formatteer beide kanten hier en de echte wijziging is duidelijk.
Wanneer terraform show -json tfplan een blob van 4 MB teruggeeft, is met het oog kijken hopeloos. Vergelijk het plan van vandaag met dat van gisteren om de aws_security_group_rule aan het licht te brengen die iemand onder een refactor PR heeft toegevoegd, of het lifecycle.ignore_changes-blok dat stilletjes verdween.
Een diff van 6.000 regels in openapi.json is onleesbaar wanneer een code generator paths alfabetisch herschikt. Formatteer beide kanten, vergelijk, en de echte wijziging komt boven: een required-veld toegevoegd aan CreateOrderRequest, of een 200-response waarvan het schema stilletjes is veranderd van string naar string | null.
Na het oplossen van een conflict in package-lock.json, vergelijk je opgeloste bestand met de lockfile van main om een transitieve downgrade te vangen. npm lost dezelfde semver-range soms op naar verschillende exacte versies op verschillende machines, wat de echte oorzaak is van "werkt op mijn machine, faalt in CI". Lees de package-lock.json-documentatie voor wat elk veld betekent.
Haal GET /my-index/_mapping op uit staging en prod, plak beide in de diff. Prod heeft mogelijk nog "type": "text" op een veld dat staging vorige sprint naar "keyword" heeft gemigreerd, en daarom geeft de aggregation query niets terug in prod en werkt lokaal. Mappings nestelen zich vijf of zes niveaus diep en een tekstdiff begraaft dit in ruis.
Wanneer een Playwright-test lokaal slaagt en in CI faalt, leg dan de JSON-responsbody vast die de test daadwerkelijk zag en vergelijk deze met de fixture in je repo. Vaak is het een createdAt-tijdstempel of een traceId-veld dat niemand heeft vastgepind, en de structurele diff maakt de schuldige sleutel duidelijk in plaats van je in een muur van geformatteerde tekst te dumpen.
Een korte spiekbrief voor de parsing-randgevallen die deze tool het vaakst aan het licht brengt. Alles is gebaseerd op de JSON-specificatie.
| Topic | What this tool does |
|---|---|
| Volgorde van objectsleutels | Ongeordend volgens de specificatie. {"a":1,"b":2} is gelijk aan {"b":2,"a":1}. Gebruik Sleutels sorteren om te normaliseren voor het vergelijken. |
| Volgorde van arrays | Geordend. [1,2,3] is niet gelijk aan [3,2,1]. Sorteer handmatig als de volgorde voor jouw use case niet uitmaakt. |
| Trailing comma's | Niet toegestaan. { "a": 1, } is een parse-error in standaard JSON. Toegestaan in JSON5/JSONC, dat zijn supersets — verwijder ze eerst. |
| Commentaar | Niet toegestaan. // zoals dit is een parse-error. JSON5 en JSONC accepteren ze; deze tool volgt de strikte RFC 8259-grammatica. |
| Getallen | Geparseerd als 64-bit IEEE 754 floats. 0.1 + 0.2 = 0.30000000000000004. Gehele getallen boven 2^53 − 1 verliezen precisie; sla snowflake IDs op als strings. |
| Dubbele sleutels | De specificatie noemt dit ongedefinieerd gedrag. De meeste parsers houden de laatste vermelding. De diff toont ze allemaal, wat meestal is wat je wilt bij het auditen van configuratiebestanden. |
| Codering | Alleen UTF-8. RFC 8259 verbiedt een UTF-8 BOM aan het begin van het document; sommige parsers accepteren dit toch, maar de specificatie niet. |
| Null vs ontbrekend | Een sleutel met waarde null is aanwezig. Een ontbrekende sleutel is afwezig. Anders dan JavaScript's undefined, dat geen JSON-representatie heeft. |
Nee. De diff draait volledig in je browser. Niets wordt naar een server gestuurd, gelogd of opgeslagen. Plak een interne API-response of een IAM-beleid en sluit het tabblad; er blijft geen kopie achter. Om dit te verifiëren, open je DevTools, schakel je naar het Network-tabblad en kijk je mee — er zijn geen uitgaande verzoeken wanneer je vergelijkt.
Ja, beide doen dat. Een tekstdiff vergelijkt tekens regel voor regel, dus herformattering, het herschikken van sleutels of witruimteveranderingen verschijnen als verschillen, zelfs als de data identiek is. Klik in beide panelen op de Format-knop om eerst pretty te printen, en de diff richt zich op echte datawijzigingen. Voor een volledig structurele vergelijking die de sleutelvolgorde negeert, sorteer je de sleutels aan beide kanten voordat je vergelijkt.
Voor objectsleutels niet — de JSON-specificatie zegt dat objecten ongeordend zijn, dus {"a":1,"b":2} en {"b":2,"a":1} stellen dezelfde data voor. Een tekendiff zal de herschikking nog steeds markeren, en daarom is de Format-knop belangrijk. Arrays zijn anders: [1,2,3] en [3,2,1] zijn niet gelijk, omdat de volgorde van een array wel betekenisvol is in JSON.
Vanwege IEEE 754 floating-point. 0.1 + 0.2 is eigenlijk 0.30000000000000004, en JSON.parse leest getallen als 64-bit floats. Grote gehele getallen lopen tegen dezelfde grens aan: alles boven 2^53 - 1 (9007199254740991) verliest precisie, dus een snowflake ID in Twitter-stijl rondt niet correct af. Als precisie belangrijk is, sla die op als strings.
Standaard JSON staat geen van beide toe. { "a": 1, } of // comment geeft je een parse-error. Dat is JSON5 of JSONC (het formaat dat VS Code gebruikt voor settings.json), wat een superset is. Verwijder eerst het commentaar en de trailing comma's. Wij volgen bewust de strikte RFC 8259-grammatica, zodat de diff overeenkomt met wat je API daadwerkelijk accepteert.
Tot een paar MB is prima, sub-seconde. Voorbij 10 MB begint de browser het te voelen, voornamelijk omdat het renderen van de diff (niet het berekenen ervan) duur wordt. Voor exports van 50 MB+ filter je beide kanten met jq tot de subtree die je interesseert, en plak je vervolgens dat.
Gratis ja, aanmelden nee. Geen account, geen proefperiode, geen limiet op hoe vaak je vergelijkt. Plak je twee JSON-fragmenten en de diff verschijnt meteen. Niets zit achter een login, en de knoppen Copy en Download geven je schone uitvoer, zonder watermerk en zonder ingevoegde opmaak.
De vergelijking draait volledig in je browser, dus je JSON wordt nooit geüpload — veel online JSON diff-sites sturen het eerst naar een server, wat niet kan met een interne API-response of een config met secrets. De highlighting is op tekenniveau met semantische opschoning, niet per hele regel, dus één gewijzigde waarde in een object van 200 regels valt direct op. Er is ook Format, Minify en live validatie.
Ja. Klik op Upload in een van beide panelen en kies een .json-bestand rechtstreeks van schijf — laad je oude package.json links en de nieuwe rechts zonder kopiëren-plakken. Het bestand wordt lokaal in de browser gelezen; het wordt nergens naartoe gestuurd. Druk aan beide kanten op Format en de diff negeert witruimte, en toont alleen de dependency-regels die echt verschoven zijn.
Niet in één weergave. Het is gebouwd voor twee kanten, origineel en gewijzigd, want dat is een diff. Heb je drie config-versies, vergelijk ze dan in paren — staging tegen prod, dan prod tegen de voorgestelde wijziging. Elk paar geeft je een schoon, gericht resultaat in plaats van een drieweg-merge-weergave die verbergt welk bestand een bepaalde key introduceerde.
Ja. Het parsen, formatteren en diffen gebeuren allemaal op je eigen machine, en niets wordt geüpload, gelogd of opgeslagen. Een geplakte JWT, API key of klantrecord blijft in het tabblad en is weg zodra je het sluit. Om dit te bevestigen, open je de DevTools, kijk je naar het Network-tabblad terwijl je vergelijkt, en zie je nul uitgaande requests met je data.
Het kan samenvatten wat er tussen twee JSON-snippets veranderd is, en voor een snelle "wat is hier verschoven?" is dat echt handig. Maar een taalmodel is geen parser. Het kan stilletjes keys herordenen, een waarde diep in een genest object missen, of struikelen over gehele getallen boven 2^53, waar de precisie al verdwenen is. En je plakt de JSON, tokens en al, in een dienst van een derde partij. Voor een exacte vergelijking op tekenniveau die je browser nooit verlaat, haal het eerst door deze tool en geef het korte resultaat dan aan ChatGPT, en vraag om de impact in gewone taal uit te leggen.
Je JSON verlaat je browser nooit. De parser, formatter en diff draaien allemaal lokaal op je machine. Geen analytics op je input, geen logs, geen "behulpzame" cloud-rondreis. Parsen gebeurt met de native JSON.parse van de browser, en de JSON-specificatie die we volgen is RFC 8259.