← Tutti gli articoli
Aggiornato il May 29, 20269 min read

Correggi «[object Object] is Not Valid JSON» e altri errori di sintassi JSON

Ricevi «[object Object] is not valid JSON» o «expected a JSON object, array or literal»? Impara perché avvengono questi errori, come correggere la sintassi JSON, sistemare virgole finali e riparare JSON rotto automaticamente.

Esegui il codice, controlli la scheda Network e lo vedi: "[object Object]" is not valid JSON. O magari il tuo validatore JSON dice Expected a JSON object, array or literal, oppure il tuo parser si strozza su una virgola dopo l'ultimo elemento. Questi sono fra gli errori JSON più comuni — e più sconcertanti — che incontrano gli sviluppatori. Questa guida spiega esattamente cosa significa ciascun errore, perché accade e come correggere la sintassi JSON affinché il parser la accetti.

Cosa significa «[object Object] is not valid JSON»?

Quando JavaScript converte un oggetto in stringa senza usare JSON.stringify(), il risultato è il testo [object Object] — l'output predefinito del metodo .toString() di qualunque oggetto. Se quella stringa viene poi passata a JSON.parse() o inviata come corpo della richiesta, ottieni l'errore:

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

Il parser sta cercando di parsare il testo letterale [object Object]. Vede [, si aspetta un array JSON, trova la parola senza apici object e fallisce. La parentesi è reale — è il primo carattere della stringa [object Object] — ma ciò che segue non è una sintassi di array JSON valida.

Perché [object Object] appare nel JSON?

La causa radice è sempre la stessa: un oggetto JavaScript è stato forzato a stringa da qualche parte nel codice prima di essere parsato o trasmesso. Ecco i quattro modi più comuni in cui accade:

Concatenazione di stringhe

Quando concateni un oggetto con una stringa, JavaScript chiama .toString() sull'oggetto, che restituisce [object Object]:

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

// ❌ La concatenazione forza la conversione dell'oggetto
const body = "data=" + user;
console.log(body); // "data=[object Object]"

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

Body di fetch / XMLHttpRequest senza JSON.stringify

Passare un oggetto semplice come body di una chiamata fetch lo converte automaticamente in stringa:

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

// ❌ fetch forza l'oggetto a "[object Object]"
fetch('/api/login', {
  method: 'POST',
  body: payload,
});

// ✅ Serializza prima, imposta il Content-Type
fetch('/api/login', {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify(payload),
});

Template literal

Inserire un oggetto direttamente in un template literal chiama .toString():

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

// ❌ Coercizione da template literal
const json = `{"config": ${config}}`;
// '{"config": [object Object]}'  ← JSON non valido

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

Stringify annidato

Chiamare JSON.stringify() su un oggetto che contiene già una stringa JSON pre-serializzata come valore produce output a doppia codifica — nel JSON compare il letterale di stringa anziché l'oggetto che rappresenta:

const inner = JSON.stringify({ id: 1 }); // '{"id":1}'
const outer = JSON.stringify({ data: inner });
// '{"data":"{\"id\":1}"}' — il campo data è una stringa, non un oggetto

// Se la stringa esterna viene poi JSON.parse() e data va riusato come JSON,
// devi fare JSON.parse(result.data) una seconda volta.

Come correggere l'errore [object Object] JSON

Il fix è sempre lo stesso: assicurati che l'oggetto sia serializzato con JSON.stringify() prima di essere usato come stringa o trasmesso in rete. Diagnosi rapida: cerca nel codice ogni punto in cui la variabile incriminata è usata come stringa e aggiungi JSON.stringify() in quel punto.

// Pattern di correzione sistematico
function toJsonBody(obj) {
  if (typeof obj === 'string') {
    // Già stringa — valida che sia JSON valido prima di usarla
    JSON.parse(obj); // solleva se non valido
    return obj;
  }
  return JSON.stringify(obj);
}

«Expected a JSON Object, Array or Literal» — cosa significa

Questo errore viene dal visualizzatore JSON integrato di Firefox (e da alcuni validatori JSON) e significa che il valore di livello più alto nel tuo JSON non è nessuno dei sei tipi JSON validi. Cause comuni:

  • L'input è una stringa vuota.JSON.parse("") solleva questo errore perché una stringa vuota non è un valore JSON valido.
  • L'input è undefined. JSON.stringify(undefined) restituisce undefined (non la stringa "undefined"), e JSON.parse(undefined) solleva.
  • La risposta è HTML, non JSON. Una pagina di errore del server spesso restituisce HTML. Il primo carattere < non è JSON valido. Controlla l'header Content-Type e il corpo grezzo della risposta nella scheda Network prima di dare per scontato che il JSON stesso sia rotto.
  • C'è un BOM all'inizio del file. Un BOM UTF-8 (byte 0xEF 0xBB 0xBF) anteposto a un file JSON causa questo errore nei parser stretti. RFC 8259 vieta esplicitamente i BOM nel JSON.
// Proteggi contro vuoto / undefined prima del parsing
function safeParse(text) {
  if (!text || typeof text !== 'string') {
    throw new TypeError(`Cannot parse ${typeof text} as JSON`);
  }
  return JSON.parse(text.trimStart()); // trimStart rimuove BOM/spazi accidentali
}

Virgola JSON dopo l'ultimo elemento: l'errore della virgola finale

Un altro errore di sintassi JSON estremamente comune è una virgola finale — una virgola che compare dopo l'ultimo elemento di un oggetto o di un array:

// ❌ Virgola finale in un oggetto
{
  "name": "Alice",
  "age": 30,
}

// ❌ Virgola finale in un array
["red", "green", "blue",]

La grammatica di JSON impone che una virgola separi due elementi — deve sempre avere un valore su entrambi i lati. Una virgola senza nulla dopo viola la grammatica. JavaScript stesso permette le virgole finali (dall'ES5), motivo per cui gli sviluppatori spesso le scrivono senza pensarci.

Per trovare e correggere le virgole finali programmaticamente:

// ⚠️ Fix con regex — va per i casi semplici, può corrompere stringhe
const fixed = raw.replace(/,\s*([}\]])/g, '$1');

// ✅ Meglio: usa un parser di riparazione che capisca la grammatica
// es. la libreria json-repair su npm

Per un approfondimento su questo errore specifico, vedi Virgola finale in JSON: perché solleva e come correggere.

Come correggere la sintassi JSON: checklist completa

Prima di ricorrere a uno strumento di correzione JSON, scorri questa checklist per identificare la classe dell'errore:

Struttura

  • Ogni { ha una } corrispondente e ogni [ ha una ] corrispondente. Parentesi non chiuse sono fra gli errori di troncamento più comuni.
  • Nessuna virgola finale — niente virgola dopo l'ultima coppia chiave-valore in un oggetto o l'ultimo elemento di un array.
  • Nessuna virgola mancante — ogni elemento in un oggetto o array (tranne l'ultimo) deve essere seguito da una virgola.

Stringhe

  • Tutte le stringhe usano apici doppi. Stringhe con apici singoli ('Alice') sono sintassi JavaScript, non JSON.
  • Tutte le chiavi degli oggetti sono stringhe tra apici doppi. Chiavi nude ({ name: "Alice" }) sono sintassi di oggetto letterale JavaScript, non JSON.
  • I caratteri di controllo dentro le stringhe vanno escapati. Newline, tab e byte null grezzi dentro una stringa JSON sono illegali — usa \n, \t, \u0000 al loro posto.

Valori

  • I booleani sono minuscoli:true / false, non True / False / TRUE.
  • Null è minuscolo:null, non None, nil, o NULL.
  • Niente undefined. JSON non ha un tipo undefined; usa null o ometti del tutto la chiave.
  • Niente NaN o Infinity. Questi valori JavaScript non hanno rappresentazione JSON. JSON.stringify({x: Infinity}) produce {"x":null} in silenzio.

Contenuto extra

  • Nessun commento.// commenti di riga e /* commenti di blocco */ non fanno parte della specifica JSON.
  • Nessun contenuto dopo. Un testo JSON valido è esattamente un valore — niente prima (a parte spazi opzionali) e niente dopo.

Usare un correttore JSON: quando automatizzare

Per debug una tantum, correggere JSON a mano è veloce. Per pipeline di produzione che ricevono JSON da fonti esterne — API, output di modelli IA, input utente — serve un correttore JSON: codice o strumento che ripari programmaticamente gli errori comuni di sintassi senza rompere il contenuto valido.

Un buon correttore JSON gestisce:

  • Virgole finali in oggetti e array
  • Stringhe con apici singoli → stringhe con apici doppi
  • Chiavi senza apici → chiavi con apici doppi
  • Letterali Python (True, False, None) → equivalenti JSON
  • Commenti JavaScript // riga e /* blocco */ → rimossi
  • Recinti di codice Markdown (```json ... ```) → rimossi
  • Parentesi non chiuse → chiuse automaticamente

Il requisito chiave è che le correzioni siano consapevoli della grammatica — lo strumento sa quali token sono separatori strutturali e quali stanno dentro valori stringa, così non corrompe mai contenuto stringa che per caso contiene ,} o True.

Per una guida passo passo all'implementazione della riparazione JSON in codice JavaScript, vedi Come gestire JSON rotto in JavaScript.

Evitare le trappole di JSON.stringify (riferimenti circolari inclusi)

Una volta che inizi a serializzare sempre con JSON.stringify, restano due situazioni che fanno inciampare la gente:

  • I riferimenti circolari sollevano. Un valore come const a = {}; a.self = a; dà TypeError: Converting circular structure to JSON. Tre buone alternative: scartare il back-reference con un replacer personalizzato che traccia gli oggetti già visti; passare a structuredClone(value) per copie profonde in-memory; o usare una libreria come flatted quando ti serve davvero serializzare un grafo ciclico e ricostruirlo dopo.
  • Tipi con perdita.JSON.stringify scarta in silenzio undefined, funzioni e valori Symbol, e converte NaN / Infinity in null. Convertili in qualcosa di rappresentabile prima dello stringify, non dopo il parsing.

Riferimento rapido: errori JSON comuni e correzioni

// 1. [object Object] — oggetto forzato a stringa
❌ fetch(url, { body: myObject })
✅ fetch(url, { body: JSON.stringify(myObject) })

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

// 3. Apici singoli
❌ { 'name': 'Alice' }
✅ { "name": "Alice" }

// 4. Chiave senza apici
❌ { name: "Alice" }
✅ { "name": "Alice" }

// 5. Booleano Python
❌ { "active": True }
✅ { "active": true }

// 6. Commento nel JSON
❌ { "debug": true // log everything }
✅ { "debug": true }

// 7. Stringa vuota
❌ JSON.parse("")
✅ JSON.parse(text || "null")

// 8. Pagina di errore HTML come «JSON»
❌ JSON.parse("<!DOCTYPE html>...")
✅ Controlla response.ok e Content-Type prima di chiamare response.json()

Domande frequenti

Cosa significa «[object Object] is not valid JSON»?

Un oggetto JavaScript è stato convertito in stringa con il suo .toString() predefinito, producendo il testo letterale [object Object], e quel testo è poi stato parsato o inviato come JSON. Il fix è serializzare con JSON.stringify() prima di usare il valore come stringa.

Come correggo l'errore [object Object] in una richiesta fetch?

Imposta body: JSON.stringify(payload) e aggiungi un header Content-Type: application/json. Passare un oggetto grezzo come body lo forza a [object Object].

Cos'è «Expected a JSON object, array or literal»?

Firefox e alcuni validatori lo stampano quando il valore di livello più alto non è uno dei sei tipi JSON — di solito perché l'input è vuoto, è undefined, è HTML invece di JSON, o inizia con un BOM. Controlla prima response.ok e l'header Content-Type.

Quali sono gli errori di sintassi JSON più comuni?

Virgole finali, apici singoli, chiavi senza apici, letterali Python (True/None), commenti e NaN/Infinity. Ciascuno ha una guida dedicata: vedi virgole finali, errori unexpected-token, unexpected end of input e caratteri di controllo non validi.

Correggi la sintassi JSON online — senza installazioni

Se hai una stringa JSON rotta da correggere subito, JSON Fix ripara automaticamente tutti gli errori sopra. Incolla il tuo JSON — per quanto rotto sia — clicca Repair & Format e ottieni un JSON sintatticamente corretto e formattato. Lo strumento gira interamente nel tuo browser: nessun dato viene inviato a un server, il che lo rende sicuro per payload sensibili.