Ferramenta de Reparação JSON

Corrija e recupere automaticamente JSON quebrado ou malformado — com segurança, rapidez e gratuitamente.

Esta ferramenta repara JSON corrompido ou inválido utilizando correção automática de erros. Ela corrige os problemas de sintaxe mais comuns encontrados em dados exportados, logs ou arquivos editados manualmente — como aspas faltando, vírgulas extras ou colchetes incompatíveis — e gera um JSON válido e legível como resultado.

Conserte seu JSON abaixo

Como Funciona o Reparador de JSON

A ferramenta analisa sua entrada em busca dos problemas típicos de sintaxe JSON e aplica correções específicas, gerando um JSON válido quando possível.

  1. Analisa a entrada e identifica erros comuns de sintaxe, incluindo caracteres ilegais, colchetes fora de lugar e aspas incorretas em strings.
  2. Aplica correções para erros comuns — como adicionar aspas faltantes, remover vírgulas finais ou corrigir colchetes.
  3. Gera o JSON corrigido. Na maioria dos casos, o resultado está pronto para ser analisado ou utilizado imediatamente.
  4. Se a estrutura não puder ser reparada automaticamente, um erro claro será exibido para que você possa ajustar sua entrada.

Erros Comuns em JSON e Como Corrigi-los

Aqui estão erros comuns em JSON que esta ferramenta pode corrigir, com exemplos para cada um:

Chaves Sem Aspas

As chaves devem estar entre aspas duplas.

Before:
{ nome: "Bob" }
After:
{ "name": "Bob" }

Correção: Adiciona aspas duplas em torno de quaisquer chaves de objeto não entre aspas.

Aspas Simples Utilizadas

JSON aceita apenas aspas duplas para strings.

Before:
{ 'role': 'administrador' }
After:
{ "role": "admin" }

Correção: Substitui aspas simples por aspas duplas em todas as strings.

Vírgulas Finais

Não é permitido vírgula após o último item.

Before:
{ "a": 1, "b": 2, }
After:
{ "a": 1, "b": 2 }

Correção: Remove quaisquer vírgulas finais.

Colchetes não correspondentes ou não fechados

Todos os colchetes e chaves devem ser fechados corretamente.

Before:
[1, 2, 3
After:
[1, 2, 3]

Correção: Adiciona colchetes ou chaves de fechamento ausentes.

Vírgulas Ausentes ou Excedentes

Itens de array e objeto devem ser separados por uma vírgula simples.

Before:
{ "a": 1 "b": 2 }
After:
{ "a": 1, "b": 2 }

Correção: Insere vírgulas faltantes ou remove duplicatas.

Linhas de Comentário Presentes

O JSON padrão não permite comentários (como // ou /* ... */).

Before:
{ "id": 1, // ID do usuário
 "ativo": true }
After:
{ "id": 1, "active": true }

Correção: Remove linhas de comentário do conteúdo de entrada.

Formatos de Números Inválidos

Apenas números decimais simples são válidos (sem NaN, Infinito ou hexadecimal).

Before:
{ "val": NaN }
After:
{ "val": null }

Correção: Substitui números inválidos por nulo.

Caracteres de Controle Não Escape

Caracteres como quebras de linha em strings devem ser escapados.

Before:
{ "msg": "Linha1
Linha2" }
After:
{ "msg": "Linha1\nLinha2" }

Correção: Escapa corretamente caracteres de controle.

Chaves Duplicadas no Objeto

Chaves duplicadas no mesmo objeto causam ambiguidade.

Before:
{ "name": "A", "name": "B" }
After:
{ "name": "B" }

Correção: Mantém apenas o último valor para qualquer chave duplicada.

Arrays Malformados

Arrays devem ter colchetes e vírgulas entre os itens.

Before:
[ 1 2 3 ]
After:
[ 1, 2, 3 ]

Correção: Adiciona vírgulas ausentes entre os elementos do array.

Entrada Vazia ou Apenas Espaços

JSON não pode estar vazio.

Before:
After:
nulo
Correção: Retorna nulo para entrada vazia.
Exemplo: De JSON Corrompido a um Reparo Válido
Entrada JSON malformada
{ usuário: 'alice', id: 42, funções: [admin, 'editor',] // vírgula extra
 ativo: true }
Saída JSON Corrigida
{
  "user": "alice",
  "id": 42,
  "roles": [
    "administrador",
    "editor"
  ],
  "active": true
}
Como Usar Esta Ferramenta de Reparo de JSON
  1. Cole ou digite seu JSON com erro no editor abaixo.
  2. Clique em 'Reparar' para detectar e corrigir automaticamente erros comuns de sintaxe.
  3. Revise a saída corrigida e copie seu JSON corrigido.
Sempre verifique o JSON reparado antes de usá-lo para dados críticos — ajustes manuais podem ser necessários para entradas complexas ou muito danificadas.
Exemplos de Código para Reparação de JSON
Veja como corrigir JSON em várias linguagens de programação.
JavaScript (Node.js) with jsonrepair
Install: npm install jsonrepair
const { jsonrepair } = require('jsonrepair');
const broken = '{ name: "Bob", age: 42, }';
const fixed = jsonrepair(broken);
console.log(fixed); // Now valid JSON!
JavaScript (Node.js) simple fix (not for production)
Install: Standard library
let broken = "{ name: 'Bob', age: 42 }";
broken = broken.replace(/(['"])?:([\s]*)([^\s,\{\}\[\]":']+)/g, '"$1$3":');
try {
  let obj = JSON.parse(broken);
  console.log(obj);
} catch (e) {
  console.error('Still broken:', e.message);
}
Python with dirtyjson
Install: pip install dirtyjson
import dirtyjson
broken = "{ name: 'Bob', age: 42 }"
obj = dirtyjson.loads(broken)
print(obj)
Python with demjson3
Install: pip install demjson3
import demjson3
broken = "{ name: 'Bob', age: 42 }"
obj = demjson3.decode(broken)
print(obj)
Go (using otto for JS-like object parsing)
Install: go get github.com/robertkrimen/otto
package main
import (
  "fmt"
  "github.com/robertkrimen/otto"
)
func main() {
  vm := otto.New()
  broken := "{ name: 'Bob', age: 42 }"
  value, err := vm.Run("(" + broken + ")")
  if err != nil {
    fmt.Println("Cannot repair:", err)
  } else {
    obj, _ := value.Export()
    fmt.Println(obj)
  }
}
Java with org.json (manual fix for single quotes)
Install: org.json:json
import org.json.JSONObject;
public class Main {
  public static void main(String[] args) {
    String broken = "{'name': 'Bob', 'age': 42}".replace(''', '"');
    JSONObject obj = new JSONObject(broken);
    System.out.println(obj);
  }
}
C# with Newtonsoft.Json (try-catch, manual fix)
Install: Newtonsoft.Json
using System;
using Newtonsoft.Json;
class Program {
  static void Main() {
    var broken = "{ name: 'Bob', age: 42 }".Replace("'", "\"");
    try {
      var obj = JsonConvert.DeserializeObject(broken);
      Console.WriteLine(obj);
    } catch (Exception ex) {
      Console.WriteLine("Broken JSON: " + ex.Message);
    }
  }
}
PHP (manual fix for single quotes/unquoted keys)
Install: Standard library
<?php
$broken = "{ name: 'Bob', age: 42 }";
$fixed = preg_replace("/'([^"]*)'/", '"$1"', $broken);
$fixed = preg_replace('/([a-zA-Z0-9_]+):/', '"$1":', $fixed);
$obj = json_decode($fixed);
var_dump($obj);
Ruby with json-repair (via gem or shell call)
Install: gem install json-repair or use npx jsonrepair
# Using system call to npx jsonrepair
require 'open3'
broken = "{ name: 'Bob', age: 42 }"
fixed, _ = Open3.capture2("echo #{broken.inspect} | npx jsonrepair")
puts fixed
Bash (npx jsonrepair CLI)
Install: npm install -g jsonrepair
echo "{ name: 'Bob', age: 42 }" | npx jsonrepair
Rust (suggest manual pre-processing)
Install: Standard libraries
// Rust does not have a json repair crate yet. Pre-process string with regex to fix simple cases, then use serde_json.
Kotlin (manual fix, like Java)
Install: org.json:json
import org.json.JSONObject
fun main() {
  var broken = "{ name: 'Bob', age: 42 }".replace("'", "\"")
  broken = Regex("([a-zA-Z0-9_]+):").replace(broken, ""$1":")
  val obj = JSONObject(broken)
  println(obj)
}
TypeScript (Node.js) with jsonrepair
Install: npm install jsonrepair
import { jsonrepair } from 'jsonrepair';
const broken = '{ name: "Bob", age: 42 }';
const fixed = jsonrepair(broken);
console.log(fixed);
Dart (manual string fixes)
Install: Standard library
var broken = "{ name: 'Bob', age: 42 }";
var fixed = broken.replaceAll("'", '"').replaceAllMapped(
  RegExp(r'([a-zA-Z0-9_]+):'),
  (m) => '"${m[ 1 ]}":',
);
print(fixed);
Elixir (manual fix with Regex)
Install: Standard library
broken = "{ name: 'Bob', age: 42 }"
fixed = Regex.replace(~r/'/, broken, """)
fixed = Regex.replace(~r/(\w+):/, fixed, ""\\1":")
IO.puts(fixed)