How to Fix Invalid JSON: Common Errors & Solutions

Por qué falla el análisis de JSON

JSON parece simple — y lo es — pero su rigidez es exactamente lo que confunde a las personas. A diferencia de los literales de objeto de JavaScript, JSON no tolera atajos de sintaxis. No se permiten comas finales. No se permiten comillas simples. No se permiten comentarios. Cada desviación produce un error de análisis, y los mensajes de error suelen ser poco útiles: Token inesperado o JSON.parse: se esperaba ',' o '}' en la línea 1.

Esta guía cubre los 10 errores más comunes de JSON que los desarrolladores encuentran en el mundo real. Cada uno incluye el JSON roto, por qué el analizador lo rechaza y la versión corregida. Guarda esta página en tus marcadores — volverás a ella.

Inténtalo tú mismo: Pega JSON roto en nuestra herramienta de Reparación de JSON para corregir automáticamente la mayoría de estos errores al instante.

Error 1: Coma final

Este es el error de JSON más común. JavaScript permite comas finales en objetos y arreglos, por lo que los desarrolladores naturalmente escriben JSON de la misma manera. Pero JSON no las permite.

Roto:

{
  "name": "Alice",
  "age": 30,
}

Corregido:

{
  "name": "Alice",
  "age": 30
}

La coma final después de 30 hace que el analizador espere otro par clave-valor. Cuando encuentra una llave de cierre en su lugar, arroja un error. Elimina la coma después del último elemento en cada objeto y arreglo.

Error 2: Comillas simples en lugar de comillas dobles

JSON requiere comillas dobles tanto para claves como para valores de cadena. Las comillas simples son una característica de JavaScript que el analizador de JSON rechaza de inmediato.

Roto:

{
  'name': 'Alice',
  'city': 'Portland'
}

Corregido:

{
  "name": "Alice",
  "city": "Portland"
}

Esto sucede con mayor frecuencia al copiar literales de objeto de código JavaScript o de diccionarios de Python (que también utilizan comillas simples). Un buscar y reemplazar de ' a " lo corrige, pero ten cuidado con las cadenas que contienen apóstrofes — esas necesitan ser escapadas.

Error 3: Claves sin comillas

JavaScript te permite escribir { name: "Alice" } sin citar la clave. JSON no. Cada clave debe ser una cadena entre comillas dobles.

Roto:

{
  name: "Alice",
  age: 30
}

Corregido:

{
  "name": "Alice",
  "age": 30
}

Esto suele surgir cuando alguien escribe JSON a mano o copia un objeto de JavaScript sin convertirlo. Algunos editores y herramientas de depuración de API mostrarán felizmente claves sin comillas, ocultando el problema hasta que intentes analizar el archivo en otro lugar.

Error 4: Comentarios en JSON

JSON no admite comentarios — ni // de una sola línea, ni /* */ de bloque. Esta es una de las limitaciones más frustrantes del formato, especialmente para archivos de configuración.

Roto:

{
  // Configuración de la base de datos
  "host": "localhost",
  "port": 5432 /* puerto predeterminado de PostgreSQL */
}

Corregido:

{
  "host": "localhost",
  "port": 5432
}

Si necesitas comentarios en archivos de configuración, considera usar JSONC (JSON con Comentarios), que VS Code y TypeScript admiten de forma nativa, o cambiar a YAML o TOML. Para JSON estándar, elimina todos los comentarios antes de analizar.

Error 5: Falta de coma entre elementos

Al agregar un nuevo campo a un objeto JSON, es fácil olvidar la coma que lo separa del campo anterior. El analizador ve dos valores consecutivos sin separador y se ahoga.

Roto:

{
  "name": "Alice"
  "age": 30
}

Corregido:

{
  "name": "Alice",
  "age": 30
}

El mensaje de error generalmente apunta a la línea después de la coma faltante, lo que puede ser engañoso. Si ves Cadena inesperada o Se esperaba una coma, mira la línea por encima de la posición reportada.

Error 6: Falta de corchete o llave de cierre

Los corchetes desajustados son difíciles de detectar en archivos JSON grandes. La falta de un ] o } hace que el analizador lea más allá del final previsto de una estructura, produciendo errores confusos lejos del problema real.

Roto:

{
  "users": [
    { "name": "Alice" },
    { "name": "Bob" }
}

Corregido:

{
  "users": [
    { "name": "Alice" },
    { "name": "Bob" }
  ]
}

La solución: usa un editor con coincidencia de corchetes (VS Code resalta los pares coincidentes) o un Validador de JSON que informe la ubicación exacta del desajuste.

Error 7: undefined, NaN o Infinity

Estos son valores válidos de JavaScript pero no tienen representación en JSON. JSON.stringify convierte silenciosamente undefined a null (o omite la clave por completo), pero si escribes manualmente estos valores, el analizador los rechaza.

Roto:

{
  "score": NaN,
  "callback": undefined,
  "limit": Infinity
}

Corregido:

{
  "score": null,
  "callback": null,
  "limit": null
}

Reemplaza undefined y NaN con null, o omite la clave por completo si la ausencia de un valor es semánticamente apropiada. Para Infinity, considera usar un número centinela o una representación de cadena como "Infinity" y manejarlo en tu código de aplicación.

Error 8: Coma extra después del último elemento del arreglo

Esta es la versión de arreglo del Error 1. Aparece constantemente en archivos JSON editados a mano, especialmente después de eliminar o reordenar elementos.

Roto:

{
  "colors": [
    "red",
    "green",
    "blue",
  ]
}

Corregido:

{
  "colors": [
    "red",
    "green",
    "blue"
  ]
}

El patrón es el mismo: la coma después de "blue" le dice al analizador que espere otro elemento. Encuentra ] en su lugar y reporta un error. Al eliminar elementos de un arreglo JSON, siempre verifica si el nuevo último elemento tiene una coma final.

Error 9: Comillas inteligentes (comillas rizadas)

Este es engañoso. Cuando copias JSON de un documento de Word, un mensaje de Slack o una publicación de blog, tu sistema puede reemplazar silenciosamente las comillas rectas (") por comillas tipográficas "inteligentes" (\u201C y \u201D). Se ven casi idénticas pero son caracteres completamente diferentes.

Roto:

{
  \u201Cname\u201D: \u201CAlice\u201D,
  \u201Ccity\u201D: \u201CPortland\u201D
}

Corregido:

{
  "name": "Alice",
  "city": "Portland"
}

El mensaje de error suele ser Token inesperado en la posición 1 o 2, lo que es desconcertante hasta que te das cuenta de que los caracteres de las comillas son incorrectos. La solución: reemplaza todas las comillas rizadas por comillas dobles rectas. En un apuro, vuelve a escribir las comillas manualmente en un editor de texto plano.

Para prevenir esto, siempre usa un editor de código (no un editor de texto enriquecido) para escribir JSON. Desactiva las "comillas inteligentes" en la configuración del teclado de tu sistema operativo si frecuentemente pegas entre aplicaciones.

Error 10: Caracteres BOM (Byte Order Mark)

Un BOM es un carácter invisible (U+FEFF) que algunos editores de texto de Windows insertan al principio de un archivo para indicar la codificación. Los analizadores de JSON lo ven como un carácter inesperado antes de la llave de apertura y fallan inmediatamente.

Síntomas:

SyntaxError: Token inesperado \uFEFF en JSON en la posición 0

No puedes ver el BOM en la mayoría de los editores — es verdaderamente invisible. Para detectarlo, abre el archivo en un editor hexadecimal y busca los bytes EF BB BF (BOM UTF-8) al principio.

Cómo solucionarlo:

• En VS Code, haz clic en el indicador de codificación en la barra de estado y elige "Guardar con codificación" → "UTF-8" (sin BOM).
• En la línea de comandos: sed -i '1s/^\xEF\xBB\xBF//' file.json
• En Node.js, elimínalo antes de analizar: const clean = text.replace(/^\\uFEFF/, "");

Referencia rápida: Todos los 10 errores

#	Error	Causa	Solución
1	Coma final	Coma después de la última propiedad/elemento	Eliminar la coma final
2	Comillas simples	Usó ' en lugar de "	Reemplazar con comillas dobles
3	Claves sin comillas	Claves sin comillas dobles	Envolver todas las claves en comillas dobles
4	Comentarios	// o /* */ en JSON	Eliminar todos los comentarios
5	Falta de coma	Sin coma entre elementos	Agregar coma entre elementos
6	Falta de corchete/llave	[ o { sin cerrar	Agregar el carácter de cierre faltante
7	undefined / NaN / Infinity	Valores solo de JS en JSON	Reemplazar con null o una cadena
8	Coma extra en el arreglo	Coma final en el arreglo	Eliminar la coma final
9	Comillas inteligentes	Comillas rizadas de Word/Slack	Reemplazar con comillas dobles rectas
10	Carácter BOM	U+FEFF invisible al inicio del archivo	Reguardar como UTF-8 sin BOM

Prevención de errores de JSON

Corregir errores es bueno. No crear errores en primer lugar es mejor. Aquí están los hábitos que mantienen JSON limpio:

• Nunca escribas JSON a mano. Genera desde el código usando JSON.stringify o el equivalente de tu lenguaje. Los serializadores producen JSON válido por definición.
• Usa un editor consciente de JSON. VS Code, IDEs de JetBrains y Sublime Text resaltan errores de sintaxis de JSON en tiempo real. Si ves un subrayado rojo, corrígelo antes de guardar.
• Valida en CI. Agrega un paso de validación a tu pipeline de construcción que analice todos los archivos JSON y falle en caso de errores. Una sola línea de script de shell lo hace: find . -name "*.json" -exec python -m json.tool {} \\;
• Usa JSONC para configuración. Si necesitas comentarios, usa JSONC (extensión .jsonc) donde sea compatible. TypeScript, VS Code y muchas otras herramientas lo manejan de forma nativa.

Cuándo usar reparación automatizada

A veces el JSON que recibes está fuera de tu control — una respuesta de API de un servicio mal construido, un archivo exportado por software legado, o un fragmento pegado por un miembro de un equipo no técnico. En estos casos, la reparación manual es tediosa y propensa a errores.

Las herramientas de reparación automatizada pueden corregir la mayoría de los errores listados arriba en un solo intento. Analizan la entrada rota, inferen la estructura pretendida y producen JSON válido. Esto funciona bien para problemas comunes como comas finales, comillas simples y claves sin comillas.

La desventaja es que la reparación automatizada hace suposiciones. Si el JSON está mal formado — faltando grandes secciones o estructuralmente ambiguo — la herramienta podría adivinar incorrectamente. Siempre valida la salida reparada antes de usarla en producción.

Inténtalo tú mismo: Pega JSON roto en nuestra herramienta de Reparación de JSON para corregir automáticamente errores comunes, o usa el Validador de JSON para identificar exactamente dónde está el problema.