← Todos os artigos
Atualizado em May 29, 20269 min read

Corrija «[object Object] is Not Valid JSON» e outros erros de sintaxe JSON

Recebendo «[object Object] is not valid JSON» ou «expected a JSON object, array or literal»? Aprenda por que esses erros acontecem, como corrigir a sintaxe JSON, consertar vírgulas finais e reparar JSON quebrado automaticamente.

Você roda seu código, abre a aba Network e vê isto: "[object Object]" is not valid JSON. Ou talvez seu validador JSON diga Expected a JSON object, array or literal, ou seu parser engasga numa vírgula depois do último elemento. Esses erros estão entre os erros JSON mais comuns — e mais confusos — que devs enfrentam. Este guia explica exatamente o que cada erro significa, por que acontece e como corrigir a sintaxe JSON para o seu parser aceitar.

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

Quando o JavaScript converte um objeto para string sem usar JSON.stringify(), o resultado é o texto [object Object] — a saída padrão do método .toString() de qualquer objeto. Se essa string for então passada para JSON.parse() ou enviada como corpo de requisição, você ganha o erro:

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

O parser está tentando parsear o texto literal [object Object]. Ele vê [, espera um array JSON, encontra a palavra sem aspas object e falha. O colchete é real — é o primeiro caractere da string [object Object] — mas o que vem depois não é sintaxe válida de array JSON.

Por que [object Object] aparece no JSON?

A causa raiz é sempre a mesma: um objeto JavaScript foi coagido a string em algum ponto do código antes de ser parseado ou transmitido. Estas são as quatro formas mais comuns de isso acontecer:

Concatenação de strings

Ao concatenar um objeto com uma string, o JavaScript chama .toString() no objeto, que devolve [object Object]:

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

// ❌ Concatenação coage o objeto
const body = "data=" + user;
console.log(body); // "data=[object Object]"

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

Body de fetch / XMLHttpRequest sem JSON.stringify

Passar um objeto comum como body de uma chamada fetch o converte em string automaticamente:

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

// ❌ fetch coage o objeto para "[object Object]"
fetch('/api/login', {
  method: 'POST',
  body: payload,
});

// ✅ Serialize antes, defina o Content-Type
fetch('/api/login', {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify(payload),
});

Template literals

Embutir um objeto direto num template literal chama .toString():

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

// ❌ Coerção em template literal
const json = `{"config": ${config}}`;
// '{"config": [object Object]}'  ← JSON inválido

// ✅ Stringifique apenas o objeto
const json = `{"config": ${JSON.stringify(config)}}`;
// '{"config": {"theme":"dark","lang":"en"}}'

Stringify aninhado

Chamar JSON.stringify() em um objeto que já contém como valor uma string JSON pré-serializada produz saída codificada em duplo — o literal de string aparece dentro do JSON em vez do objeto que ele representa:

const inner = JSON.stringify({ id: 1 }); // '{"id":1}'
const outer = JSON.stringify({ data: inner });
// '{"data":"{\"id\":1}"}' — o campo data é uma string, não um objeto

// Se essa string externa for depois JSON.parse()'d e data for usado como JSON,
// é preciso JSON.parse(result.data) uma segunda vez.

Como corrigir o erro [object Object] de JSON

A correção é sempre garantir que o objeto seja serializado com JSON.stringify() antes de ser usado como string ou transmitido pela rede. Diagnóstico rápido: procure no código todo lugar em que a variável afetada é usada como string e adicione JSON.stringify() naquele ponto.

// Padrão sistemático de correção
function toJsonBody(obj) {
  if (typeof obj === 'string') {
    // Já é string — valide se é JSON válido antes de usar
    JSON.parse(obj); // lança se inválido
    return obj;
  }
  return JSON.stringify(obj);
}

«Expected a JSON Object, Array or Literal» — o que isto significa

Esse erro vem do visualizador JSON embutido do Firefox (e de alguns validadores JSON) e significa que o valor de nível superior do seu JSON não é nenhum dos seis tipos JSON válidos. Causas comuns:

  • A entrada é uma string vazia.JSON.parse("") lança esse erro porque string vazia não é valor JSON válido.
  • A entrada é undefined. JSON.stringify(undefined) devolve undefined (não a string "undefined"), e JSON.parse(undefined) lança.
  • A resposta é HTML, não JSON. Uma página de erro do servidor costuma devolver HTML. O primeiro caractere < não é JSON válido. Cheque o Content-Type e o corpo bruto na aba Network antes de supor que o JSON está quebrado.
  • Há um BOM no início do arquivo. Um BOM UTF-8 (bytes 0xEF 0xBB 0xBF) na frente de um arquivo JSON causa esse erro em parsers estritos. RFC 8259 proíbe explicitamente BOMs em JSON.
// Proteja contra vazio / undefined antes de parsear
function safeParse(text) {
  if (!text || typeof text !== 'string') {
    throw new TypeError(`Cannot parse ${typeof text} as JSON`);
  }
  return JSON.parse(text.trimStart()); // trimStart remove BOM/espaços acidentais
}

Vírgula JSON após o último elemento: o erro de vírgula final

Outro erro de sintaxe JSON extremamente comum é uma vírgula final — uma vírgula que aparece depois do último item de um objeto ou array:

// ❌ Vírgula final em objeto
{
  "name": "Alice",
  "age": 30,
}

// ❌ Vírgula final em array
["red", "green", "blue",]

A gramática do JSON exige que uma vírgula separe dois itens — ela sempre precisa ter um valor de cada lado. Uma vírgula sem nada depois viola a gramática. O JavaScript em si permite vírgulas finais (desde ES5), e por isso devs escrevem sem pensar.

Para achar e corrigir vírgulas finais programaticamente:

// ⚠️ Correção por regex — funciona em casos simples, pode corromper strings
const fixed = raw.replace(/,\s*([}\]])/g, '$1');

// ✅ Melhor: use um parser de reparo que entenda a gramática
// por ex. a lib json-repair no npm

Para um mergulho profundo nesse erro específico, veja Vírgula final em JSON: por que lança e como corrigir.

Como corrigir sintaxe JSON: checklist completo

Antes de partir para uma ferramenta de correção de JSON, passe por este checklist para identificar a classe do erro:

Estrutura

  • Todo { tem um } correspondente e todo [ tem um ] correspondente. Colchetes não fechados são um dos erros de truncamento mais comuns.
  • Sem vírgulas finais — sem vírgula depois do último par chave–valor de um objeto ou do último item de um array.
  • Sem vírgulas faltando — cada item em um objeto ou array (menos o último) precisa ser seguido por uma vírgula.

Strings

  • Todas as strings usam aspas duplas. Strings com aspas simples ('Alice') são sintaxe de JavaScript, não JSON.
  • Todas as chaves de objeto são strings entre aspas duplas. Chaves sem aspas ({ name: "Alice" }) são sintaxe de objeto literal JavaScript, não JSON.
  • Caracteres de controle dentro de strings são escapados. Quebras de linha, tabulações e bytes nulos crus dentro de uma string JSON são ilegais — use \n, \t, \u0000 no lugar.

Valores

  • Booleanos em minúsculas:true / false, não True / False / TRUE.
  • Null em minúsculas:null, não None, nil, ou NULL.
  • Nada de undefined. JSON não tem tipo undefined; use null ou omita a chave de vez.
  • Nada de NaN ou Infinity. Esses valores JavaScript não têm representação JSON. JSON.stringify({x: Infinity}) produz {"x":null} em silêncio.

Conteúdo extra

  • Sem comentários.// comentários de linha e /* comentários de bloco */ não fazem parte da especificação JSON.
  • Sem conteúdo após. Um texto JSON válido é exatamente um valor — nada antes (a não ser espaço opcional) e nada depois.

Usando um corretor de JSON: quando automatizar

Para debug pontual, consertar JSON na mão é rápido. Para pipelines de produção que recebem JSON de fontes externas — APIs, saída de modelos de IA, input de usuário — você precisa de um corretor de JSON: código ou ferramenta que repara erros comuns de sintaxe programaticamente sem quebrar o conteúdo válido.

Um bom corretor de JSON cuida de:

  • Vírgulas finais em objetos e arrays
  • Strings com aspas simples → strings com aspas duplas
  • Chaves sem aspas → chaves com aspas duplas
  • Literais Python (True, False, None) → equivalentes JSON
  • Comentários JavaScript // linha e /* bloco */ → removidos
  • Cercas de código Markdown (```json ... ```) → removidas
  • Colchetes não fechados → fechados automaticamente

A exigência-chave é que as correções sejam conscientes da gramática — a ferramenta entende quais tokens são separadores estruturais e quais estão dentro de valores string, de modo que nunca corrompe conteúdo de string que por acaso contenha ,} ou True.

Para um passo a passo de como implementar reparo de JSON em código JavaScript, veja Como lidar com JSON quebrado em JavaScript.

Evitando armadilhas do JSON.stringify (incluindo referências circulares)

Depois que você passa a sempre serializar com JSON.stringify, duas situações ainda derrubam quem não está atento:

  • Referências circulares lançam. Um valor como const a = {}; a.self = a; dá TypeError: Converting circular structure to JSON. Três boas alternativas: descartar a referência reversa com um replacer custom que rastreia objetos vistos; trocar para structuredClone(value) para deep copies em memória; ou usar uma lib como flatted quando você precisa mesmo serializar um grafo cíclico e reconstruí-lo depois.
  • Tipos com perda.JSON.stringify descarta silenciosamente undefined, funções e valores Symbol, e converte NaN / Infinity em null. Converta esses caras em algo representável antes do stringify, não depois do parse.

Referência rápida: erros JSON comuns e correções

// 1. [object Object] — objeto coagido a string
❌ fetch(url, { body: myObject })
✅ fetch(url, { body: JSON.stringify(myObject) })

// 2. Vírgula final
❌ { "a": 1, "b": 2, }
✅ { "a": 1, "b": 2 }

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

// 4. Chave sem aspas
❌ { name: "Alice" }
✅ { "name": "Alice" }

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

// 6. Comentário no JSON
❌ { "debug": true // log everything }
✅ { "debug": true }

// 7. String vazia
❌ JSON.parse("")
✅ JSON.parse(text || "null")

// 8. Página de erro HTML como «JSON»
❌ JSON.parse("<!DOCTYPE html>...")
✅ Cheque response.ok e Content-Type antes de chamar response.json()

Perguntas frequentes

O que «[object Object] is not valid JSON» quer dizer?

Um objeto JavaScript foi convertido em string com o .toString() padrão, produzindo o texto literal [object Object], e esse texto foi então parseado ou enviado como JSON. A correção é serializar com JSON.stringify() antes de usar o valor como string.

Como corrijo o erro [object Object] numa requisição fetch?

Configure body: JSON.stringify(payload) e adicione um cabeçalho Content-Type: application/json. Passar um objeto cru como body o coage a [object Object].

O que é «Expected a JSON object, array or literal»?

Firefox e alguns validadores imprimem isso quando o valor de nível superior não é um dos seis tipos JSON — normalmente porque a entrada está vazia, é undefined, é HTML em vez de JSON, ou começa com BOM. Cheque primeiro response.ok e o cabeçalho Content-Type.

Quais são os erros de sintaxe JSON mais comuns?

Vírgulas finais, aspas simples, chaves sem aspas, literais Python (True/None), comentários e NaN/Infinity. Cada um tem um guia dedicado: veja vírgulas finais, erros de unexpected-token, unexpected end of input e caracteres de controle inválidos.

Corrija sintaxe JSON online — sem instalação

Se você tem uma string JSON quebrada que precisa corrigir agora, JSON Fix repara automaticamente todos os erros acima. Cole seu JSON — por mais quebrado que esteja — clique em Repair & Format, e receba de volta JSON sintaticamente correto e formatado. A ferramenta roda inteira no seu navegador: nenhum dado é enviado a servidor, o que a torna segura para payloads sensíveis.