Incolla, formatta e confronta due frammenti JSON affiancati. Validazione, pretty-print e minify integrati.
Uno strumento gratuito, in-browser, per confrontare due documenti JSON. Incolla la versione vecchia a sinistra, quella nuova a destra, e le differenze si accendono carattere per carattere. Niente lascia la tua macchina.
Usa il JSON.parse nativo del tuo browser per la validazione. C'è un pulsante Format quando il tuo JSON arriva su un'unica riga minificata gigante, un pulsante Minify per il caso opposto, e validazione live che segnala errori di sintassi mentre digiti.
Se hai mai fissato un diff openapi.json da 6.000 righe in una PR di GitHub cercando l'unico campo che ha rotto un client downstream, questo è lo strumento che ti porta lì in pochi secondi.
Il diff è a livello di carattere, poi ripulito da un post-processing semantico in modo che le evidenziazioni cadano su blocchi sensati invece che su caratteri casuali. Le inserzioni appaiono in verde nel pannello destro, le cancellazioni in rosso in quello sinistro.
JSON ha le sue stranezze che la spec mette nero su bianco. La specifica JSON in RFC 8259 definisce gli oggetti come non ordinati, quindi riordinare le chiavi è tecnicamente un'operazione neutra anche se un diff testuale lo segnala. Lo gestiamo dandoti un pulsante Format su ciascun lato: formatta entrambi, poi confronta, e l'ordine sarà coerente. Per lavoro strutturale più approfondito guarda JSON Patch (RFC 6902) o il più semplice formato JSON Merge Patch (RFC 7396), i due modi standard di descrivere una modifica JSON come dato.
Quando l'ordine conta per hashing o firma, la spec di riferimento è RFC 8785 (JSON Canonicalization Scheme). Ordina le chiavi, normalizza la formattazione dei numeri, poi fai il diff.
Due pannelli di testo, un diff. Niente registrazione, niente upload, niente andata e ritorno al server.
Incolla il JSON vecchio a sinistra, quello nuovo a destra. Oppure clicca Upload su un lato qualsiasi per caricare direttamente un file .json. Il pulsante Sample riempie entrambi i pannelli con un esempio piccolo se vuoi prima vedere lo strumento all'opera.
Clicca Format su ciascun pannello per stamparlo con indentazione di due spazi. Questo normalizza spazi e a capo, così il diff evidenzia cambi di dato reali e non differenze di formattazione. Il badge di validazione diventa verde quando il tuo JSON parsa pulito.
Le cancellazioni appaiono con evidenziazione rossa a sinistra, le inserzioni con evidenziazione verde a destra. Scorri un lato e l'altro segue. I contatori di modifiche in ogni intestazione ti dicono quante modifiche distinte ha trovato il diff.
Incolla l'output corrente di aws iam get-policy-version contro il JSON proposto per vedere esattamente quali voci Action sono state aggiunte, o se qualcuno ha infilato "Resource": "*" in uno statement prima specifico. La console AWS riordina gli statement al salvataggio, il che rende un diff GitHub fuorviante; formatta entrambi i lati qui e il vero cambiamento diventa ovvio.
Quando terraform show -json tfplan restituisce un blob da 4 MB, leggerlo a occhio è disperato. Confronta il piano di oggi con quello di ieri per far emergere la aws_security_group_rule che qualcuno ha aggiunto sotto una PR di refactor o il blocco lifecycle.ignore_changes sparito in silenzio.
Un diff di openapi.json da 6.000 righe è illeggibile quando un generatore di codice riordina alfabeticamente i paths. Formatta entrambi i lati, confronta, e il vero cambiamento emerge: un campo required aggiunto a CreateOrderRequest, o una risposta 200 il cui schema è passato silenziosamente da string a string | null.
Dopo aver risolto un conflitto su package-lock.json, confronta il file risolto con il lockfile di main per beccare un downgrade transitivo. npm a volte risolve lo stesso intervallo semver in versioni esatte diverse su macchine diverse, ed è la vera causa di "funziona sulla mia macchina, fallisce in CI". Leggi la documentazione di package-lock.json per il significato di ogni campo.
Tira fuori GET /my-index/_mapping da staging e da produzione, butta entrambi nel diff. La produzione potrebbe avere ancora "type": "text" su un campo che staging ha migrato a "keyword" lo sprint scorso, ed è proprio per questo che la query di aggregazione non restituisce nulla in produzione e funziona in locale. I mapping sono annidati per cinque o sei livelli e un diff testuale seppellisce questa cosa nel rumore.
Quando un test Playwright passa in locale e fallisce in CI, cattura il body JSON della risposta che il test ha effettivamente visto e confrontalo con la fixture nel tuo repo. Spesso è un timestamp createdAt o un campo traceId che nessuno ha fissato, e il diff strutturale rende ovvia la chiave colpevole invece di scaricarti in un muro di testo formattato.
Un breve cheat sheet sui casi limite di parsing che questo strumento fa emergere più spesso. Tutto ancorato alla specifica JSON.
| Topic | What this tool does |
|---|---|
| Ordine delle chiavi dell'oggetto | Non ordinato secondo la spec. {"a":1,"b":2} equivale a {"b":2,"a":1}. Usa Sort keys per normalizzare prima di confrontare. |
| Ordine dell'array | Ordinato. [1,2,3] non è uguale a [3,2,1]. Ordina manualmente se l'ordine non conta per il tuo caso. |
| Virgole finali | Non ammesse. { "a": 1, } è un errore di parsing nel JSON standard. Ammesse in JSON5/JSONC, che sono superset: toglile prima. |
| Commenti | Non ammessi. // così è un errore di parsing. JSON5 e JSONC li accettano; questo strumento segue la grammatica stretta di RFC 8259. |
| Numeri | Parsati come float IEEE 754 a 64 bit. 0.1 + 0.2 = 0.30000000000000004. Gli interi sopra 2^53 − 1 perdono precisione; salva gli ID snowflake come stringhe. |
| Chiavi duplicate | La spec le definisce comportamento indefinito. La maggior parte dei parser tiene l'ultima occorrenza. Il diff te le mostra tutte, che è di solito quello che vuoi quando auditi file di configurazione. |
| Encoding | Solo UTF-8. RFC 8259 vieta un BOM UTF-8 all'inizio del documento; alcuni parser lo accettano comunque, ma la spec no. |
| Null vs assente | Una chiave con valore null è presente. Una chiave assente non c'è. Diverso dall'undefined di JavaScript, che non ha rappresentazione JSON. |
No. Il diff gira interamente nel tuo browser. Niente viene mandato a un server, loggato o salvato. Incolla una risposta di API interna o una policy IAM e chiudi la scheda; non resta nessuna copia. Per verificare, apri DevTools, passa al tab Network e guarda: quando confronti non ci sono richieste in uscita.
Sì, entrambi. Un diff testuale confronta caratteri riga per riga, quindi riformattazione, riordino delle chiavi o cambi di spazi appaiono come differenze anche quando i dati sono identici. Clicca prima il pulsante Format su entrambi i pannelli e il diff si concentra sui cambi di dato reali. Per un confronto pienamente strutturale che ignora l'ordine delle chiavi, ordina le chiavi su entrambi i lati prima di fare il diff.
Per le chiavi degli oggetti no: la spec di JSON dice che gli oggetti non sono ordinati, quindi {"a":1,"b":2} e {"b":2,"a":1} rappresentano gli stessi dati. Un diff a caratteri segnalerà comunque il riordino, ed è per questo che il pulsante Format conta. Gli array sono diversi: [1,2,3] e [3,2,1] non sono uguali perché in JSON l'ordine dell'array ha significato.
Per via dei numeri in virgola mobile IEEE 754. 0.1 + 0.2 è in realtà 0.30000000000000004, e JSON.parse legge i numeri come float a 64 bit. Gli interi grandi sbattono contro lo stesso limite: tutto ciò che supera 2^53 - 1 (9007199254740991) perde precisione, quindi un ID stile snowflake di Twitter non sopravvive al round-trip. Se la precisione conta, salvali come stringhe.
Lo standard JSON non permette nessuna delle due cose. { "a": 1, } o // commento ti daranno un errore di parsing. Quello è JSON5 o JSONC (il formato che VS Code usa per settings.json), che è un superset. Togli prima commenti e virgole finali. Seguiamo apposta la grammatica stretta di RFC 8259, così il diff coincide con quello che la tua API accetta davvero.
Fino a qualche MB va benissimo, sotto il secondo. Oltre i 10 MB il browser inizia a sentirlo, soprattutto perché è il rendering del diff (non il calcolarlo) a diventare costoso. Per export da 50 MB in su, filtra prima entrambi i lati al sottoalbero che ti interessa con jq, e poi incolla quello.
Gratis sì, registrazione no. Niente account, niente prova, niente limite a quante volte confronti. Incolla i tuoi due frammenti JSON e il diff compare subito. Niente è chiuso dietro un login, e i pulsanti Copy e Download ti restituiscono un output pulito, senza filigrana e senza formattazione iniettata.
Il confronto gira interamente nel tuo browser, quindi il tuo JSON non viene mai caricato — molti siti di JSON diff lo mandano prima a un server, cosa che non puoi fare con una risposta di API interna o un config con dei segreti. L'evidenziazione è a livello di carattere con pulizia semantica, non per riga intera, così un singolo valore cambiato in un oggetto da 200 righe salta all'occhio. Ci sono anche Format, Minify e validazione in tempo reale.
Sì. Clicca su Upload in uno dei due pannelli e scegli un file .json direttamente dal disco — carica il tuo vecchio package.json a sinistra e quello nuovo a destra senza copia-incolla. Il file viene letto in locale nel browser; non viene mai inviato da nessuna parte. Premi Format su entrambi i lati e il diff ignora gli spazi, mostrando solo le righe di dipendenze che si sono davvero spostate.
Non in un'unica vista. È fatto per due lati, originale e modificato, perché è questo un diff. Se hai tre versioni di config, confrontale a coppie — staging contro prod, poi prod contro la modifica proposta. Ogni coppia ti dà un risultato pulito e mirato invece di una vista di merge a tre vie che nasconde quale file ha introdotto una certa chiave.
Sì. Il parsing, la formattazione e il diff avvengono tutti sulla tua macchina, e niente viene caricato, loggato o memorizzato. Un JWT, una API key o un record cliente che incolli resta nella scheda e sparisce quando la chiudi. Per verificarlo, apri i DevTools, guarda la scheda Network mentre confronti, e vedrai zero richieste in uscita con i tuoi dati.
Può riassumere cosa è cambiato tra due frammenti di JSON, e per un veloce "cosa si è spostato qui?" torna davvero comodo. Ma un modello linguistico non è un parser. Può riordinare le chiavi senza dirtelo, mancare un valore sepolto in fondo a un oggetto annidato, o inciampare sugli interi oltre 2^53, dove la precisione è ormai persa. E stai incollando il JSON, token compresi, dentro un servizio di terze parti. Per un confronto esatto, a livello di carattere, che non lascia mai il tuo browser, passalo prima da questo strumento, poi consegna il breve risultato a ChatGPT e chiedigli di spiegarne l'impatto in parole semplici.
Il tuo JSON non lascia mai il tuo browser. Parser, formattatore e diff girano tutti sulla tua macchina, in locale. Niente analytics su quello che incolli, niente log, niente "comodi" giri sul cloud. Il parsing usa il JSON.parse nativo del browser, e la spec JSON che seguiamo è RFC 8259.