Klistra in, formatera och jämför två JSON-utdrag sida vid sida. Validering, pretty-print och minifiering inbyggt.
Ett gratis verktyg i webbläsaren för att jämföra två JSON-dokument. Klistra in en gammal version till vänster, den nya till höger, och skillnaderna lyser upp tecken för tecken. Inget lämnar din maskin.
Det använder din webbläsares inbyggda JSON.parse för validering. Det finns en Format-knapp när din JSON är en enda gigantisk minifierad rad, en Minify-knapp för det motsatta fallet, och liveloggning som markerar syntaxfel medan du skriver.
Om du någonsin har stirrat på en 6 000 raders openapi.json-diff i en GitHub-PR och försökt hitta det enda fältet som bröt en downstream-klient, är detta verktyget som tar dig dit på sekunder.
Jämförelsen sker på teckennivå, sedan städas den med semantisk efterbearbetning så att markeringarna landar på meningsfulla bitar snarare än slumpmässiga tecken. Insättningar visas i grönt i den högra panelen, borttagningar i rött i den vänstra.
JSON har sina egna egenheter som specifikationen pekar ut. JSON-specifikationen i RFC 8259 definierar objekt som oordnade, så att ändra ordning på nycklar är tekniskt sett ingen åtgärd även om en text-diff kommer flagga det. Vi hanterar det genom att ge dig en Format-knapp på varje sida: formatera båda, jämför sedan, och ordningen blir konsekvent. För djupare strukturellt arbete, kolla in JSON Patch (RFC 6902) eller det enklare JSON Merge Patch-formatet (RFC 7396), vilka är de två standardsätten att beskriva en JSON-ändring som data.
När ordning spelar roll för hashning eller signering är RFC 8785 (JSON Canonicalization Scheme) den relevanta specifikationen. Sortera nycklar, normalisera nummerformatering, jämför sedan.
Två textpaneler, en diff. Ingen registrering, ingen uppladdning, ingen serverrundtur.
Klistra in den gamla JSON-koden till vänster, den nya JSON-koden till höger. Eller klicka Upload på endera sidan för att ladda en .json-fil direkt. Sample-knappen fyller båda panelerna med ett litet exempel om du först vill se verktyget i aktion.
Klicka Format i varje panel för att pretty-printa med två mellanslags indrag. Detta normaliserar blanksteg och radbrytningar så att jämförelsen markerar faktiska dataändringar, inte formateringsskillnader. Valideringsmärket blir grönt när din JSON parsas rent.
Borttagningar visas med röd markering till vänster, insättningar med grön markering till höger. Skrolla en sida och den andra följer med. Antalet ändringar i varje rubrik talar om hur många distinkta redigeringar jämförelsen hittade.
Klistra in den aktuella utdatan från aws iam get-policy-version mot den föreslagna JSON-koden för att se exakt vilka Action-poster som lagts till, eller om någon smugit in "Resource": "*" i en tidigare specifik sats. AWS-konsolen omordnar satser vid sparande, vilket gör en GitHub-diff missvisande; formatera båda sidor här så blir den verkliga ändringen tydlig.
När terraform show -json tfplan returnerar en 4 MB-blob är det hopplöst att titta med ögonen. Jämför dagens plan mot gårdagens för att få fram aws_security_group_rule som någon lagt till under en refactor-PR eller lifecycle.ignore_changes-blocket som tyst försvann.
En 6 000 raders openapi.json-diff är oläslig när en kodgenerator omordnar paths alfabetiskt. Formatera båda sidor, jämför, och den verkliga ändringen kommer fram: ett required-fält tillagt i CreateOrderRequest, eller ett 200-svar vars schema tyst bytte från string till string | null.
Efter att du löst en konflikt i package-lock.json, jämför din lösta fil mot lockfilen i main för att fånga en transitiv nedgradering. npm löser ibland samma semver-intervall till olika exakta versioner på olika maskiner, vilket är den faktiska orsaken till "fungerar på min maskin, fallerar i CI". Läs package-lock.json-dokumentationen för vad varje fält betyder.
Hämta GET /my-index/_mapping från staging och prod, släpp båda i jämförelsen. Prod kan fortfarande ha "type": "text" på ett fält som staging migrerade till "keyword" förra sprinten, vilket är därför aggregation-frågan inte returnerar något i prod och fungerar lokalt. Mappningar nästar fem eller sex nivåer djupt och en text-diff begraver detta i brus.
När ett Playwright-test passerar lokalt och fallerar i CI, fånga JSON-svarskroppen som testet faktiskt såg och jämför den mot fixturen i ditt repo. Ofta är det en createdAt-tidsstämpel eller ett traceId-fält som ingen pinnade, och den strukturella jämförelsen gör den skyldiga nyckeln uppenbar i stället för att dumpa dig i en vägg av formaterad text.
Ett kort fusklapp för parse-gränsfallen som detta verktyg får upp till ytan oftast. Allt är grundat i JSON-specifikationen.
| Topic | What this tool does |
|---|---|
| Objektnyckelordning | Oordnad enligt specifikationen. {"a":1,"b":2} är lika med {"b":2,"a":1}. Använd Sortera nycklar för att normalisera innan du jämför. |
| Array-ordning | Ordnad. [1,2,3] är inte lika med [3,2,1]. Sortera manuellt om ordning inte spelar roll för ditt användningsfall. |
| Efterföljande kommatecken | Ej tillåtna. { "a": 1, } är ett parse-fel i standard-JSON. Tillåtet i JSON5/JSONC, vilka är supermängder — ta bort dem först. |
| Kommentarer | Ej tillåtna. // så här är ett parse-fel. JSON5 och JSONC accepterar dem; detta verktyg följer den strikta RFC 8259-grammatiken. |
| Tal | Parsade som 64-bitars IEEE 754 floats. 0.1 + 0.2 = 0.30000000000000004. Heltal över 2^53 − 1 tappar precision; lagra snowflake-ID:n som strängar. |
| Duplicerade nycklar | Specifikationen kallar det odefinierat beteende. De flesta parsers behåller den sista förekomsten. Jämförelsen visar alla, vilket vanligtvis är vad du vill ha när du granskar konfigurationsfiler. |
| Kodning | Endast UTF-8. RFC 8259 förbjuder en UTF-8 BOM i början av dokumentet; vissa parsers accepterar det ändå, men specifikationen gör det inte. |
| Null kontra saknad | En nyckel med värdet null är närvarande. En saknad nyckel är frånvarande. Skiljer sig från JavaScript's undefined, som inte har någon JSON-representation. |
Nej. Jämförelsen körs helt och hållet i din webbläsare. Inget skickas till en server, loggas eller lagras. Klistra in ett internt API-svar eller en IAM-policy och stäng fliken; ingen kopia lämnas kvar. För att verifiera, öppna DevTools, växla till Network-fliken och titta — det finns inga utgående förfrågningar när du jämför.
Ja, båda gör det. En text-diff jämför tecken rad för rad, så omformatering, omordnade nycklar eller blanksteg-ändringar dyker upp som skillnader även när data är identisk. Klicka på Format-knappen på båda panelerna för att pretty-printa först, så fokuserar jämförelsen på verkliga dataändringar. För en helt strukturell jämförelse som ignorerar nyckelordning, sortera nycklarna på båda sidor innan du jämför.
För objektnycklar nej — JSON-specifikationen säger att objekt är oordnade, så {"a":1,"b":2} och {"b":2,"a":1} representerar samma data. En tecken-diff kommer ändå flagga omordningen, vilket är därför Format-knappen spelar roll. Arrayer är annorlunda: [1,2,3] och [3,2,1] är inte lika eftersom array-ordning är meningsfull i JSON.
På grund av IEEE 754 flyttal. 0.1 + 0.2 är faktiskt 0.30000000000000004, och JSON.parse läser tal som 64-bitars floats. Stora heltal träffar samma gräns: allt över 2^53 - 1 (9007199254740991) tappar precision, så ett snowflake-ID i Twitter-stil överlever inte rundturen. Om precision spelar roll, lagra dem som strängar.
Standard-JSON tillåter ingetdera. { "a": 1, } eller // kommentar ger dig ett parse-fel. Det är JSON5 eller JSONC (formatet VS Code använder för settings.json), vilket är en supermängd. Ta bort kommentarer och efterföljande kommatecken först. Vi följer den strikta RFC 8259-grammatiken medvetet så att jämförelsen matchar vad ditt API faktiskt accepterar.
Upp till några MB är okej, under en sekund. Förbi 10 MB börjar webbläsaren känna det, mest för att rendera jämförelsen (inte beräkna den) är vad som blir dyrt. För 50 MB+ exporter, filtrera båda sidor till det delträd du bryr dig om med jq först, och klistra sedan in det.
Gratis ja, registrering nej. Inget konto, ingen testperiod, ingen gräns för hur många gånger du jämför. Klistra in dina två JSON-snuttar så dyker diffen upp direkt. Inget är inlåst bakom en inloggning, och knapparna Copy och Download ger dig ren utdata, utan vattenstämpel och utan inympad formatering.
Jämförelsen körs helt i din webbläsare, så din JSON laddas aldrig upp — många online-JSON diff-sajter skickar den till en server först, vilket du inte kan göra med ett internt API-svar eller en config med hemligheter. Markeringen är på teckennivå med semantisk uppstädning, inte hela rader, så ett enda ändrat värde i ett objekt på 200 rader sticker ut direkt. Det finns även Format, Minify och validering i realtid.
Ja. Klicka på Upload i någon av panelerna och välj en .json-fil direkt från disken — ladda din gamla package.json till vänster och den nya till höger utan att kopiera och klistra. Filen läses lokalt i webbläsaren; den skickas aldrig någonstans. Tryck Format på båda sidor så ignorerar diffen blanksteg och visar bara de beroenderader som faktiskt flyttat sig.
Inte i en och samma vy. Den är byggd för två sidor, original och ändrad, för det är vad en diff är. Har du tre config-versioner jämför du dem parvis — staging mot prod, sedan prod mot den föreslagna ändringen. Varje par ger ett rent, fokuserat resultat istället för en trevägs-merge-vy som döljer vilken fil som införde en viss nyckel.
Ja. Parsning, formatering och diff sker allt på din maskin, och inget laddas upp, loggas eller lagras. En inklistrad JWT, API key eller kundpost stannar i fliken och är borta när du stänger den. För att bekräfta det, öppna DevTools, titta på Network-fliken medan du jämför, så ser du noll utgående förfrågningar med din data.
Det kan sammanfatta vad som ändrats mellan två JSON-snuttar, och för ett snabbt "vad flyttade sig här?" är det faktiskt praktiskt. Men en språkmodell är ingen parser. Den kan tyst omordna nycklar, missa ett värde som ligger djupt i ett nästlat objekt, eller snubbla på heltal över 2^53 där precisionen redan är borta. Och du klistrar in din JSON, tokens och allt, i en tredjepartstjänst. För en exakt jämförelse på teckennivå som aldrig lämnar din webbläsare, kör den genom det här verktyget först, och lämna sedan det korta resultatet till ChatGPT och be den förklara följderna på vanlig svenska.
Din JSON lämnar aldrig din webbläsare. Parser, formaterare och jämförelse körs alla på din maskin, lokalt. Ingen analys av din indata, inga loggar, ingen "hjälpsam" molnrundtur. Parsning använder webbläsarens inbyggda JSON.parse, och JSON-specifikationen vi följer är RFC 8259.