← Tous les articles
Mis à jour le May 29, 20269 min read

Corriger « [object Object] is Not Valid JSON » et d'autres erreurs de syntaxe JSON

Vous avez « [object Object] is not valid JSON » ou « expected a JSON object, array or literal » ? Apprenez pourquoi ces erreurs arrivent, comment corriger la syntaxe JSON, corriger les virgules finales et réparer du JSON cassé automatiquement.

Vous lancez votre code, regardez l'onglet Network et vous le voyez : "[object Object]" is not valid JSON. Ou peut-être que votre validateur JSON dit Expected a JSON object, array or literal, ou que votre parseur s'étrangle sur une virgule après le dernier élément. Ces erreurs comptent parmi les fautes JSON les plus courantes — et les plus déroutantes — que rencontrent les développeurs. Ce guide explique exactement ce que veut dire chaque erreur, pourquoi elle survient, et comment corriger la syntaxe JSON pour que votre parseur l'accepte.

Que signifie « [object Object] is not valid JSON » ?

Quand JavaScript convertit un objet en chaîne sans utiliser JSON.stringify(), le résultat est le texte [object Object] — la sortie par défaut de la méthode .toString() de tout objet. Si cette chaîne est ensuite passée à JSON.parse() ou envoyée comme corps de requête, vous obtenez l'erreur :

SyntaxError: "[object Object]" is not valid JSON

Le parseur essaie de parser le texte littéral [object Object]. Il voit [, attend un tableau JSON, trouve le mot non quoté object, et échoue. Le crochet est réel — c'est le premier caractère de la chaîne [object Object] — mais ce qui suit n'est pas une syntaxe de tableau JSON valide.

Pourquoi [object Object] apparaît-il dans le JSON ?

La cause racine est toujours la même : un objet JavaScript a été contraint en chaîne quelque part dans le code avant d'être parsé ou transmis. Voici les quatre manières les plus courantes :

Concaténation de chaînes

Quand vous concaténez un objet à une chaîne, JavaScript appelle .toString() sur l'objet, ce qui renvoie [object Object] :

const user = { name: "Alice", age: 30 };

// ❌ La concaténation contraint l'objet
const body = "data=" + user;
console.log(body); // "data=[object Object]"

// ✅ Utiliser JSON.stringify
const body = "data=" + JSON.stringify(user);

Corps de fetch / XMLHttpRequest sans JSON.stringify

Passer un objet brut comme body d'un appel fetch le convertit automatiquement en chaîne :

const payload = { action: "login", user: "alice" };

// ❌ fetch contraint l'objet en "[object Object]"
fetch('/api/login', {
  method: 'POST',
  body: payload,
});

// ✅ Sérialiser d'abord, définir Content-Type
fetch('/api/login', {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify(payload),
});

Littéraux de gabarit

Embarquer un objet directement dans un littéral de gabarit appelle .toString() :

const config = { theme: "dark", lang: "en" };

// ❌ Contrainte via littéral de gabarit
const json = `{"config": ${config}}`;
// '{"config": [object Object]}'  ← JSON invalide

// ✅ Stringifier seulement l'objet
const json = `{"config": ${JSON.stringify(config)}}`;
// '{"config": {"theme":"dark","lang":"en"}}'

Stringify imbriqué

Appeler JSON.stringify() sur un objet qui contient déjà une chaîne JSON pré-sérialisée comme valeur produit une sortie doublement encodée — le littéral de chaîne apparaît dans le JSON au lieu de l'objet qu'il représente :

const inner = JSON.stringify({ id: 1 }); // '{"id":1}'
const outer = JSON.stringify({ data: inner });
// '{"data":"{\"id\":1}"}' — le champ data est une chaîne, pas un objet

// Si cette chaîne externe est ensuite JSON.parse()'ée et que data est ré-utilisé comme JSON,
// il faut faire JSON.parse(result.data) une seconde fois.

Comment corriger l'erreur [object Object] JSON

Le correctif consiste toujours à s'assurer que l'objet est sérialisé avec JSON.stringify() avant d'être utilisé comme chaîne ou transmis sur le réseau. Un diagnostic rapide : cherchez dans votre code chaque endroit où la variable concernée est utilisée comme chaîne et ajoutez-y JSON.stringify().

// Schéma de correction systématique
function toJsonBody(obj) {
  if (typeof obj === 'string') {
    // Déjà une chaîne — valider qu'elle est du JSON valide avant usage
    JSON.parse(obj); // lève si invalide
    return obj;
  }
  return JSON.stringify(obj);
}

« Expected a JSON Object, Array or Literal » — ce que ça veut dire

Cette erreur provient du visualiseur JSON intégré de Firefox (et de certains validateurs JSON) et signifie que la valeur de plus haut niveau de votre JSON n'est aucun des six types JSON valides. Causes courantes :

  • L'entrée est une chaîne vide.JSON.parse("") lève cette erreur parce qu'une chaîne vide n'est pas une valeur JSON valide.
  • L'entrée est undefined. JSON.stringify(undefined) renvoie undefined (pas la chaîne "undefined"), et JSON.parse(undefined) lève.
  • La réponse est du HTML, pas du JSON. Une page d'erreur serveur renvoie souvent du HTML. Le premier caractère < n'est pas du JSON valide. Vérifiez l'en-tête Content-Type et le corps de réponse brut dans l'onglet Network avant de conclure que le JSON lui-même est cassé.
  • Il y a un BOM en début de fichier. Un BOM UTF-8 (octets 0xEF 0xBB 0xBF) préposé à un fichier JSON provoque cette erreur dans les parseurs stricts. RFC 8259 interdit explicitement les BOM dans JSON.
// Garder contre vide / undefined avant de parser
function safeParse(text) {
  if (!text || typeof text !== 'string') {
    throw new TypeError(`Cannot parse ${typeof text} as JSON`);
  }
  return JSON.parse(text.trimStart()); // trimStart retire les BOM/espaces accidentels
}

Virgule JSON après le dernier élément : l'erreur de virgule finale

Autre erreur de syntaxe JSON extrêmement courante : une virgule finale — une virgule qui apparaît après le dernier élément d'un objet ou d'un tableau :

// ❌ Virgule finale dans un objet
{
  "name": "Alice",
  "age": 30,
}

// ❌ Virgule finale dans un tableau
["red", "green", "blue",]

La grammaire JSON impose qu'une virgule sépare deux éléments — il doit toujours y avoir une valeur de chaque côté. Une virgule sans rien après viole la grammaire. JavaScript lui-même autorise les virgules finales (depuis ES5), c'est pourquoi les développeurs en écrivent sans y penser.

Pour trouver et corriger les virgules finales programmatiquement :

// ⚠️ Correctif regex — marche pour les cas simples, peut corrompre des chaînes
const fixed = raw.replace(/,\s*([}\]])/g, '$1');

// ✅ Mieux : utiliser un parseur de réparation qui comprend la grammaire
// par ex. la bibliothèque json-repair sur npm

Pour une plongée dans cette erreur précise, voir Virgule finale en JSON : pourquoi ça lève et comment corriger.

Comment corriger la syntaxe JSON : checklist complète

Avant de dégainer un outil de correction JSON, parcourez cette checklist pour identifier la classe d'erreur :

Structure

  • Chaque { a un } correspondant et chaque [ a un ] correspondant. Les crochets non fermés sont parmi les erreurs de troncature les plus fréquentes.
  • Pas de virgule finale — pas de virgule après la dernière paire clé–valeur d'un objet ni le dernier élément d'un tableau.
  • Pas de virgule manquante — chaque élément d'un objet ou tableau (sauf le dernier) doit être suivi d'une virgule.

Chaînes

  • Toutes les chaînes utilisent des guillemets doubles. Les chaînes en guillemets simples ('Alice') sont de la syntaxe JavaScript, pas JSON.
  • Toutes les clés d'objet sont des chaînes entre guillemets doubles. Les clés nues ({ name: "Alice" }) sont de la syntaxe d'objet littéral JavaScript, pas JSON.
  • Les caractères de contrôle dans les chaînes doivent être échappés. Les sauts de ligne, tabulations et octets nuls bruts dans une chaîne JSON sont illégaux — utilisez \n, \t, \u0000 à la place.

Valeurs

  • Les booléens sont en minuscules :true / false, pas True / False / TRUE.
  • Null est en minuscules :null, pas None, nil, ni NULL.
  • Pas d'undefined. JSON n'a pas de type undefined ; utilisez null ou omettez la clé.
  • Pas de NaN ni Infinity. Ces valeurs JavaScript n'ont pas de représentation JSON. JSON.stringify({x: Infinity}) produit {"x":null} en silence.

Contenu supplémentaire

  • Pas de commentaires.// commentaires de ligne et /* commentaires de bloc */ ne font pas partie de la spécification JSON.
  • Pas de contenu en trop. Un texte JSON valide est exactement une seule valeur — rien avant (sauf un espace optionnel) ni rien après.

Utiliser un correcteur JSON : quand automatiser

Pour le débogage ponctuel, corriger le JSON à la main est rapide. Pour des pipelines de production qui reçoivent du JSON depuis des sources externes — APIs, sorties de modèles IA, entrée utilisateur — il vous faut un correcteur JSON : code ou outil qui répare programmatiquement les erreurs de syntaxe courantes sans casser le contenu valide.

Un bon correcteur JSON gère :

  • Les virgules finales dans les objets et tableaux
  • Les chaînes en guillemets simples → chaînes en guillemets doubles
  • Les clés non quotées → clés entre guillemets doubles
  • Les littéraux Python (True, False, None) → équivalents JSON
  • Les commentaires JavaScript // ligne et /* bloc */ → supprimés
  • Les balises de bloc de code Markdown (```json ... ```) → retirées
  • Les crochets non fermés → refermés automatiquement

Exigence clé : les corrections doivent être conscientes de la grammaire — l'outil comprend quels tokens sont des séparateurs structurels et lesquels sont à l'intérieur des valeurs de chaîne, afin de ne jamais corrompre un contenu de chaîne qui contient justement ,} ou True.

Pour un tutoriel sur l'implémentation de la réparation JSON en code JavaScript, voir Comment gérer du JSON cassé en JavaScript.

Éviter les pièges de JSON.stringify (références circulaires comprises)

Une fois qu'on prend l'habitude de toujours sérialiser avec JSON.stringify, deux situations continuent de piéger :

  • Les références circulaires lèvent. Une valeur comme const a = {}; a.self = a; donne TypeError: Converting circular structure to JSON. Trois bonnes alternatives : abandonner la référence arrière avec un replacer personnalisé qui suit les objets vus ; passer à structuredClone(value) pour des copies profondes en mémoire ; ou utiliser une bibliothèque comme flatted quand on doit vraiment sérialiser un graphe cyclique et le reconstruire plus tard.
  • Types avec perte.JSON.stringify supprime silencieusement undefined, les fonctions et les valeurs Symbol, et convertit NaN / Infinity en null. Convertissez-les en quelque chose de représentable avant stringify, pas après parsing.

Référence rapide : erreurs JSON courantes et correctifs

// 1. [object Object] — objet contraint en chaîne
❌ fetch(url, { body: myObject })
✅ fetch(url, { body: JSON.stringify(myObject) })

// 2. Virgule finale
❌ { "a": 1, "b": 2, }
✅ { "a": 1, "b": 2 }

// 3. Guillemets simples
❌ { 'name': 'Alice' }
✅ { "name": "Alice" }

// 4. Clé non quotée
❌ { name: "Alice" }
✅ { "name": "Alice" }

// 5. Booléen Python
❌ { "active": True }
✅ { "active": true }

// 6. Commentaire en JSON
❌ { "debug": true // log everything }
✅ { "debug": true }

// 7. Chaîne vide
❌ JSON.parse("")
✅ JSON.parse(text || "null")

// 8. Page d'erreur HTML prise pour du « JSON »
❌ JSON.parse("<!DOCTYPE html>...")
✅ Vérifier response.ok et Content-Type avant d'appeler response.json()

Foire aux questions

Que signifie « [object Object] is not valid JSON » ?

Un objet JavaScript a été converti en chaîne avec sa .toString() par défaut, produisant le texte littéral [object Object], qui a ensuite été parsé ou envoyé comme JSON. Le correctif consiste à sérialiser avec JSON.stringify() avant d'utiliser la valeur comme chaîne.

Comment corriger l'erreur [object Object] dans une requête fetch ?

Mettez body: JSON.stringify(payload) et ajoutez un en-tête Content-Type: application/json. Passer un objet brut comme body le contraint en [object Object].

Qu'est-ce que « Expected a JSON object, array or literal » ?

Firefox et certains validateurs l'affichent quand la valeur de plus haut niveau n'est pas l'un des six types JSON — généralement parce que l'entrée est vide, est undefined, est du HTML au lieu de JSON, ou commence par un BOM. Vérifiez d'abord response.ok et l'en-tête Content-Type.

Quelles sont les erreurs de syntaxe JSON les plus courantes ?

Virgules finales, guillemets simples, clés non quotées, littéraux Python (True/None), commentaires, et NaN/Infinity. Chacun a son guide dédié : voir virgules finales, erreurs unexpected-token, unexpected end of input, et caractères de contrôle invalides.

Corriger la syntaxe JSON en ligne — sans installation

Si vous avez une chaîne JSON cassée à corriger tout de suite, JSON Fix répare automatiquement toutes les erreurs ci-dessus. Collez votre JSON — aussi cassé soit-il — cliquez sur Repair & Format, et récupérez un JSON syntaxiquement correct et formaté. L'outil tourne entièrement dans votre navigateur : aucune donnée n'est envoyée à un serveur, ce qui est sûr pour les payloads sensibles.