Corriger un JSON invalide : 10 erreurs courantes

Pour corriger un JSON invalide, collez-le dans un validateur JSON, allez à la ligne signalée et regardez le caractère juste avant l'endroit indiqué. Neuf fois sur dix, le coupable est une virgule finale, des guillemets simples, une clé sans guillemets, un commentaire ou un crochet manquant. Si l'erreur indique Unexpected token < à la position 0, le problème ne vient pas du tout de votre JSON : vous avez reçu une page HTML. Ce guide passe en revue chaque erreur JSON courante, ce que signifie vraiment le message et comment la corriger précisément.

Pourquoi JSON est si strict

JSON (JavaScript Object Notation) ressemble à JavaScript, mais sa grammaire est bien plus réduite et plus stricte. La norme, RFC 8259, n'autorise que quelques éléments : des objets entre { }, des tableaux entre [ ], des chaînes entre guillemets doubles, des nombres, true, false et null. Tout le reste, y compris des syntaxes que JavaScript ou Python acceptent volontiers, rend le document entier invalide.

Cette rigueur est un atout. Comme tous les analyseurs s'accordent sur le même petit ensemble de règles, un JSON écrit dans un langage peut être lu de façon fiable dans n'importe quel autre. L'inconvénient, c'est qu'un seul caractère mal placé casse tout, et les analyseurs s'arrêtent généralement au premier problème rencontré.

Corriger un JSON invalide étape par étape

1. Copiez le texte exact. Prenez l'entrée brute, pas une version déjà retouchée. Si elle vient d'une API, copiez le corps de la réponse tel qu'il a été reçu.
2. Collez-le dans le validateur. Ouvrez le validateur et formateur JSON, collez le texte et validez.
3. Repérez l'emplacement signalé. Notez la ligne, la colonne ou la position indiquée dans le message d'erreur.
4. Regardez légèrement à gauche. La position signalée est l'endroit où l'analyseur a abandonné, souvent un ou deux caractères après la vraie erreur. Une virgule finale, par exemple, est généralement signalée au crochet fermant qui la suit.
5. Corrigez une erreur et validez à nouveau. Les analyseurs ne signalent que le premier problème : recommencez jusqu'à ce que l'entrée passe.
6. Formatez le résultat. Une fois valide, la version formatée et indentée permet de vérifier bien plus facilement que la structure est celle attendue.

Les 10 erreurs JSON les plus courantes et leurs corrections

1. Virgules finales

Une virgule après le dernier élément d'un objet ou d'un tableau est l'erreur JSON la plus fréquente, car le code JavaScript l'autorise et de nombreux éditeurs la laissent traîner.

{"name": "Ada", "role": "admin",}   // invalide
{"name": "Ada", "role": "admin"}    // valide

Correction : supprimez la virgule avant le } ou le ] fermant.

2. Guillemets simples

Les chaînes et les clés JSON doivent utiliser des guillemets doubles. Les guillemets simples passent en JavaScript et en Python, mais pas en JSON.

{'name': 'Ada'}    // invalide
{"name": "Ada"}    // valide

Correction : remplacez les guillemets simples autour des clés et des valeurs par des guillemets doubles. Attention aux apostrophes à l'intérieur du texte, comme dans "it's", qui sont correctes et doivent rester.

3. Clés sans guillemets

Chaque nom de propriété doit être une chaîne entre guillemets.

{name: "Ada"}      // invalide
{"name": "Ada"}    // valide

4. Virgules manquantes

Quand deux valeurs se suivent sans virgule, l'analyseur se plaint de la seconde. Cela arrive souvent après une modification manuelle ou la fusion de deux extraits.

{"a": 1 "b": 2}    // invalide
{"a": 1, "b": 2}   // valide

Correction : ajoutez la virgule juste après la valeur précédente, juste avant la position indiquée par l'erreur.

5. Commentaires

Le JSON standard n'a pas de commentaires. // ... comme /* ... */ sont invalides. Certains outils utilisent des formats assouplis (JSONC ou JSON5) pour les fichiers de configuration, qui autorisent commentaires et virgules finales, mais un analyseur JSON strict les rejettera.

Correction : supprimez les commentaires, ou placez vos notes dans un champ ordinaire comme "_comment": "..." si le programme destinataire ignore les clés inconnues.

6. Valeurs Python ou JavaScript

JSON ne connaît que true, false et null en minuscules. Les True, False et None de Python sont invalides, tout comme les undefined, NaN et Infinity de JavaScript.

Correction : convertissez-les en leurs équivalents JSON, et transformez des valeurs comme NaN en null ou en chaîne. Si vous affichez un dictionnaire Python, utilisez json.dumps() plutôt que print() ou str(), qui produisent de la syntaxe Python, pas du JSON.

7. Guillemets typographiques venus de documents et de messageries

Le texte copié depuis un traitement de texte, une présentation ou une appli de messagerie contient souvent des guillemets courbes (“ ”) au lieu de guillemets droits ("). Ils se ressemblent beaucoup, mais ce sont des caractères différents.

Correction : remplacez les guillemets courbes autour des clés et des valeurs par des guillemets doubles droits, et copiez le code depuis des sources en texte brut dès que possible.

8. Échappements incorrects et retours à la ligne dans les chaînes

Une barre oblique inverse commence une séquence d'échappement, donc un chemin Windows comme "C:\new\file" casse ou change de sens sans prévenir. Un vrai retour à la ligne dans une chaîne est également invalide.

{"path": "C:\new\file"}       // invalide
{"path": "C:\\new\\file"}     // valide
{"note": "line one\nline two"} // valide : le retour à la ligne est échappé

Correction : doublez chaque barre oblique inverse littérale et écrivez les retours à la ligne sous la forme \n.

9. Crochets manquants ou en trop

Une erreur comme Unexpected end of JSON input signifie généralement qu'un } ou ] fermant manque, ou que le texte a été coupé en cours de route. Un crochet en trop produit une erreur de jeton inattendu vers la fin.

Correction : formatez les parties qui s'analysent, ou indentez le texte à la main, et comptez les crochets ouvrants et fermants niveau par niveau. Si l'entrée a été tronquée (par exemple une ligne de journal avec une limite de longueur), récupérez l'original complet plutôt que de deviner la fin.

10. Plusieurs documents JSON collés

Un document JSON contient exactement une valeur de premier niveau. Deux objets à la suite, comme {"id":1}{"id":2}, ne forment pas un document valide, pas plus qu'un fichier journal délimité par des retours à la ligne où chaque ligne est un objet.

Correction : placez les éléments dans un tableau, [{"id":1},{"id":2}], ou analysez le fichier ligne par ligne s'il est censé être délimité par des retours à la ligne.

Décoder les messages d'erreur

Chaque langage et chaque navigateur formule le même problème différemment. Voici comment traduire les messages que vous verrez le plus souvent.

Unexpected token < in JSON at position 0

Le premier caractère est <, ce qui signifie que le texte est du HTML, pas du JSON. Un serveur a renvoyé une page d'erreur, une page de connexion ou une page 404 au lieu de données. Vérifiez le code de statut HTTP et l'en-tête Content-Type avant l'analyse. Notre outil d'en-têtes HTTP affiche les deux pour n'importe quelle URL publique, et le vérificateur de redirections d'URL révèle si la requête est redirigée ailleurs, par exemple vers une page de connexion.

Unexpected token u in JSON at position 0

La valeur passée à l'analyseur était undefined, qui devient le texte undefined. Le bug se trouve plus tôt dans votre code : la variable n'a jamais été définie.

Unexpected end of JSON input

L'analyseur a atteint la fin avant que la structure soit complète. Cherchez un crochet manquant ou un corps de réponse vide.

Expected property name or '}' / Expecting property name enclosed in double quotes

Le premier message vient de JavaScript et le second du module json de Python. Tous deux désignent généralement une virgule finale, une clé entre guillemets simples ou une clé sans guillemets.

Un caractère invisible à la position 0

Si le texte semble parfait mais échoue dès le premier caractère, il commence peut-être par une marque d'ordre des octets (BOM) ou un autre caractère invisible. Enregistrez le fichier en UTF-8 sans BOM, ou supprimez ce premier caractère avant l'analyse.

Exemple concret : réparer un extrait de configuration cassé

Voici un extrait que quelqu'un a collé depuis un message de discussion :

{
  name: 'My App',
  "debug": True,
  // turn this off in production
  "plugins": ["seo", "cache",],
  "path": "C:\apps\myapp"
}

Le validateur s'arrête à la première erreur, la clé sans guillemets de la ligne 2. En corrigeant une chose à la fois :

• Ligne 2 : mettez la clé entre guillemets et passez aux guillemets doubles, ce qui donne "name": "My App".
• Ligne 3 : remplacez True par true.
• Ligne 4 : supprimez le commentaire.
• Ligne 5 : retirez la virgule après "cache".
• Ligne 6 : doublez les barres obliques inverses, ce qui donne "C:\\apps\\myapp".

Le résultat valide :

{
  "name": "My App",
  "debug": true,
  "plugins": ["seo", "cache"],
  "path": "C:\\apps\\myapp"
}

Vérifier du JSON en ligne de commande

Pour les gros fichiers ou les contrôles automatisés, validez en local. Chacune de ces commandes se termine en erreur si l'entrée est invalide, vous pouvez donc les utiliser dans des scripts :

• python3 -m json.tool data.json affiche le JSON formaté, ou une erreur avec sa ligne et sa colonne.
• jq empty data.json vérifie le fichier et n'affiche rien s'il est valide (jq doit être installé).
• node -e "JSON.parse(require('fs').readFileSync('data.json','utf8'))" utilise le même analyseur que les applis Node.js.

Pièges à éviter

• Ne corrigez pas le symptôme par rechercher-remplacer. Remplacer aveuglément tous les guillemets simples casse aussi les apostrophes dans le texte. Corrigez uniquement les guillemets autour des clés et des valeurs.
• N'étouffez pas les erreurs d'analyse. Un code qui renvoie un objet vide dès que l'analyse échoue masque de vrais bugs. Journalisez plutôt l'erreur et les premiers caractères de l'entrée (sans journaliser de données privées).
• Corrigez la source, pas seulement la sortie. Si un système produit sans cesse du JSON cassé, générez-le avec un vrai sérialiseur comme JSON.stringify() ou json.dumps() plutôt qu'en collant des chaînes.
• Méfiez-vous des données cachées dans d'autres encodages. Du JSON dans une URL ou un jeton arrive souvent encodé. Décodez-le d'abord avec le décodeur d'URL ou le décodeur Base64, puis validez-le.

Outils et guides associés

• Le validateur et formateur JSON vérifie la syntaxe et met en forme le JSON pour le rendre lisible.
• L'analyseur d'URL découpe l'adresse d'une API en ses parties pour confirmer que vous appelez le bon point de terminaison.
• Le convertisseur d'entités HTML décode des textes comme ", qui apparaissent parfois quand du JSON a été intégré dans du HTML.
• Comment vérifier les enregistrements DNS aide quand une API renvoie du HTML parce que le domaine pointe vers le mauvais serveur.
• Comment supprimer les doublons et nettoyer des listes est utile pour ranger des valeurs avant de les placer dans un tableau JSON.

Questions fréquentes

Pourquoi mon JSON est-il invalide alors qu'il semble correct ?

Les suspects habituels sont des caractères invisibles ou trompeurs : une virgule finale, des guillemets courbes au lieu de droits, une marque d'ordre des octets au début du fichier ou un commentaire. Un validateur indique l'emplacement exact, vous n'avez pas à chercher à l'œil.

Les virgules finales sont-elles autorisées en JSON ?

Non. Le JSON standard n'autorise pas de virgule après le dernier élément d'un objet ou d'un tableau. Des formats assouplis comme JSONC et JSON5 les acceptent, mais les analyseurs stricts comme JSON.parse les rejettent.

Le JSON peut-il contenir des commentaires ?

Non. Le JSON standard n'a pas de syntaxe de commentaire. Supprimez-les avant l'analyse, ou utilisez un champ ordinaire comme _comment si le programme qui lit le fichier ignore les clés supplémentaires.

Que signifie Unexpected token < in JSON at position 0 ?

Le texte commence par un signe inférieur à, c'est donc presque certainement une page HTML, comme une page d'erreur, de connexion ou 404, au lieu de JSON. Vérifiez le code de statut HTTP, l'en-tête Content-Type et l'URL demandée.

Le JSON est-il sensible à la casse ?

Oui. Les littéraux doivent être true, false et null en minuscules, et les clés sont sensibles à la casse : Name et name sont deux clés différentes.

Quelle différence entre valider et formater du JSON ?

Valider vérifie si le texte respecte les règles de JSON et signale la première erreur. Formater ajoute des retours à la ligne et une indentation à un JSON valide pour le rendre plus lisible. Les données ne changent pas.