Pega, formatea y compara dos fragmentos de JSON lado a lado. Validación, formato legible y minificación incluidos.
Una herramienta gratuita, en el navegador, para comparar dos documentos JSON. Pega la versión antigua a la izquierda, la nueva a la derecha, y las diferencias se iluminan carácter por carácter. Nada sale de tu equipo.
Usa el JSON.parse nativo de tu navegador para validar. Hay un botón Formatear cuando tu JSON viene en una sola línea minificada gigantesca, un botón Minificar para el caso contrario, y validación en vivo que marca errores de sintaxis mientras escribes.
Si alguna vez te has quedado mirando un diff de un openapi.json de 6.000 líneas en una PR de GitHub intentando encontrar el único campo que rompió un cliente downstream, esta es la herramienta que te lleva ahí en segundos.
El diff es a nivel de carácter, después limpiado con un postprocesado semántico para que los resaltados caigan sobre fragmentos con significado y no sobre caracteres sueltos. Las inserciones aparecen en verde en el panel derecho; las eliminaciones, en rojo en el izquierdo.
JSON tiene sus propias rarezas que la especificación deja claras. La especificación de JSON en RFC 8259 define los objetos como no ordenados, así que reordenar claves técnicamente no cambia nada aunque un diff de texto lo marque. Lo gestionamos dándote un botón Formatear en cada lado: formatea ambos, después compara, y el orden será consistente. Para trabajo estructural más profundo, mira JSON Patch (RFC 6902) o el más sencillo formato JSON Merge Patch (RFC 7396), que son las dos formas estándar de describir un cambio JSON como datos.
Cuando el orden importa para hashing o firmado, la especificación relevante es RFC 8785 (JSON Canonicalization Scheme). Ordena las claves, normaliza el formato de los números, después haz el diff.
Dos paneles de texto, un diff. Sin registro, sin subida, sin viaje al servidor.
Pega el JSON antiguo a la izquierda, el nuevo a la derecha. O haz clic en Subir en cualquiera de los dos lados para cargar un archivo .json directamente. El botón Ejemplo rellena ambos paneles con un caso pequeño si quieres ver la herramienta en acción primero.
Haz clic en Formatear en cada panel para imprimir con sangría de dos espacios. Esto normaliza espacios y saltos de línea, así el diff resalta cambios reales en los datos, no diferencias de formato. La etiqueta de validación se pone verde cuando tu JSON parsea sin errores.
Las eliminaciones aparecen resaltadas en rojo a la izquierda, las inserciones en verde a la derecha. Haz scroll en cualquier lado y el otro le sigue. Los contadores de cambios en cada cabecera te dicen cuántas ediciones distintas encontró el diff.
Pega la salida actual de aws iam get-policy-version contra el JSON propuesto para ver exactamente qué entradas Action se añadieron, o si alguien coló "Resource": "*" dentro de una sentencia que antes era específica. La consola de AWS reordena las sentencias al guardar, lo que hace que un diff de GitHub engañe; formatea ambos lados aquí y el cambio real salta a la vista.
Cuando terraform show -json tfplan devuelve un blob de 4 MB, mirarlo a ojo es imposible. Compara el plan de hoy con el de ayer para sacar a flote el aws_security_group_rule que alguien añadió bajo una PR de refactor o el bloque lifecycle.ignore_changes que desapareció sin ruido.
Un diff de un openapi.json de 6.000 líneas es ilegible cuando un generador de código reordena paths alfabéticamente. Formatea ambos lados, compara, y el cambio real aflora: un campo required añadido a CreateOrderRequest, o una respuesta 200 cuyo esquema cambió silenciosamente de string a string | null.
Después de resolver un conflicto en package-lock.json, compara tu archivo resuelto contra el lockfile de main para cazar un downgrade transitivo. npm a veces resuelve el mismo rango semver a versiones exactas distintas en máquinas diferentes, que es la causa real de "funciona en mi máquina, falla en CI". Lee la documentación de package-lock.json para saber qué significa cada campo.
Saca GET /my-index/_mapping de staging y de prod, mete los dos en el diff. Prod puede seguir teniendo "type": "text" en un campo que staging migró a "keyword" el sprint pasado, que es la razón por la que la query de agregación devuelve nada en prod y funciona local. Los mappings anidan cinco o seis niveles de profundidad y un diff de texto entierra esto en ruido.
Cuando un test de Playwright pasa local y falla en CI, captura el cuerpo JSON de la respuesta que el test vio realmente y compáralo con el fixture en tu repo. A menudo es un timestamp createdAt o un campo traceId que nadie fijó, y el diff estructural deja la clave culpable a la vista en lugar de tirarte a un muro de texto formateado.
Una hoja resumen de los casos límite de parseo que esta herramienta saca a la luz con más frecuencia. Todo está basado en la especificación de JSON.
| Topic | What this tool does |
|---|---|
| Orden de claves de objeto | No ordenado según la spec. {"a":1,"b":2} equivale a {"b":2,"a":1}. Usa Ordenar claves para normalizar antes de comparar. |
| Orden de array | Ordenado. [1,2,3] no es igual a [3,2,1]. Ordena manualmente si el orden no importa para tu caso. |
| Comas finales | No permitidas. { "a": 1, } es un error de parseo en JSON estándar. Permitidas en JSON5/JSONC, que son superconjuntos: quítalas primero. |
| Comentarios | No permitidos. // como esto es un error de parseo. JSON5 y JSONC los aceptan; esta herramienta sigue la gramática estricta de RFC 8259. |
| Números | Parseados como floats IEEE 754 de 64 bits. 0.1 + 0.2 = 0.30000000000000004. Los enteros por encima de 2^53 − 1 pierden precisión; guarda los IDs snowflake como strings. |
| Claves duplicadas | La spec las llama comportamiento indefinido. La mayoría de parsers se quedan con la última ocurrencia. El diff te las muestra todas, que es lo que normalmente quieres al auditar archivos de configuración. |
| Codificación | Solo UTF-8. RFC 8259 prohíbe un BOM UTF-8 al inicio del documento; algunos parsers lo aceptan igualmente, pero la spec no. |
| Null vs ausente | Una clave con valor null está presente. Una clave ausente no está. Distinto del undefined de JavaScript, que no tiene representación en JSON. |
No. El diff corre entero en tu navegador. Nada se envía a un servidor, ni se registra, ni se almacena. Pega una respuesta de API interna o una política IAM y cierra la pestaña; no queda copia en ningún lado. Para verificarlo, abre DevTools, ve a la pestaña Red, y observa: no hay peticiones salientes cuando comparas.
Sí, ambos lo hacen. Un diff de texto compara caracteres línea a línea, así que reformatear, reordenar claves o cambios de espacios en blanco aparecen como diferencias aunque los datos sean idénticos. Pulsa el botón Formatear en ambos paneles primero y el diff se centra en cambios reales de datos. Para una comparación totalmente estructural que ignore el orden de claves, ordena las claves en ambos lados antes de comparar.
Para claves de objeto, no: la spec de JSON dice que los objetos son no ordenados, así que {"a":1,"b":2} y {"b":2,"a":1} representan los mismos datos. Un diff por caracteres aún marcará el reorden, por eso el botón Formatear importa. Los arrays son distintos: [1,2,3] y [3,2,1] no son iguales porque el orden del array sí tiene significado en JSON.
Por punto flotante IEEE 754. 0.1 + 0.2 es en realidad 0.30000000000000004, y JSON.parse lee los números como floats de 64 bits. Los enteros grandes chocan con el mismo límite: cualquier cosa por encima de 2^53 - 1 (9007199254740991) pierde precisión, así que un ID estilo snowflake de Twitter no sobrevive el round-trip. Si la precisión importa, guárdalos como strings.
El JSON estándar no permite ninguno de los dos. { "a": 1, } o // comentario te darán un error de parseo. Eso es JSON5 o JSONC (el formato que usa VS Code para settings.json), que es un superconjunto. Quita los comentarios y comas finales primero. Seguimos la gramática estricta de RFC 8259 a propósito, para que el diff coincida con lo que tu API realmente acepta.
Hasta unos pocos MB va bien, en menos de un segundo. Pasados los 10 MB el navegador empieza a notarlo, sobre todo porque renderizar el diff (no calcularlo) es lo que se vuelve caro. Para exports de 50 MB o más, filtra ambos lados al subárbol que te interesa con jq primero, y después pega eso.
Gratis sí, registro no. No hay cuenta, ni prueba, ni límite en cuántas veces comparas. Pega tus dos fragmentos de JSON y el diff aparece al momento. Nada queda detrás de un login, y los botones Copiar y Descargar te dan una salida limpia, sin marca de agua y sin formato inyectado.
La comparación corre entera en tu navegador, así que tu JSON nunca se sube — muchas webs de JSON diff lo envían a un servidor primero, algo que no puedes hacer con una respuesta de API interna o un config con secretos. El resaltado es a nivel de carácter con limpieza semántica, no por líneas enteras, así que un único valor cambiado en un objeto de 200 líneas salta a la vista. También trae Formatear, Minificar y validación en vivo.
Sí. Haz clic en Subir en cualquiera de los dos paneles y elige un archivo .json directamente del disco — carga tu viejo package.json a la izquierda y el nuevo a la derecha sin copiar y pegar. El archivo se lee en local en el navegador; nunca se envía a ningún sitio. Pulsa Formatear en ambos lados y el diff ignora los espacios, mostrando solo las líneas de dependencias que de verdad se movieron.
No en una sola vista. Está hecho para dos lados, original y modificado, porque eso es un diff. Si tienes tres versiones de config, compáralas por pares — staging contra prod, después prod contra el cambio propuesto. Cada par te da un resultado limpio y enfocado en vez de una vista de fusión a tres bandas que oculta qué archivo introdujo una clave.
Sí. El parseo, el formateo y el diff ocurren todos en tu máquina, y nada se sube, se registra ni se almacena. Un JWT, una API key o un registro de cliente que pegues se queda en la pestaña y desaparece al cerrarla. Para confirmarlo, abre DevTools, observa la pestaña Red mientras comparas, y verás cero peticiones salientes con tus datos.
Puede resumir qué cambió entre dos fragmentos de JSON, y para un rápido "¿qué se movió aquí?" resulta la mar de práctico. Pero un modelo de lenguaje no es un parser. Puede reordenar claves sin avisar, pasar por alto un valor enterrado en el fondo de un objeto anidado, o tropezar con enteros por encima de 2^53, donde la precisión ya está perdida. Y estás pegando el JSON, tokens incluidos, en un servicio de terceros. Para una comparación exacta, a nivel de carácter, que nunca sale de tu navegador, pásalo antes por esta herramienta y luego entrega el resultado corto a ChatGPT y pídele que explique el impacto en lenguaje llano.
Tu JSON nunca sale de tu navegador. El parser, el formateador y el diff corren todos en tu máquina, en local. Sin analítica sobre lo que pegas, sin logs, sin viajes "útiles" a la nube. El parseo usa el JSON.parse nativo del navegador, y la spec de JSON que seguimos es RFC 8259.