← Todos los artículos
Actualizado el May 29, 20269 min read

Arregla «[object Object] is Not Valid JSON» y otros errores de sintaxis JSON

¿Te aparece «[object Object] is not valid JSON» o «expected a JSON object, array or literal»? Aprende por qué ocurren estos errores, cómo corregir la sintaxis JSON, arreglar comas finales y reparar JSON roto automáticamente.

Ejecutas tu código, revisas la pestaña Network y lo ves: "[object Object]" is not valid JSON. O quizá tu validador JSON dice Expected a JSON object, array or literal, o tu parser se atraganta con una coma después del último elemento. Estos errores están entre los fallos JSON más comunes — y más confusos — que encuentran los desarrolladores. Esta guía explica con exactitud qué significa cada error, por qué ocurre y cómo corregir la sintaxis JSON para que tu parser la acepte.

¿Qué significa «[object Object] is not valid JSON»?

Cuando JavaScript convierte un objeto en cadena sin usar JSON.stringify(), el resultado es el texto [object Object] — la salida por defecto del método .toString() de cualquier objeto. Si esa cadena luego se pasa a JSON.parse() o se envía como cuerpo de petición, obtienes el error:

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

El parser está intentando parsear el texto literal [object Object]. Ve un [, espera un array JSON, encuentra la palabra sin comillas object y falla. El corchete es real — es el primer carácter de la cadena [object Object] — pero lo que sigue no es sintaxis válida de array JSON.

¿Por qué aparece [object Object] en el JSON?

La causa raíz siempre es la misma: un objeto JavaScript fue coercido a cadena en algún punto del código antes de ser parseado o transmitido. Estas son las cuatro formas más comunes en que ocurre:

Concatenación de cadenas

Cuando concatenas un objeto con una cadena, JavaScript llama a .toString() sobre el objeto, que devuelve [object Object]:

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

// ❌ La concatenación coerce el objeto
const body = "data=" + user;
console.log(body); // "data=[object Object]"

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

Body de fetch / XMLHttpRequest sin JSON.stringify

Pasar un objeto plano como body de una llamada fetch lo convierte en cadena automáticamente:

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

// ❌ fetch coerce el objeto a "[object Object]"
fetch('/api/login', {
  method: 'POST',
  body: payload,
});

// ✅ Serializa primero, fija el Content-Type
fetch('/api/login', {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify(payload),
});

Plantillas literales

Incrustar un objeto directamente en una plantilla literal llama a .toString():

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

// ❌ Coerción por plantilla literal
const json = `{"config": ${config}}`;
// '{"config": [object Object]}'  ← JSON inválido

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

Stringify anidado

Llamar a JSON.stringify() sobre un objeto que ya contiene como valor una cadena JSON previamente serializada produce una salida doblemente codificada — en el JSON aparece el literal de cadena en lugar del objeto que representa:

const inner = JSON.stringify({ id: 1 }); // '{"id":1}'
const outer = JSON.stringify({ data: inner });
// '{"data":"{\"id\":1}"}' — el campo data es una cadena, no un objeto

// Si luego haces JSON.parse() de esa cadena externa y vuelves a usar data
// como JSON, tienes que hacer JSON.parse(result.data) una segunda vez.

Cómo arreglar el error [object Object] de JSON

La solución es siempre asegurarse de que el objeto se serializa con JSON.stringify() antes de usarlo como cadena o de transmitirlo por la red. Un diagnóstico rápido: busca en tu código cada lugar donde se usa la variable afectada como cadena y añade JSON.stringify() en ese punto.

// Patrón sistemático de arreglo
function toJsonBody(obj) {
  if (typeof obj === 'string') {
    // Ya es cadena — valida que sea JSON válido antes de usar
    JSON.parse(obj); // lanza si no es válido
    return obj;
  }
  return JSON.stringify(obj);
}

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

Este error viene del visor JSON integrado de Firefox (y de algunos validadores) y significa que el valor de nivel superior de tu JSON no es ninguno de los seis tipos JSON válidos. Causas habituales:

  • La entrada es una cadena vacía.JSON.parse("") lanza este error porque una cadena vacía no es un valor JSON válido.
  • La entrada es undefined. JSON.stringify(undefined) devuelve undefined (no la cadena "undefined"), y JSON.parse(undefined) lanza.
  • La respuesta es HTML, no JSON. Una página de error del servidor suele devolver HTML. El primer carácter < no es JSON válido. Revisa el Content-Type y el cuerpo crudo de la respuesta en la pestaña Network antes de dar por hecho que el JSON está roto.
  • Hay un BOM al inicio del archivo. Un BOM UTF-8 (bytes 0xEF 0xBB 0xBF) al inicio de un archivo JSON provoca este error en parsers estrictos. RFC 8259 prohíbe explícitamente los BOM en JSON.
// Protege contra vacío / 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 elimina BOM/espacios accidentales
}

Coma JSON tras el último elemento: el error de coma final

Otro error de sintaxis JSON muy común es una coma final — una coma que aparece después del último elemento de un objeto o array:

// ❌ Coma final en objeto
{
  "name": "Alice",
  "age": 30,
}

// ❌ Coma final en array
["red", "green", "blue",]

La gramática JSON exige que una coma separe dos elementos — siempre debe tener un valor a cada lado. Una coma sin nada después incumple la gramática. JavaScript en sí permite las comas finales (desde ES5), por lo que los desarrolladores las escriben sin pensar.

Para encontrar y arreglar las comas finales de forma programática:

// ⚠️ Arreglo con regex — funciona en casos simples, puede corromper cadenas
const fixed = raw.replace(/,\s*([}\]])/g, '$1');

// ✅ Mejor: usa un parser de reparación que entienda la gramática
// p. ej. la librería json-repair en npm

Para profundizar en este error en concreto, ve Coma final en JSON: por qué lanza y cómo arreglarlo.

Cómo corregir la sintaxis JSON: lista completa

Antes de echar mano de una herramienta de corrección de JSON, repasa esta lista para identificar la clase de error:

Estructura

  • Cada { tiene su pareja } y cada [ tiene su pareja ]. Los corchetes sin cerrar son uno de los errores de truncado más habituales.
  • Sin comas finales — sin coma tras el último par clave–valor de un objeto o el último elemento de un array.
  • Sin comas faltantes — cada elemento de un objeto o array (salvo el último) debe ir seguido de una coma.

Cadenas

  • Todas las cadenas usan comillas dobles. Las cadenas con comilla simple ('Alice') son sintaxis de JavaScript, no de JSON.
  • Todas las claves de objeto son cadenas entre comillas dobles. Las claves desnudas ({ name: "Alice" }) son sintaxis de objeto literal de JavaScript, no de JSON.
  • Los caracteres de control dentro de cadenas se escapan. Saltos de línea, tabuladores y bytes nulos crudos dentro de una cadena JSON son ilegales — usa \n, \t, \u0000 en su lugar.

Valores

  • Booleans en minúscula:true / false, no True / False / TRUE.
  • Null en minúscula:null, no None, nil o NULL.
  • Nada de undefined. JSON no tiene tipo undefined; usa null u omite la clave por completo.
  • Nada de NaN o Infinity. Estos valores de JavaScript no tienen representación JSON. JSON.stringify({x: Infinity}) produce {"x":null} en silencio.

Contenido extra

  • Sin comentarios.// comentarios de línea y /* comentarios de bloque */ no forman parte de la especificación JSON.
  • Sin contenido residual. Un texto JSON válido es exactamente un valor — nada antes (excepto espacio en blanco opcional) y nada después.

Usar un corrector de JSON: cuándo automatizar

Para depurar un caso puntual, arreglar JSON a mano es rápido. Para pipelines de producción que reciben JSON de fuentes externas — APIs, salidas de modelos de IA, entrada de usuario — necesitas un corrector de JSON: código o herramienta que repare programáticamente los errores comunes de sintaxis sin romper el contenido válido.

Un buen corrector de JSON maneja:

  • Comas finales en objetos y arrays
  • Cadenas con comilla simple → cadenas con comilla doble
  • Claves sin comillas → claves con comillas dobles
  • Literales de Python (True, False, None) → equivalentes JSON
  • Comentarios de JavaScript // línea y /* bloque */ → eliminados
  • Cercas de código Markdown (```json ... ```) → eliminadas
  • Corchetes sin cerrar → auto-cerrados

El requisito clave es que las correcciones sean conscientes de la gramática — la herramienta entiende qué tokens son separadores estructurales y cuáles están dentro de valores de cadena, de modo que nunca corrompe contenido de cadena que casualmente contenga ,} o True.

Para un recorrido de cómo implementar la reparación de JSON en código JavaScript, ve Cómo manejar JSON roto en JavaScript.

Evitar las trampas de JSON.stringify (incluidas las referencias circulares)

Una vez te acostumbras a serializar siempre con JSON.stringify, dos situaciones siguen pillando a la gente:

  • Las referencias circulares lanzan. Un valor como const a = {}; a.self = a; da TypeError: Converting circular structure to JSON. Tres buenas alternativas: tirar la referencia de vuelta con un replacer personalizado que rastree objetos vistos; cambiar a structuredClone(value) para copias profundas en memoria; o usar una librería como flatted cuando realmente necesitas serializar un grafo cíclico y reconstruirlo después.
  • Tipos con pérdida.JSON.stringify descarta en silencio undefined, funciones y valores Symbol, y convierte NaN / Infinity a null. Conviértelos en algo representable antes de stringify, no después de parsear.

Referencia rápida: errores JSON comunes y arreglos

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

// 2. Coma final
❌ { "a": 1, "b": 2, }
✅ { "a": 1, "b": 2 }

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

// 4. Clave sin comillas
❌ { name: "Alice" }
✅ { "name": "Alice" }

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

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

// 7. Cadena vacía
❌ JSON.parse("")
✅ JSON.parse(text || "null")

// 8. Página de error HTML como «JSON»
❌ JSON.parse("<!DOCTYPE html>...")
✅ Comprueba response.ok y Content-Type antes de llamar a response.json()

Preguntas frecuentes

¿Qué significa «[object Object] is not valid JSON»?

Un objeto JavaScript se convirtió en cadena con su .toString() por defecto, produciendo el texto literal [object Object], y ese texto se parseó o se envió luego como JSON. La solución es serializar con JSON.stringify() antes de usar el valor como cadena.

¿Cómo arreglo el error [object Object] en una petición fetch?

Pon body: JSON.stringify(payload) y añade una cabecera Content-Type: application/json. Pasar un objeto crudo como body lo coerce a [object Object].

¿Qué es «Expected a JSON object, array or literal»?

Firefox y algunos validadores lo imprimen cuando el valor de nivel superior no es uno de los seis tipos JSON — normalmente porque la entrada está vacía, es undefined, es HTML en lugar de JSON, o empieza con un marcador de orden de bytes. Comprueba primero response.ok y la cabecera Content-Type.

¿Cuáles son los errores de sintaxis JSON más comunes?

Comas finales, comillas simples, claves sin comillas, literales de Python (True/None), comentarios y NaN/Infinity. Cada uno tiene su guía: ve comas finales, errores unexpected-token, unexpected end of input y caracteres de control inválidos.

Corrige sintaxis JSON online — sin instalación

Si tienes una cadena JSON rota que necesitas corregir ahora mismo, JSON Fix repara automáticamente todos los errores anteriores. Pega tu JSON — por roto que esté — pulsa Repair & Format y recibirás JSON sintácticamente correcto y formateado. La herramienta corre íntegramente en tu navegador: no se envía ningún dato a ningún servidor, así que es segura para payloads sensibles.