Skip to content

JSON Diff (Comparar)

Compare dois arquivos JSON instantaneamente no navegador. Destaque lado a lado, saída JSON Patch (RFC 6902), ignore campos ruidosos como timestamps e IDs. 100% privado, sem upload.

Sem rastreamento Roda no navegador Grátis
Ignorar caminhos:
Opções Avançadas
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

O que é JSON Diff?

JSON Diff é uma comparação estrutural de dois documentos JSON que respeita o modelo de dados do JSON — chaves são desordenadas, tipos são estritos e arrays podem ser ordenados ou identificados por chave. Ao contrário de um diff de texto (que compara linhas e reporta reordenações de chaves ou espaços em branco como diferenças), um JSON diff produz resultados semanticamente significativos.

A forma canônica legível por máquina é o JSON Patch (RFC 6902), um array de operações ordenadas (add, remove, replace, move, copy, test) que transforma um documento em outro. Os caminhos usam JSON Pointer (RFC 6901). Relacionado: JSON Merge Patch (RFC 7396) — mais simples, mas não consegue distinguir 'remover chave' de 'definir chave como null'. Esta ferramenta produz RFC 6902.

Igualdade profunda de JSON em JavaScript é mais difícil do que parece. JSON.stringify(a) === JSON.stringify(b) falha com reordenação de chaves, e engana com -0 vs 0 (ambos se serializam como "0"). Um diff correto deve percorrer ambas as árvores em paralelo usando a união de conjuntos de chaves, distinguir null de ausente via o operador 'in', e decidir o que 'igual' significa para números (Object.is por padrão, epsilon para tolerância).

Esta ferramenta roda inteiramente no seu navegador. As entradas nunca saem da sua máquina. Seguro para respostas de API, schemas internos e configurações proprietárias.

Trabalhando com ferramentas JSON adjacentes? Formate com o Formatador JSON; converta com JSON para YAML e YAML para 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 }]

Funcionalidades Principais

Lado a Lado + JSON Patch

Duas visualizações a partir de um diff: destaque visual para revisão, patch RFC 6902 para automação.

Ignorar Campos Ruidosos

Presets com um clique removem /createdAt, /updatedAt, /*Id, /*At, requestId, traceId. Padrões personalizados de Extended JSON Pointer são suportados.

Combinar Arrays por Chave

Compare arrays de objetos por um campo id em vez de por índice — para envs do K8s, entradas de package-lock ou qualquer lista logicamente desordenada.

Estrito com Tipos por Padrão

1 ≠ "1". null ≠ ausente. Detecte desvios de serialização de backend no momento em que aparecem em um fixture de teste.

100% Baseado no Navegador

As entradas nunca saem da sua máquina. Sem upload, sem localStorage de JSON, sem análise do que você cola.

Compartilhe o Link, Não os Dados

Share Link escreve apenas sua configuração na URL. Suas entradas JSON permanecem locais.

Exemplos

Regressão de Resposta de API

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

Duas alterações (name + createdAt). Adicione /user/createdAt em Ignorar caminhos e apenas a mudança de nome permanece.

Auditoria de Arquivo de Config (Reordenação de Chaves)

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

Mesmos dados, ordem de chaves diferente. O JSON Diff trata a ordem das chaves como semanticamente irrelevante — o diff é vazio.

Array de Objetos (Combinar por Chave)

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

Mude o modo de Array para 'Combinar por chave' com key=id. Sem alinhamento, cada elemento parece alterado; com alinhamento, apenas qty no id=1 muda.

Saída JSON Patch (RFC 6902)

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

Mude para a aba JSON Patch para obter [{"op":"replace","path":"/items/0/price","value":24.99}] que você pode aplicar com fast-json-patch.

Como Usar

  1. 1

    Cole os dois documentos JSON

    Cole o JSON original (esquerda) e o modificado (direita). O diff ao vivo é renderizado enquanto você digita; entradas grandes (>200 KB) mudam para um botão Diff manual.

  2. 2

    Filtre o ruído

    Clique em um preset (Timestamps / IDs / Trace) ou cole padrões de Extended JSON Pointer em Ignorar caminhos para eliminar campos irrelevantes.

  3. 3

    Escolha a visualização que você precisa

    Lado a Lado para revisão humana, JSON Patch (RFC 6902) para operações aplicáveis por máquina. Use Share Link para enviar a configuração a um colega.

Armadilhas Comuns do Diff

Ruído de Ordem de Chaves (Sintoma de Diff de Texto)

Se sua ferramenta de diff reporta {"a":1,"b":2} vs {"b":2,"a":1} como diferentes, ela está fazendo diff de linha, não diff de JSON. Chaves JSON são desordenadas — esta ferramenta ignora a ordem de chaves automaticamente.

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

Confusão entre Null e Ausente

{"a":null} e {} não são iguais. Tratá-los como iguais mascara bugs reais de backend.

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

Ordem de Array Sem Alinhamento por Chave

[{id:1},{id:2}] vs [{id:2},{id:1}] não é '2 alterações' para um conjunto lógico. O Sequencial reporta assim; mude para Combinar por chave.

✗ Incorreto
Sequential diff: 4 modified
✓ Correto
Match by key (id): 0 differences

Desvio de Tipo (Número vs String)

Backends às vezes serializam IDs inconsistentemente — 42 vs "42". A ferramenta sinaliza esses como modificações de 'tipo' para que você detecte o desvio cedo.

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

Precisão de Ponto Flutuante

0.1 + 0.2 !== 0.3 em IEEE 754. Com tolerance=0 (padrão), isso é sinalizado. Defina tolerance como 1e-9 se você pretende equivalência numérica.

✗ Incorreto
tolerance=0:  0.30000000000000004 ≠ 0.3
✓ Correto
tolerance=1e-9: equal

Ruído de Timestamp e UUID

createdAt, updatedAt, requestId, traceId mudam em cada requisição. Use os presets de Ignorar caminhos para descartá-los.

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

Casos de Uso Comuns

Regressão de Resposta de API
Compare respostas de staging vs produção; ignore timestamps e IDs de requisição para exibir apenas alterações significativas no payload.
Falhas em Testes de Snapshot de CI
Cole o real vs esperado de um snapshot falhando no Jest/Vitest. Filtre o ruído e encontre a mudança real em segundos.
Conflitos de package-lock / yarn.lock
Resolva conflitos de merge alinhando dependências por nome; ordem de chaves e campos não relacionados deixam de ser ruído.
Auditoria de Valores K8s / Helm
Combine envs, volumeMounts e ports por nome. Detecte ordenações não intencionais vs edições reais de configuração.
Cobertura de Tradução i18n
Faça diff estrutural de en.json contra zh.json para encontrar chaves de tradução faltando ou extras sem ruído de valores.
Revisão de Plano Terraform / CDK
Compare a saída do plano entre execuções; a tolerância numérica lida com aritmética de ponto flutuante, ignore caminhos descartam ARNs e timestamps.

Detalhes Técnicos

Saída de Patch Compatível com RFC 6902
Gera operações JSON Patch válidas (add/remove/replace) com caminhos RFC 6901. Verificado contra fast-json-patch@3.x e os pacotes npm rfc6902.
Travessia Iterativa
Travessia com pilha explícita (sem recursão) limitada a 100.000 nós e profundidade 64 para evitar estouro de pilha em entradas adversariais.
Igualdade Numérica com Object.is
A tolerância numérica padrão é 0 — usa Object.is para que -0 e +0 sejam distinguidos. Defina tolerância > 0 para igualdade baseada em epsilon.

Boas Práticas

Filtre Antes de Revisar
Adicione Ignorar caminhos primeiro (timestamps, IDs, campos de trace), depois leia o diff. Revisar diffs ruidosos treina o olho a pular — e perder — mudanças reais.
Combinar por Chave para Conjuntos Lógicos
Se seu array representa um conjunto desordenado (envs, usuários, dependências), use Combinar por chave. Diff sequencial em conjuntos lógicos quase sempre está errado.
Compartilhe o Link, Não as Entradas
Use Share Link para enviar a um colega sua configuração de filtro — nunca cole JSON sensível em documentos compartilhados. A URL contém apenas a configuração.

Perguntas Frequentes

Por que meu diff mostra tudo alterado quando só mudei um campo?
Três suspeitos habituais: (1) ordem de chaves diferente — o JSON Diff trata a ordem como equivalente, mas ferramentas de diff de texto não tratam; (2) timestamps/UUIDs/auto-IDs que mudam a cada requisição — adicione-os em Ignorar caminhos; (3) ordem de arrays, quando a comparação por índice não deveria ser aplicada — mude o modo de Array para 'Combinar por chave'.
Como ignoro timestamps e IDs no JSON diff?
Use o campo Ignorar caminhos acima. Clique no preset 'Timestamps' ou 'IDs' para filtrar /createdAt, /updatedAt, /*Id, /*At, /requestId com um clique. Você também pode colar seus próprios padrões de Extended JSON Pointer — um por linha — para filtragem avançada.
Qual é a diferença entre JSON Patch e um diff visual?
O diff visual (lado a lado) é para humanos — revise as alterações visualmente. O JSON Patch (RFC 6902) é para máquinas — um array de operações estruturadas (add/remove/replace) que você pode aplicar com os pacotes npm fast-json-patch ou rfc6902. Mesmo diff, duas saídas.
O JSON diff trata null e chaves ausentes da mesma forma?
Não. {"a":null} e {} são diferentes — o primeiro tem um null explícito, o segundo não tem a chave. Sistemas reais se comportam de forma diferente para os dois; esta ferramenta os mantém distintos.
Como os arrays são comparados — por índice ou por chave?
Por índice (Sequencial) por padrão. Mude para 'Combinar por chave' e forneça um campo de chave (geralmente id) para alinhar elementos independentemente da ordem. Use isso para envs do K8s, entradas de package-lock, ou qualquer lista que seja logicamente um conjunto.
Posso exportar o diff como JSON Patch (RFC 6902)?
Sim. A aba JSON Patch produz um array de operações RFC 6902 válido. Se Ignorar caminhos estiver definido, o patch será filtrado (a aba mostra '(filtrado: exclui N caminhos ignorados)') e não reconstituirá os originais exatamente. Limpe Ignorar caminhos para um patch completo.
O JSON Patch é igual ao JSON Merge Patch (RFC 7396)?
Não. O RFC 6902 (JSON Patch) é um array de operações ordenadas — explícito e reversível. O RFC 7396 (Merge Patch) é um único documento de mesclagem — mais simples, mas não consegue representar remoção de forma diferente de definir como null. O JSON Diff produz RFC 6902.
Como comparo dois arquivos JSON grandes (>10 MB)?
Arquivos acima de ~5 MB excedem a memória prática do navegador. O modo ao vivo é desativado em 200 KB; para arquivos de vários megabytes, use jq na linha de comando ou fast-json-patch no Node.
A ferramenta envia meu JSON para um servidor?
Não. Todo o processamento roda localmente no seu navegador. As entradas nunca são gravadas em disco, rede, localStorage ou parâmetros de URL. Atualizar a página as apaga. O botão Share Link escreve apenas sua configuração (modo de Array, Ignorar caminhos) — nunca seus dados.
Por que 42 é diferente de "42" no diff?
O JSON Diff é estrito com tipos: o número 42 e a string "42" não são iguais. Isso detecta desvios de serialização de backend (alguns endpoints retornam IDs numéricos, outros retornam strings) — o diff rotula isso como modificação de 'tipo'.
Posso fazer diff de JSON com comentários (JSONC) ou vírgulas no final?
O JSON padrão (RFC 8259) não permite comentários ou vírgulas no final. Esta ferramenta usa o JSON.parse nativo, que rejeita ambos. Remova os comentários primeiro usando o Formatador JSON.
Como comparo arrays aninhados de objetos por uma chave como id?
Defina o modo de Array como 'Combinar por chave' e insira id. O diff alinha pelos valores de id. A v1 aplica o mesmo campo de chave em todas as profundidades de array; arrays internos sem esse campo voltam ao sequencial e emitem um chip de aviso.
O diff lida com precisão de ponto flutuante (0.1 + 0.2)?
Sim, com Tolerância Numérica. O padrão é 0 com Object.is — então -0 vs +0 são sinalizados. Defina a tolerância para um epsilon pequeno (ex: 1e-9) e 0.1 + 0.2 será considerado igual a 0.3. A tolerância se aplica apenas a folhas numéricas.

Ferramentas relacionadas

Ver todas as ferramentas →

Decodificador e Codificador Base64

Codificação e Formatação

Decodifique e codifique Base64 online gratuitamente. Conversão em tempo real com suporte completo a UTF-8 e emoji. 100% privado — executa no seu navegador. Sem necessidade de cadastro.

Formatador e Validador JSON

Codificação e Formatação

Formate, valide e embeleze JSON instantaneamente no seu navegador. Ferramenta online gratuita com validação de sintaxe, detecção de erros, minificação e cópia com um clique. 100% privado — seus dados nunca saem do seu dispositivo.

Conversor JSON para YAML

Codificação e Formatação

Cole JSON e obtenha YAML instantaneamente. Conversão ao vivo no navegador. K8s/Compose, indentação 2/4 espaços, Norway-safe. 100% privado, sem upload.

Codificador e Decodificador de URL com Analisador Integrado

Codificação e Formatação

Cole uma URL para decodificar ou codificar em tempo real. Analisador de URL integrado decompõe cada componente em campos editáveis. Modo duplo: encodeURI e encodeURIComponent. Privado — nenhum dado enviado a servidor.

Conversor YAML para JSON

Codificação e Formatação

Cole YAML e obtenha JSON instantaneamente. Conversão ao vivo no navegador. Suporte a manifestos K8s, OpenAPI e valores Helm. 100% privado, sem upload.

Conversor de Base Numérica — Binário, Hex, Decimal e Octal

Ferramentas de Conversão

Converta números entre binário, hexadecimal, decimal, octal e qualquer base personalizada (2-36) instantaneamente. Gratuito, privado, sem cadastro — todo o processamento acontece no seu navegador.