Reparar JSON

Ferramenta online gratuita para reparar JSON. Detecta e corrige automaticamente vírgulas finais, aspas simples, chaves sem aspas, colchetes não fechados, comentários e wrappers Markdown. Projetada para limpeza de saída IA e recuperação de JSON truncado. Inteiramente local no navegador.

Sugestões Relacionadas

O que é Reparar JSON (JSON Repair)?

Reparar JSON (JSON Repair) é o processo de pegar um texto JSON não padrão que um parser JSON estrito não pode consumir devido a erros de sintaxe, e restaurá-lo automaticamente para uma string JSON válida em conformidade com RFC 8259. Ao contrário do Formatador JSON (Beautify), Reparar JSON não trata diferenças de formato, mas erros estruturais: vírgulas finais, aspas simples, aspas ausentes, colchetes não fechados, wrappers Markdown, comentários - todos fazem com que JSON.parse() lance SyntaxError, embora sejam extremamente comuns no desenvolvimento real.

As fontes de JSON 'não padrão' em projetos de engenharia reais são altamente concentradas: ① Ao copiar de LLMs como ChatGPT / Claude / Gemini, a saída geralmente vem envolta em blocos de código Markdown (```json ... ```) ou acompanhada de texto explicativo; ② Copiar de console.log() de um objeto JavaScript pode incluir vírgulas finais e aspas simples; ③ Arquivos de configuração frequentemente usam a sintaxe estendida JSON5 / JSONC (que permite comentários, chaves sem aspas, strings multi-linha, etc.); ④ Respostas em streaming ou logs truncados podem quebrar o JSON no meio do fluxo, faltando o `}` ou `"` de fechamento. Uma ferramenta Reparar JSON escaneia o texto, identifica esses problemas típicos e restaura o conteúdo para JSON padrão com o princípio de 'mínima intrusão' preservando ao máximo a semântica dos dados originais.

No nível de implementação, Reparar JSON tipicamente consiste em duas fases: ① Análise tolerante (tolerant parse) - uso de um scanner baseado em máquina de estados em vez de expressões regulares para processar o fluxo de caracteres passo a passo, distinguindo caracteres de sintaxe 'dentro de strings' de 'fora'; ② Saída canônica (canonical output) - regeneração do resultado com `JSON.parse` + `JSON.stringify`, garantindo que a saída seja 100% válida para qualquer parser estrito a jusante. A ferramenta Reparar JSON da GeekFormat completa todo o fluxo de reparo localmente no navegador, sem enviar o conteúdo original a nenhum servidor, adequada para processar respostas de API sensíveis, arquivos de configuração internos e saídas de modelos de IA.

Casos de uso

  • Limpeza de saída IA/LLM: converta com um clique o JSON de ChatGPT/Claude envolto em Markdown, com texto explicativo e vírgulas finais para JSON padrão
  • Depuração e solução de problemas de interface: quando respostas API são truncadas por problemas de gateway ou rede, complete rapidamente colchetes e strings para localizar a estrutura de dados original
  • Literais de objeto JavaScript copiados do console: solução única para aspas simples, vírgulas finais e chaves sem aspas
  • Limpeza de arquivo de configuração: remova comentários de JSON5/JSONC para obter JSON padrão, pronto para consumo unificado a jusante
  • Reparo de dados de log e área de transferência: padronize rapidamente trechos JSON contendo comentários, espaços especiais ou truncamento
  • Migração de dados e pré-processamento de script: adicione uma etapa de reparo no pipeline de migração de dados para evitar que poucos JSONs inválidos bloqueiem um lote ETL inteiro

Como Usar

  1. Cole o conteúdo JSON com erros, envolto em Markdown ou truncado na caixa de entrada esquerda, ou clique em 'Exemplo' para carregar um JSON quebrado típico, ou faça upload de um arquivo .json/.txt
  2. A ferramenta detecta e repara automaticamente problemas comuns de sintaxe; a área de saída direita mostra o JSON padrão formatado e a contagem de cada classe de problema reparado
  3. Se ainda houver mensagens de erro vermelhas, você pode editar manualmente a entrada e reativar o reparo (Mac: ⌘+Shift+R, Windows: Ctrl+Shift+R)
  4. Após confirmar que a estrutura está correta, clique em 'Copiar' para colocar o resultado reparado na área de transferência, ou clique em 'Baixar' para salvar como repaired.json para mais formatação, validação, etc.

Recursos

  • Cobre 7 erros comuns de sintaxe: vírgulas finais, aspas simples, chaves sem aspas, strings não fechadas, comentários, colchetes ausentes, wrappers de bloco de código Markdown
  • Otimizado para limpeza de saída IA: remove automaticamente wrappers ```json e texto explicativo circundante; reconhece saídas típicas de ChatGPT, Claude, Gemini e outros LLMs
  • Compatível com JSON5/JSONC: analisa sintaxe estendida incluindo comentários, aspas flexíveis e espaços especiais (ex. caracteres Unicode invisíveis)
  • Completamento inteligente de JSON truncado: lida com respostas API truncadas e chaves de fechamento ausentes, completando automaticamente colchetes e aspas ausentes
  • Visualização de problemas reparados: auto-estatísticas e mostra a contagem de cada classe de problema reparado para fácil auditoria e revisão humana
  • Processamento local para privacidade: análise, reparo e formatação acontecem localmente no navegador, nenhuma entrada enviada a um servidor
  • Transição suave para formatação: o JSON padrão reparado pode ir diretamente para o Formatador JSON, Validador Schema ou gerador de código como próximos passos
  • Carregamento de arquivos e exemplos: suporta upload de arquivos .json/.txt ou clique para carregar um exemplo para verificação rápida do efeito do reparo

Exemplos de Código

Reparo programático com a biblioteca jsonrepair JavaScript

javascript
// npm install jsonrepair
import { jsonrepair } from 'jsonrepair';

const broken = `{
  name: 'Alice',
  age: 30,
  tags: ['dev', 'writer',], // vírgula final + comentário
}`;

try {
  const fixed = jsonrepair(broken);
  const obj = JSON.parse(fixed);
  console.log(obj);
  // => { name: 'Alice', age: 30, tags: ['dev', 'writer'] }
} catch (err) {
  console.error('Ainda não reparável:', err.message);
}

Reparo programático com a biblioteca jsonrepair Python

python
# pip install jsonrepair
from jsonrepair import jsonrepair
import json

broken = '''{
  name: "Alice",
  age: 30,
  tags: ["dev", "writer",], // vírgula final + comentário
}'''

fixed = jsonrepair(broken)
obj = json.loads(fixed)
print(obj)
# => {'name': 'Alice', 'age': 30, 'tags': ['dev', 'writer']}

Correção rápida de vírgula final com jq + sed (somente emergência)

bash
# Remove vírgulas finais de objetos/arrays (opção de emergência; NÃO lida com comentários / aspas simples)
# Para cenários complexos, use uma biblioteca dedicada como jsonrepair
sed -E 's/,([ \t]*[}\]])/\1/g' broken.json > clean.json

# Valida a saída limpa
jq . clean.json >/dev/null && echo 'JSON é válido'

Perguntas frequentes

Qual é a diferença entre Reparar JSON e Formatar JSON?

O Formatador JSON apenas reformata JSON que já é legal mas tem indentação ou espaçamento inconsistente. Reparar JSON, por outro lado, trata especificamente JSON com erros de sintaxe: primeiro corrige problemas estruturais como vírgulas finais, aspas simples, comentários, colchetes ausentes, depois emite o formato padrão. Quando uma ferramenta de formatação lança SyntaxError, você deve começar com Reparar JSON.

Quais erros comuns de sintaxe JSON a ferramenta pode reparar?

A ferramenta inclui algoritmos de reparo inteligentes para os seguintes problemas frequentes: 1) Vírgulas finais; 2) Aspas simples em vez de duplas; 3) Chaves sem aspas; 4) Strings não fechadas; 5) Comentários JavaScript de linha/bloco; 6) JSON envolto em blocos de código Markdown; 7) Chaves/colchetes de fechamento ausentes por truncamento.

Por que a saída JSON de IA ou LLMs é frequentemente não padrão?

Grandes modelos de linguagem (ex. ChatGPT, Claude, Gemini) frequentemente produzem JSON envolto em Markdown (```json ... ```), com texto explicativo em prefixo/sufixo, vírgulas finais, comentários ou com estrutura incompleta por truncamento de tokens. Reparar JSON é especificamente otimizado para esses cenários para limpar com um clique a saída de IA para JSON válido.

O JSON reparado é sempre estruturalmente idêntico aos dados originais?

A saída reparada é uma string JSON válida em conformidade com o padrão JSON; a semântica dos dados é preservada na grande maioria dos casos. No entanto, como o reparo é baseado em regras heurísticas, em cenários extremamente quebrados ou ambíguos (ex. várias vírgulas ausentes na mesma linha) pode divergir ligeiramente da intenção original. Recomendamos executar Validação Schema ou revisão humana para dados críticos.

Por que não usar diretamente Python json.loads ou JavaScript JSON.parse?

Parsers nativos só podem lançar erros em SyntaxError, não reparar. Reparar JSON é uma camada tolerante que se coloca antes dos parsers nativos: primeiro tenta consertar o texto, depois passa para o parser nativo, garantindo que a saída final seja consumível por qualquer parser JSON estrito. A mesma ideia pode ser aplicada como pré-processamento em ambientes de produção no lado do servidor.

Os comentários em JSON5 / JSONC são preservados?

Não. Comentários são parte da sintaxe estendida JSON5, não do JSON padrão. A ferramenta os remove para garantir que a saída esteja em conformidade com o JSON padrão. Se você deseja manter os comentários, continue usando arquivos fonte JSON5 ou a cadeia de ferramentas JSONC. Se você precisa converter JSON5 para JSON padrão, esta ferramenta faz isso diretamente.

JSON truncado (ex. saída streaming cortada) pode ser reparado?

Sim. A ferramenta tenta corresponder parênteses direitos ausentes, colchetes e aspas de fechamento de string, preservando o máximo de conteúdo identificado possível. Nota: se o ponto de truncamento cair dentro de um literal de string, você pode precisar fornecer manualmente os caracteres chave ausentes.

Há perda de dados após o reparo?

Em cenários comuns de reparo (remover vírgulas finais, adicionar aspas, completar colchetes, remover comentários) a semântica dos dados é totalmente preservada. Em casos raros, quando o conteúdo original tem ambiguidade irreversível (ex. nível de aninhamento destruído), a ferramenta reparará o mais conservadoramente possível e emitirá o original como está; ela não excluirá ativamente campos ou chaves.

Posso reparar vários JSONs em lote?

Esta ferramenta repara uma entrada por vez. Para cenários em lote, recomendamos executar o algoritmo subjacente localmente em um script (ex. a biblioteca jsonrepair do Python ou o pacote npm josdejong/jsonrepair), depois importar o resultado para esta ferramenta para verificação humana e formatação.

Ainda preciso fazer formatação e Validação Schema após o reparo?

Recomendado. O reparo aborda principalmente erros no nível de sintaxe; a formatação e a Validação Schema garantem legibilidade e correção de negócio. A saída da ferramenta de reparo se conecta perfeitamente com o Formatador JSON, Validador Schema e geradores de código da GeekFormat.

A ferramenta carrega meu JSON em um servidor?

Não. Toda a análise, reparo e formatação acontecem localmente no navegador; nem a entrada nem os resultados intermediários são enviados a nenhum servidor. Funciona offline, adequado para processar JSON sensíveis (ex. respostas API de ambientes de produção, configurações internas).

Posso fixar a estratégia de reparo usada cada vez?

Esta ferramenta ativa todas as regras comuns de reparo por padrão para maximizar a taxa de sucesso. Se você precisa de controle fino sobre regras para uma linguagem ou equipe específica, pode usar a biblioteca jsonrepair em seu ambiente de produção e ativar ou desativar seletivamente regras específicas. A saída desta ferramenta também pode servir como entrada padronizada para validação a jusante.

Solução de Problemas

Erro 'Não é possível reparar este JSON'

Causa: o texto de entrada tem danos estruturais graves, como vários colchetes ausentes, literais de string truncados ou conjunto de caracteres corrompido. Solução: abra o arquivo original em um editor de texto simples primeiro, confirme que a codificação é UTF-8 sem BOM e que não é um binário comprimido; se os dados vieram de uma resposta API, contate o upstream para completá-los; para conjuntos de dados extremamente quebrados, use o arquivo fonte diretamente.

Campos movidos para a posição errada após o reparo

Causa: o texto original continha caracteres de sintaxe JSON (ex. //, /*, }) dentro de comentários ou literais de string, confundindo o parser; ou o nível de aninhamento é tão profundo que o emparelhamento de colchetes está desalinhado. Solução: escape manualmente // e /* dentro de strings; para dados profundamente aninhados, adicione colchetes externos temporários ou quebras de linha antes de re-executar o reparo.

Texto explicativo na saída IA não é removido

Causa: a saída IA geralmente começa/termina com linguagem natural (ex. 'Aqui está o resultado:') e pode abranger várias linhas. Solução: use um editor de texto para excluir o texto fora do bloco JSON, mantendo apenas o conteúdo dentro do wrapper ```json mais externo; se a ferramenta ainda não conseguir reconhecê-lo, adicione manualmente as { } mais externas antes de re-executar o reparo.

Tamanho não mudou após o reparo, ou alguns caracteres foram substituídos

Causa: o original continha barras invertidas, escapes Unicode ou entidades HTML, que a ferramenta re-escapou de acordo com as regras JSON. Solução: verifique se o original estava aninhado dentro de uma string JS; se estiver em uma página HTML, decodifique HTML primeiro; mais caracteres após o escape é normal.

O navegador mostra 'Memória insuficiente' ou congela

Causa: uma única entrada acima de 5–10 MB exerce uma pressão significativa na memória do navegador. Solução: divida os dados em lotes menores (1–2 MB cada); ou use a biblioteca jsonrepair no lado do servidor para streaming; uma pequena diferença entre o resultado reparado e o original é normal.

A validação Schema ainda relata erros após o reparo

Causa: Reparar JSON só corrige erros no nível de sintaxe; não impõe nomes, tipos ou valores de campos de negócio em relação ao Schema. Solução: use a ferramenta de Validação JSON Schema da GeekFormat para verificar restrições de campos; localize campos específicos pelo erro e corrija-os manualmente.

Glossário

JSON
JavaScript Object Notation, formato leve de troca de dados baseado em pares chave-valor definido em RFC 8259. Padrão de fato para APIs REST, arquivos de configuração e logs.
RFC 8259
A especificação JSON oficial do IETF, definindo a sintaxe estrita do JSON válido - todas as chaves devem estar entre aspas duplas, apenas um conjunto limitado de caracteres em strings precisam de escape, comentários e vírgulas finais não são permitidos.
JSON.parse
O parser JSON estrito embutido no JavaScript e em navegadores modernos, em conformidade com RFC 8259. Lança SyntaxError em qualquer erro de sintaxe e não pode realizar reparo tolerante.
JSON5
Uma sintaxe estendida para JSON (não padrão), que permite chaves sem aspas, strings com aspas simples, comentários (// e /* */), vírgulas finais, números hexadecimais, etc. Mais fácil de escrever à mão, mas incompatível com JSON.parse.
JSONC
JSON with Comments, nome genérico usado por editores como VS Code para arquivos de configuração JSON com comentários (ex. tsconfig.json). Efetivamente um alias para JSON5.
Vírgula final
Uma vírgula extra após o último elemento de um objeto ou array. Permitida em JavaScript, mas proibida pelo padrão JSON - o erro de sintaxe mais comum de saídas LLM e cópias de console.log().
Bloco de código Markdown
Um trecho de código envolto em três crases (```). LLMs frequentemente envolvem automaticamente a saída JSON em ```json ... ```; colar diretamente em JSON.parse() falhará.
Parser Tolerante
Um parser que tenta se recuperar e continuar a análise ao encontrar erros de sintaxe. O motor principal de uma ferramenta Reparar JSON, distinto do JSON.parse estrito.
SyntaxError
A exceção de erro de sintaxe lançada pelo JavaScript. Qualquer parser JSON estrito lança isso ao receber entrada que não está em conformidade com RFC 8259.
JSON Canônico
JSON regenerado via parse + stringify, com ordem das chaves estável, sem espaços extras e 100% compatível com parsers padrão. O formato de saída final de uma ferramenta Reparar JSON.

Tipos Comuns de Erros em Reparo de JSON com Exemplos

CategoriaAntesDepoisMétodo de reparo
Vírgula final{ "a": 1, }{ "a": 1 }Remover a vírgula após o último elemento
Aspas simples{ 'a': 1 }{ "a": 1 }Substituir todas as aspas simples por duplas
Chaves sem aspas{ a: 1 }{ "a": 1 }Adicionar aspas duplas em torno da chave
Comentários de linha{ // comentário "a": 1 }{ "a": 1 }Remover comentários //
Comentários de bloco{ /* bloco */ "a": 1 }{ "a": 1 }Remover comentários /* */
Wrapper Markdown```json { "a": 1 } ```{ "a": 1 }Remover wrappers ```json e ```
String não fechada{ "a": "olá }{ "a": "olá" }Adicionar aspas de fechamento ausentes
Colchete ausente{ "a": 1{ "a": 1 }Stack-match para adicionar chave/colchete de fechamento

Reparar JSON vs Formatar JSON vs Validação JSON Schema

FerramentaO que resolveRequisito de entradaModo de falha
Reparar JSONConverter JSON com erro para JSON válidoTolerante, aceita JSON não padrãoErro se muito quebrado para adivinhar a estrutura
Formatar JSONReformatar JSON válidoDeve ser já JSON válidoSyntaxError lançado diretamente
Comprimir JSONRemover espaços, reduzir tamanhoDeve ser já JSON válidoSyntaxError lançado diretamente
Validação JSON SchemaVerificar tipos/valores de campos vs regras de negócioDeve ser já JSON válidoLista cada campo que viola as regras
JSON Merge / SortFusão multi-fonte / ordenação de chavesDeve ser já JSON válidoSyntaxError lançado diretamente

Authoritative References