Skip to content

JSON Diff (Comparar)

Compara dos archivos JSON al instante en tu navegador. Resaltado lado a lado, salida RFC 6902 JSON Patch, ignora campos ruidosos como marcas de tiempo e IDs. 100% privado, sin carga.

Sin rastreo Se ejecuta en el navegador Gratis
Rutas ignoradas:
Opciones avanzadas
Modo de array
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

¿Qué es JSON Diff?

JSON Diff es una comparación estructural de dos documentos JSON que respeta el modelo de datos de JSON — las claves no tienen orden, los tipos son estrictos y los arrays pueden estar ordenados o indexados por clave. A diferencia de un diff de texto (que compara líneas e informa de reordenaciones de claves o espacios en blanco como diferencias), un JSON diff produce resultados semánticamente significativos.

La forma canónica legible por máquinas es JSON Patch (RFC 6902), un array ordenado de operaciones (add, remove, replace, move, copy, test) que transforma un documento en otro. Las rutas usan JSON Pointer (RFC 6901). Relacionado: JSON Merge Patch (RFC 7396) — más sencillo pero no puede distinguir 'eliminar clave' de 'asignar null a clave'. Esta herramienta genera RFC 6902.

La igualdad profunda en JSON con JavaScript es más compleja de lo que parece. JSON.stringify(a) === JSON.stringify(b) falla con reordenación de claves y engaña con -0 vs 0 (ambos se serializan como "0"). Un diff correcto debe recorrer ambos árboles en paralelo usando la unión de conjuntos de claves, distinguir null de ausente mediante el operador 'in', y decidir qué significa 'igual' para los números (Object.is por defecto, épsilon para tolerancia).

Esta herramienta se ejecuta completamente en tu navegador. Las entradas nunca abandonan tu equipo. Segura para respuestas de API, esquemas internos y configuraciones propietarias.

¿Trabajas con herramientas JSON relacionadas? Da formato con el Formateador JSON; convierte con JSON a YAML y YAML a 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 }]

Características principales

Vista lateral + JSON Patch

Dos vistas desde un diff: resaltado visual para revisión, patch RFC 6902 para automatización.

Ignorar campos ruidosos

Los presets con un clic eliminan /createdAt, /updatedAt, /*Id, /*At, requestId, traceId. Se admiten patrones Extended JSON Pointer personalizados.

Coincidir arrays por clave

Compara arrays de objetos por un campo id en lugar de por índice — para envs de K8s, entradas de package-lock o cualquier lista lógicamente desordenada.

Estricto con los tipos por defecto

1 ≠ "1". null ≠ ausente. Detecta la deriva de serialización del backend en el momento en que aterrice en un fixture de prueba.

100% basado en el navegador

Las entradas nunca abandonan tu equipo. Sin carga, sin localStorage del JSON, sin análisis de lo que pegas.

Comparte el enlace, no los datos

Compartir enlace solo escribe tu configuración en la URL. Tus entradas JSON permanecen locales.

Ejemplos

Regresión de respuesta de API

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

Dos cambios (name + createdAt). Añade /user/createdAt a las rutas ignoradas y solo quedará el cambio de nombre.

Auditoría de archivo de configuración (reordenación de claves)

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

Mismos datos, distinto orden de claves. JSON Diff trata el orden de claves como semánticamente irrelevante — el diff está vacío.

Array de objetos (coincidencia por clave)

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

Cambia el modo de Array a 'Coincidir por clave' con key=id. Sin alineación, cada elemento parece modificado; con alineación, solo cambia qty en id=1.

Salida JSON Patch (RFC 6902)

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

Cambia a la pestaña JSON Patch para obtener [{"op":"replace","path":"/items/0/price","value":24.99}] que puedes aplicar con fast-json-patch.

Cómo usar

  1. 1

    Pega ambos documentos JSON

    Pega el JSON original (izquierda) y el modificado (derecha). El diff en vivo se renderiza mientras escribes; las entradas grandes (>200 KB) cambian a un botón manual de Diff.

  2. 2

    Filtra el ruido

    Haz clic en un preset (Timestamps / IDs / Trace) o pega patrones Extended JSON Pointer en las rutas ignoradas para eliminar campos irrelevantes.

  3. 3

    Elige la vista que necesitas

    Vista lateral para revisión humana, JSON Patch (RFC 6902) para operaciones aplicables por máquinas. Usa Compartir enlace para enviar la configuración a un compañero.

Errores comunes al comparar

Ruido por orden de claves (síntoma de diff de texto)

Si tu herramienta de diff informa {"a":1,"b":2} vs {"b":2,"a":1} como diferente, está haciendo diff de líneas, no diff de JSON. Las claves JSON no tienen orden — esta herramienta ignora el orden de claves automáticamente.

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

Confusión entre null y ausente

{"a":null} y {} no son lo mismo. Tratarlos como iguales oculta errores reales del backend.

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

Orden de arrays sin alineación por clave

[{id:1},{id:2}] vs [{id:2},{id:1}] no son 'dos cambios' para un conjunto lógico. El modo secuencial lo reporta así; cambia a Coincidir por clave.

✗ Incorrecto
Sequential diff: 4 modified
✓ Correcto
Match by key (id): 0 differences

Deriva de tipo (número vs cadena)

Los backends a veces serializan IDs de forma inconsistente — 42 vs "42". La herramienta marca estos como modificaciones de 'tipo' para que puedas detectar la deriva pronto.

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

Precisión de punto flotante

0.1 + 0.2 !== 0.3 en IEEE 754. Con tolerance=0 (por defecto), esto se marca. Establece la tolerancia a 1e-9 si deseas equivalencia numérica.

✗ Incorrecto
tolerance=0:  0.30000000000000004 ≠ 0.3
✓ Correcto
tolerance=1e-9: equal

Ruido de marcas de tiempo y UUID

createdAt, updatedAt, requestId, traceId cambian en cada petición. Usa los presets de rutas ignoradas para eliminarlos.

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

Casos de uso comunes

Regresión de respuesta de API
Compara respuestas de staging vs producción; ignora marcas de tiempo e IDs de petición para mostrar solo los cambios de payload significativos.
Fallos de pruebas de snapshot en CI
Pega el actual vs el esperado de un snapshot fallido en Jest/Vitest. Filtra el ruido y encuentra el cambio real en segundos.
Conflictos en package-lock / yarn.lock
Resuelve conflictos de fusión alineando dependencias por nombre; el orden de claves y los campos no relacionados dejan de ser ruido.
Auditoría de valores K8s / Helm
Alinea envs, volumeMounts y ports por nombre. Detecta ordenaciones no intencionadas frente a ediciones reales de configuración.
Cobertura de traducción i18n
Compara en.json contra zh.json estructuralmente para encontrar claves de traducción faltantes o extra sin ruido de valores.
Revisión de plan Terraform / CDK
Compara la salida del plan entre ejecuciones; la tolerancia numérica gestiona la aritmética de punto flotante, las rutas ignoradas eliminan ARNs y marcas de tiempo.

Detalles técnicos

Salida de patch conforme con RFC 6902
Genera operaciones JSON Patch válidas (add/remove/replace) con rutas RFC 6901. Verificado contra los paquetes npm fast-json-patch@3.x y rfc6902.
Traversal iterativo
Recorrido con pila explícita (sin recursión) limitado a 100.000 nodos y profundidad 64 para evitar desbordamiento de pila en entradas adversariales.
Igualdad numérica con Object.is
La tolerancia numérica predeterminada es 0 — usa Object.is para distinguir -0 de +0. Establece tolerancia > 0 para igualdad basada en épsilon.

Buenas prácticas

Filtra antes de revisar
Añade primero las rutas ignoradas (marcas de tiempo, IDs, campos de traza) y luego lee el diff. Revisar diffs ruidosos entrena el ojo a saltarse — y perderse — los cambios reales.
Coincidencia por clave para conjuntos lógicos
Si tu array representa un conjunto desordenado (envs, usuarios, dependencias), usa Coincidir por clave. El diff secuencial en conjuntos lógicos casi siempre es incorrecto.
Comparte el enlace, no las entradas
Usa Compartir enlace para enviar a un compañero tu configuración de filtros — nunca pegues JSON sensible en documentos compartidos. La URL contiene solo la configuración.

Preguntas frecuentes

¿Por qué el diff muestra todo como modificado si solo cambié un campo?
Tres sospechosos habituales: (1) orden diferente de claves — JSON Diff trata el orden de claves como equivalente, pero las herramientas de diff de texto no; (2) marcas de tiempo/UUIDs/auto-IDs que cambian en cada petición — añádelos a las rutas ignoradas; (3) orden de arrays, cuando la comparación por índice no corresponde — cambia el modo de Array a 'Coincidir por clave'.
¿Cómo ignoro marcas de tiempo e IDs en JSON diff?
Usa el campo de rutas ignoradas que aparece arriba. Haz clic en el preset 'Timestamps' o 'IDs' para filtrar con un clic /createdAt, /updatedAt, /*Id, /*At, /requestId. También puedes pegar tus propios patrones Extended JSON Pointer — uno por línea — para filtrado avanzado.
¿Cuál es la diferencia entre JSON Patch y un diff visual?
El diff visual (lado a lado) es para personas — se revisan los cambios visualmente. JSON Patch (RFC 6902) es para máquinas — un array estructurado de operaciones (add/remove/replace) que puedes aplicar con los paquetes npm fast-json-patch o rfc6902. Mismo diff, dos salidas.
¿JSON diff trata null y clave inexistente como lo mismo?
No. {"a":null} y {} son distintos — el primero tiene un null explícito, el segundo no tiene la clave. Los sistemas reales se comportan de forma diferente ante ambos; esta herramienta los mantiene separados.
¿Cómo se comparan los arrays — por índice o por clave?
Por índice (Secuencial) de forma predeterminada. Cambia a 'Coincidir por clave' e indica un campo clave (habitualmente id) para alinear elementos independientemente del orden. Usa esto para envs de K8s, entradas de package-lock o cualquier lista que sea lógicamente un conjunto.
¿Puedo exportar el diff como RFC 6902 JSON Patch?
Sí. La pestaña JSON Patch produce un array de operaciones RFC 6902 válido. Si hay rutas ignoradas, el patch se filtra (la pestaña muestra '(filtrado: excluye {n} rutas ignoradas)') y no permitirá reconstruir exactamente los originales. Limpia las rutas ignoradas para obtener un patch completo.
¿JSON Patch es lo mismo que JSON Merge Patch (RFC 7396)?
No. RFC 6902 (JSON Patch) es un array ordenado de operaciones — explícito y reversible. RFC 7396 (Merge Patch) es un único documento de fusión — más sencillo pero no puede representar la eliminación de forma diferente a asignar null. JSON Diff genera RFC 6902.
¿Cómo comparo dos archivos JSON grandes (>10 MB)?
Los archivos de más de ~5 MB superan la memoria práctica del navegador. El modo en vivo se desactiva con 200 KB; para archivos de varios megabytes, usa jq en línea de comandos o fast-json-patch en Node.
¿La herramienta envía mi JSON a un servidor?
No. Todo el proceso se ejecuta localmente en tu navegador. Las entradas nunca se escriben en disco, red, localStorage ni parámetros de URL. Recargar la página las borra. El botón Compartir enlace solo escribe tu configuración (modo de Array, rutas ignoradas) — nunca tus datos.
¿Por qué 42 es diferente de "42" en el diff?
JSON Diff es estricto con los tipos: el número 42 y la cadena "42" no son iguales. Esto detecta la deriva de serialización del backend (algunos endpoints devuelven IDs numéricos, otros cadenas) — el diff lo etiqueta como modificación de 'tipo'.
¿Puedo comparar JSON con comentarios (JSONC) o comas finales?
El JSON estándar (RFC 8259) no permite comentarios ni comas finales. Esta herramienta usa JSON.parse nativo, que rechaza ambos. Elimina los comentarios primero con el Formateador JSON.
¿Cómo comparo arrays anidados de objetos por una clave como id?
Establece el modo de Array a 'Coincidir por clave' e introduce id. El diff alinea por valores de id. v1 aplica el mismo campo clave en todos los niveles de arrays; los arrays internos sin ese campo vuelven al modo secuencial y emiten un aviso.
¿El diff maneja la precisión de punto flotante (0.1 + 0.2)?
Sí, con tolerancia numérica. El valor predeterminado es 0 con Object.is — por lo que -0 vs +0 se marcan. Establece la tolerancia a un pequeño épsilon (p. ej., 1e-9) y 0.1 + 0.2 se comparará como igual a 0.3. La tolerancia se aplica solo a hojas numéricas.

Herramientas relacionadas

Ver todas las herramientas →