Votre appel d’API vient d’échouer avec JSONDecodeError: Expecting property name enclosed in double quotes. Le temps presse. Les données viennent d’un LLM, et quelque part dans cette réponse de 2000 tokens, une simple virgule en trop a fait tomber tout votre pipeline.
En mai 2026, le moyen le plus rapide de réparer les fichiers JSON mal formés est d’utiliser des bibliothèques automatisées comme json_repair (Python) ou jsonrepair (npm). Ces outils sont conçus pour corriger instantanément les erreurs de syntaxe générées par les LLM. Pour les réparations manuelles, les coupables habituels sont les virgules en trop, les simples quotes ou les clés sans guillemets — les trois violations les plus courantes de la norme RFC 8259.
La réparation la plus rapide : json_repair pour les sorties de LLM
Les analyseurs standard comme json.loads() de Python sont stricts par conception. Un seul caractère mal placé déclenche une JSONDecodeError et tout s’arrête. C’est un problème quotidien en 2026, car les LLM enveloppent régulièrement le JSON dans du texte conversationnel, tronquent les réponses en plein milieu de phrase, ou parsèment le tout de commentaires qui enfreignent la spécification.
La bibliothèque json_repair est la solution de référence. Selon GitHub, ce projet compte plus de 4700 étoiles en 2026. Il fonctionne en « devinant » l’intention de la chaîne — en refermant les crochets manquants, en ajoutant des guillemets et en retirant le texte superflu autour du bloc JSON.
Python : avant et après
Installation : pip install json-repair
L’entrée cassée :
import json_repair
bad_json = '{"user": "Alice", "status": tru'
decoded_object = json_repair.loads(bad_json)
Ce qui s’est passé en coulisses : json_repair a vu que tru était probablement true, a ajouté l’accolade fermante manquante et a renvoyé un dictionnaire Python valide. Zéro intervention manuelle.
Mode Salvage : quand les données sont vraiment moches
Pour les cas plus difficiles, json_repair (v0.59.5+) inclut un Mode Salvage. Comme le note la documentation du projet, ce mode est conçu spécifiquement pour les réponses d’IA tronquées ou les journaux corrompus. Il peut forcer des tableaux à devenir des objets ou abandonner des éléments trop abîmés pour être sauvés, garantissant que la sortie corresponde à votre schéma.
import json_repair
# Salvage mode for severely truncated data
result = json_repair.loads(
'{"items": [{"id": 1, "name": "Widget"}, {"id": 2, "na',
salvage_mode=True
)
# Result: {'items': [{'id': 1, 'name': 'Widget'}, {'id': 2}]}
# Dropped the incomplete 'na' but saved everything else
Alternative npm
Pour les projets Node.js, le CLI jsonrepair fait le même travail :
# Fix a file in place
npx jsonrepair broken.json > fixed.json
# Fix a string in a script
const { jsonrepair } = require('jsonrepair');
const fixed = jsonrepair('{"name": "test",}');
Débogage manuel : trouver ce qui a cassé la spécification
Quand l’automatique ne suffit pas, vous devez trouver exactement où le fichier enfreint la RFC 8259. Le JSON est bien moins indulgent que YAML ou JavaScript. Comme l’explique l’équipe de diagnostic JSONParser, « l’analyseur échoue au premier caractère qu’il ne parvient pas à comprendre, ce qui est souvent un symptôme en aval d’un problème apparu plusieurs lignes plus tôt ».
Les trois tueurs de JSON
Tueur 1 : les virgules en trop
Selon DEV Community, les virgules en trop sont la cause n°1 des échecs d’analyse. Elles vont très bien en JavaScript, mais sont illégales après le dernier élément d’un tableau ou d’un objet JSON.
// BROKEN - trailing comma after "active"
{
"name": "Alice",
"status": "active",
}
// FIXED - no comma before closing brace
{
"name": "Alice",
"status": "active"
}
Tueur 2 : les simples quotes
Le JSON exige des guillemets doubles (") pour les clés comme pour les valeurs de chaîne. Beaucoup de développeurs Python et JavaScript utilisent par accident des simples quotes ('). Comme le souligne TidyCode, c’est une correction obligatoire.
// BROKEN - single quotes
{'name': 'Alice'}
// FIXED - double quotes
{"name": "Alice"}
Tueur 3 : les clés sans guillemets
En JavaScript, vous pouvez écrire { name: "Alice" }. En JSON, chaque clé a besoin de guillemets doubles.
// BROKEN - unquoted key
{name: "Alice"}
// FIXED - quoted key
{"name": "Alice"}
L’erreur « Unexpected Token »
Quand un validateur signale « Unexpected Token », cela signifie que l’analyseur a rencontré NaN, Infinity ou undefined — des constantes JavaScript que le JSON ne prend pas en charge. Le JSON n’autorise que null, true, false et les nombres.
// BROKEN - NaN is not valid JSON
{"score": NaN, "result": Infinity}
// FIXED - replace with null or valid values
{"score": null, "result": null}
Analyse stricte vs. analyse de réparation : quand utiliser laquelle
La bonne approche dépend de la provenance de vos données. Les fichiers de configuration édités à la main méritent une analyse stricte pour obliger l’auteur à corriger ses erreurs. Les données générées par machine, issues de LLM ou de journaux d’API, nécessitent une analyse basée sur la réparation.
| Fonctionnalité |
Strict (json.loads) |
Réparation (json_repair) |
| Virgules en trop |
Lève une JSONDecodeError |
Automatiquement retirées |
| Simples quotes |
Échoue |
Converties en guillemets doubles |
| Données tronquées |
Échoue |
Referme les crochets/guillemets ouverts |
| Commentaires |
Échoue |
Automatiquement retirés |
| Meilleur cas d’usage |
Fichiers de config édités à la main |
Sorties de LLM, journaux d’API |
Réparations guidées par schéma avec Pydantic
Vous pouvez guider le processus de réparation avec Pydantic v2 ou un JSON Schema. En fournissant un schéma à json_repair, l’outil fait plus que corriger la syntaxe — il peut corriger les types (transformer la chaîne "1" en nombre 1) et remplir les champs obligatoires manquants avec des valeurs par défaut.
from pydantic import BaseModel
import json_repair
class User(BaseModel):
id: int
name: str
active: bool = True
# Broken JSON with wrong types
raw = '{"id": "42", "name": "Alice"}'
repaired = json_repair.loads(raw)
# Validate against schema
user = User(**repaired)
# user.id is now int(42), user.active defaults to True
Comme l’a noté Stefano Baccianella dans la citation de son projet en 2025, cette approche est optimisée pour le JSON « globalement correct mais techniquement invalide » que les modèles de langage ont tendance à produire.
Gérer les fichiers de plusieurs gigaoctets sans planter
Réparer un extrait de 10 Ko est facile. Réparer un fichier de 2 Go nécessite une stratégie qui ne va pas dévorer toute votre RAM. Charger le fichier entier en mémoire provoque des erreurs de type mémoire saturée (OOM).
Stratégie 1 : le streaming avec ijson
Pour les jeux de données massifs, utilisez ijson pour traiter les données morceau par morceau. Comme le mentionne Scrapfly, ijson traite les données de manière incrémentale. Associez-le à un script de nettoyage qui corrige les problèmes ligne par ligne avant l’analyse.
import ijson
# Stream through a large JSON file
with open('huge_broken.json', 'r') as f:
for item in ijson.items(f, 'records.item'):
# Process each item individually
process(item)
Stratégie 2 : le pipe CLI pour une efficacité maximale
L’approche la plus économe en mémoire pour les gros fichiers consiste à utiliser le CLI jsonrepair et à envoyer la sortie directement vers un nouveau fichier :
# Streams repair, never loads full file into memory
jsonrepair large_broken.json > fixed.json
C’est nettement plus économe en mémoire que de charger le fichier dans Python ou un navigateur.
Conclusion
Réparer le JSON mal formé n’est plus une corvée manuelle grâce aux bibliothèques adaptées à l’IA comme json_repair. Vous avez encore besoin de comprendre les bases de la RFC 8259 — pas de virgules en trop, pas de simples quotes, pas de clés sans guillemets — mais l’automatisation est la seule approche praticable pour les données à grande échelle en 2026.
Le flux de travail est simple : essayez d’abord une bibliothèque de réparation. Si elle échoue, utilisez un validateur pour localiser l’erreur de syntaxe exacte. Cela permet à vos applications de continuer à tourner même quand les données entrantes sont loin d’être parfaites.
FAQ
Le JSON peut-il officiellement prendre en charge les commentaires ou les simples quotes ?
Non. La norme RFC 8259 interdit strictement les commentaires. Les simples quotes sont également invalides — seuls les guillemets doubles sont autorisés pour les clés et les chaînes. Toutefois, des outils comme json_repair peuvent retirer les commentaires et convertir les guillemets automatiquement afin de rendre les fichiers analysables par les bibliothèques standard.
Comment gérer de très gros fichiers JSON mal formés sans planter ?
Utilisez un analyseur en flux comme ijson pour traiter les données par blocs. Évitez de charger toute la chaîne mal formée dans une seule variable. Pour des résultats plus rapides, utilisez des outils de réparation en CLI qui envoient la sortie directement vers un nouveau fichier sur le disque sans tout garder en mémoire.
Quelle est la différence entre un JSON mal formé et un JSON invalide ?
Le JSON mal formé enfreint les règles de syntaxe — crochets manquants, clés sans guillemets, virgules en trop — ce qui le rend impossible à analyser. Le JSON invalide respecte toutes les règles de syntaxe mais ne correspond pas à un JSON Schema précis (par exemple, un champ est une chaîne alors que le schéma attend un entier). Réparer un JSON mal formé est une réparation structurelle ; réparer un JSON invalide relève de l’intégrité des données.
Puis-je utiliser json_repair avec la validation Pydantic ?
Oui. Exécutez d’abord json_repair.loads() pour corriger les erreurs de syntaxe, puis passez le dictionnaire réparé à votre modèle Pydantic pour la validation des types et l’application du schéma. Cette approche en deux étapes traite à la fois les problèmes structurels et sémantiques.
Qu’en est-il du JSON avec des commentaires de style JavaScript ?
Le JSON standard ne prend pas en charge les commentaires, mais json_repair peut retirer automatiquement les commentaires // et /* */. Si vous avez besoin de commentaires dans vos fichiers de configuration, envisagez le format JSONC (JSON avec commentaires) et un analyseur compatible comme json5 pour Python.
