Outil de Réparation JSON

Réparez et récupérez automatiquement les fichiers JSON corrompus ou mal formés — de manière sécurisée, rapide et gratuite.

Cet outil répare les fichiers JSON cassés ou invalides grâce à une correction d'erreurs automatisée. Il cible les problèmes de syntaxe les plus courants rencontrés dans les données exportées, les journaux ou les fichiers édités manuellement—comme les guillemets manquants, les virgules superflues ou les crochets déséquilibrés—et génère un JSON valide et analysable en sortie.

Réparez votre JSON ci-dessous

Comment fonctionne la réparation JSON

L'outil analyse votre saisie à la recherche de problèmes courants de syntaxe JSON et applique des corrections ciblées, générant un JSON valide autant que possible.

  1. Analyse l'entrée et détecte les erreurs de syntaxe courantes, telles que les caractères illégaux, les parenthèses mal placées et les guillemets incorrects, pour assurer un code propre et optimisé.
  2. Applique des corrections aux erreurs fréquentes — comme l'ajout de guillemets manquants, la suppression des virgules superflues ou la correction des crochets.
  3. Produit le JSON réparé. Dans la plupart des cas, le résultat est prêt à être analysé ou utilisé immédiatement.
  4. Si la structure ne peut pas être réparée automatiquement, une erreur claire est affichée pour que vous puissiez ajuster votre saisie.

Erreurs JSON Courantes et Comment les Corriger

Voici les erreurs JSON typiques que cet outil peut corriger, avec des exemples pour chacune :

Clés non citées

Les clés doivent être entre guillemets doubles.

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

Correction : Ajout de guillemets doubles autour de toutes les clés d’objet non citées.

Guillemets Simples Utilisés

JSON n'accepte que les guillemets doubles pour les chaînes de caractères.

Before:
{ 'role': 'administrateur' }
After:
{ "role": "administrateur" }

Correction : Remplace les guillemets simples par des guillemets doubles pour toutes les chaînes.

Virgules terminales

Aucune virgule n’est autorisée après le dernier élément.

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

Correction : Suppression de toutes les virgules terminales.

Crochets non appariés ou non fermés

Toutes les parenthèses et accolades doivent être correctement fermées.

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

Correction : Ajoute les crochets ou accolades fermantes manquants.

Virgules manquantes ou en trop

Les éléments des tableaux et des objets doivent être séparés par une seule virgule.

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

Correction : Insère les virgules manquantes ou supprime les doublons.

Lignes de commentaire présentes

Le JSON standard n'autorise pas les commentaires (comme // ou /* ... */).

Before:
{ "id": 1, // identifiant utilisateur
 "active": true }
After:
{ "id": 1, "actif": true }

Correction : supprime les lignes de commentaires de l'entrée.

Formats de Numéro Invalides

Seuls les nombres décimaux simples sont valides (pas de NaN, d’Infinity ni d’hexadécimal).

Before:
{ "val": Non défini }
After:
{ "val": null }

Correction : remplace les nombres invalides par null.

Caractères de Contrôle Non Échappés

Les caractères comme les sauts de ligne dans les chaînes doivent être échappés.

Before:
{ "msg": "Ligne1
Ligne2" }
After:
{ "msg": "Ligne1\nLigne2" }

Correction : Échappe correctement les caractères de contrôle.

Clés dupliquées dans l'objet

Les clés en double dans un même objet causent de l'ambiguïté.

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

Correction : conserve uniquement la dernière valeur pour chaque clé en double.

Tableaux mal formés

Les tableaux doivent contenir des crochets et des virgules entre les éléments.

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

Correction : Ajout des virgules manquantes entre les éléments du tableau.

Entrée vide ou uniquement des espaces

Le JSON ne peut pas être vide.

Before:
After:
nul
Correction : Retourne null pour une entrée vide.
Exemple : Du JSON corrompu à une réparation valide
Entrée JSON mal formée
{ utilisateur : 'alice', identifiant : 42, rôles : [admin, 'éditeur',] // virgule supplémentaire
 actif : vrai }
Sortie JSON réparée
{
  "user": "alice",
  "id": 42,
  "roles": [
    "administrateur",
    "éditeur"
  ],
  "active": true
}
Comment Utiliser Cet Outil de Réparation JSON
  1. Collez ou saisissez votre JSON cassé dans l’éditeur ci-dessous.
  2. Cliquez sur « Réparer » pour détecter et corriger automatiquement les erreurs de syntaxe courantes.
  3. Examinez le résultat réparé et copiez votre JSON corrigé.
Vérifiez toujours le JSON réparé avant de l'utiliser pour des données critiques — des ajustements manuels peuvent être nécessaires pour des entrées complexes ou fortement endommagées.
Exemples de code pour la réparation JSON
Découvrez comment réparer le JSON dans différents langages de programmation.
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)