¿Por qué JSON.parse dice "Unexpected token"?

Esto es diagnóstico de Unexpected token en JSON.parse: qué significa el error, cómo leer la posición y qué hacer cuando el cuerpo es HTML. Las comas finales, las comillas y Unexpected end se cubren con más amplitud en Errores JSON habituales: comas finales, comillas y Unexpected token.

¿Qué significa “Unexpected token” en JSON.parse()?

JSON.parse() exige la gramática JSON. Un carácter ilegal en la posición actual lanza SyntaxError. {“name”:“Alex”,} es inválido: tras esa coma el objeto no puede terminar. El texto del mensaje y la posición siguen variando según el runtime.

¿Qué error lanza JSON.parse()?

El JSON inválido suele lanzar SyntaxError. Registra error.name para confirmar el tipo. No dejes fijo el error.message completo: motores y versiones lo redactan de forma distinta.

try {
  JSON.parse('{"name":"Alex",}');
} catch (error) {
  console.log(error.name);
  // SyntaxError
}

1. Usar comillas simples en lugar de dobles

{‘name’:‘Alex’} es JSON inválido. {“name”:“Alex”} es válido. Las cadenas JSON y los nombres de miembro de objeto usan comillas dobles. Un literal de objeto JavaScript como const user = { name: ‘Alex’ } puede ser JavaScript legal y aun así no ser texto JSON.

Inválido

{'name':'Alex'}

Válido

{"name":"Alex"}

2. Comas finales

Una coma después de la última propiedad o del último elemento de array no es JSON estándar válido. {“name”:“Alex”,“age”:30,} y [1, 2, 3,] fallan. Trátalo como una causa de Unexpected token; Errores JSON habituales: comas finales, comillas y Unexpected token cubre las comas finales con más detalle.

Inválido

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

Válido

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

[1, 2, 3,]

3. Nombres de propiedad sin comillas

{ name: “Alex” } puede ser un literal de objeto JavaScript. En JSON, los nombres de miembro son cadenas y necesitan comillas dobles: {“name”:“Alex”}.

Inválido

{
  name: "Alex"
}

Válido

{
  "name": "Alex"
}

4. Escape de cadena inválido

En el texto JSON una barra invertida inicia un escape. Una ruta cruda como C:\Users\Alex es inválida porque \U no es un escape legal. Duplica las barras invertidas. No mezcles el escape del lenguaje anfitrión con el escape JSON. Errores JSON habituales: comas finales, comillas y Unexpected token lo cubre con más detalle.

Inválido

{"file":"C:\Users\Alex"}

Válido

{"file":"C:\\Users\\Alex"}

5. Texto extra antes o después del JSON

JSON.parse espera un solo valor JSON. Un prefijo como Success: delante de {“ok”:true}, o un sufijo como done detrás, deja inválida toda la cadena. El espacio en blanco insignificante alrededor de un único valor JSON sí está permitido. JSON no prohíbe espacios antes o después del valor.

Success:
{"ok":true}

{"ok":true}
done

6. Analizar HTML en lugar de JSON

Llamar a response.json() sobre una página HTML es un caso habitual de Unexpected token. Endpoints incorrectos, páginas HTML 404 o 500, redirecciones de login, cuerpos de proxy y páginas de respaldo suelen empezar con marcado. «Unexpected token < siempre significa HTML» es demasiado fuerte: < es una pista, no una prueba.

fetch('/api/data')
  .then(response => response.json())

¿Qué suele significar “Unexpected token <”?

Los valores JSON no suelen empezar por <. Si el cuerpo comienza con o , < puede ser el primer carácter ilegal. En la depuración local, revisa el estado HTTP, Content-Type y el cuerpo en bruto. El redactado del motor sigue variando.

Revisa la respuesta antes de analizarla

El cuerpo de fetch solo se puede consumir una vez. En la depuración local, lee text() primero, inspecciona un prefijo corto y luego aplica JSON.parse a esa misma cadena. No llames a response.json() y después a response.text() sobre la misma respuesta. No registres por defecto cargas sensibles de producción.

const response = await fetch(url);
const text = await response.text();

console.log(response.status);
console.log(response.headers.get("content-type"));
console.log(text.slice(0, 200));

try {
  const data = JSON.parse(text);
  console.log(data);
} catch (error) {
  console.error("Invalid JSON:", error);
}

¿Qué significa “at position 123”?

Algunos motores informan una posición, línea o columna. Mira cerca una comilla, coma, llave o escape incorrectos. Ese índice es donde el análisis notó un problema; la causa real puede estar antes. No está garantizado que sea el carácter defectuoso exacto.

Unexpected token frente a Unexpected end

Unexpected token significa que el analizador encontró un carácter que no esperaba. Unexpected end puede aparecer cuando la entrada se detiene antes de completar el valor, como en {“name”:“Alex” sin llave de cierre. El redactado exacto depende del motor. Errores JSON habituales: comas finales, comillas y Unexpected token cubre el JSON incompleto con más amplitud.

{"name":"Alex"

JSON no es lo mismo que un literal de objeto JavaScript

JSON es un formato de datos. Un literal de objeto JavaScript es sintaxis JavaScript. El objeto JS con claves sin comillas, comillas simples y una coma final no es texto JSON válido. JSON.parse no puede analizar con seguridad literales de objeto JavaScript.

const data = {
  name: 'Alex',
  active: true,
};

{
  "name": "Alex",
  "active": true
}

¿Puede JSON contener comentarios?

El JSON estándar no admite comentarios. Una línea // dentro de un objeto es inválida. JSON5 y extensiones similares son formatos distintos. Formatear y comparar JSON valida JSON estándar con JSON.parse y no trata JSON5 como JSON.

{
  // user name
  "name": "Alex"
}

¿Son válidos en JSON undefined, NaN e Infinity?

No. Los valores JSON son objeto, array, cadena, número, true, false y null. undefined, NaN e Infinity no lo son. Un valor de nivel superior no tiene que ser un objeto o un array: true, 123, “hello” y null son JSON válido.

{"a":undefined}
{"a":NaN}
{"a":Infinity}

true
123
"hello"
null

Cómo corregir un error Unexpected token paso a paso

Trabaja la fuente, no la cadena del error:

1. Confirma que la entrada es realmente JSON, no HTML, registros o JavaScript.
2. Inspecciona los primeros caracteres de la entrada en bruto.
3. Si vino de una API, revisa el estado HTTP y Content-Type. Ni 200 ni application/json garantizan JSON válido.
4. Valida la sintaxis en un analizador JSON.
5. Usa cualquier posición, línea o columna indicada como pista, no como la causa raíz garantizada.
6. Revisa comillas, comas, llaves, corchetes y escapes cerca de esa zona.
7. Compara con una copia formateada y validada.
8. Corrige el serializador o el endpoint. No borres el token indicado al azar.

Usa JSON.stringify() al producir JSON en JavaScript

Prefiere JSON.stringify a concatenar cadenas a mano. Emite texto JSON válido para los valores que serializa. No conserva todos los valores JavaScript: undefined, las funciones y los símbolos tienen un comportamiento especial. Ese detalle queda fuera de alcance aquí.

const data = {
  name: "Alex",
  active: true
};
const json = JSON.stringify(data);
// {"name":"Alex","active":true}

JSON inválido frente a una corrección real

Estos pares se comprobaron con JSON.parse. Para HTML, la corrección es la respuesta, no un retoque de sintaxis.

Problema	Inválido	Corrección
Comillas simples	{'a':1}	{"a":1}
Coma final	{"a":1,}	{"a":1}
Clave sin comillas	{a:1}	{"a":1}
undefined	{"a":undefined}	{"a":null}
Cuerpo HTML	<html>...	Revisa el endpoint y la respuesta en bruto. No edites HTML para convertirlo en JSON.

Una guía simple de decisión para Unexpected token

Si JSON.parse falló, decide si siquiera tienes JSON antes de reescribir comillas.

• JSON.parse falló
• ↓
• ¿De una API? Revisa estado, Content-Type y el cuerpo en bruto
• ¿Empieza como JSON? Si no, corrige la fuente o el endpoint
• Si sí, valida comillas, comas, llaves, corchetes, escapes, valores no admitidos
• Usa la posición indicada como pista
• ↓
• Corrige la fuente y vuelve a analizar

Valida JSON antes de analizarlo o usarlo

NEXNARA Formatear y comparar JSON valida JSON en el navegador con JSON.parse—no eval.

Valida, formatea con 2 espacios, 4 espacios o tabuladores, minifica, copia, descarga y sube .json. JSON Diff cubre objetos y arrays anidados, rutas, resumen, filtros e intercambio. Tras el análisis, las copias formateada y minificada de los mismos datos se comparan como iguales; las claves de objeto se comparan por nombre.

El texto de más de 5 MB puede ir lento. El texto de más de 15 MB no se procesa en el navegador.

La validación y el formateo de JSON ocurren en tu navegador. Esta herramienta no envía el JSON a un servidor de NEXNARA. Los anuncios y otras funciones del sitio sí usan la red.

Pega la cadena que falla en Formatear y comparar JSON y lee los primeros caracteres antes de reescribir comillas.

FAQ

¿Por qué JSON.parse dice Unexpected token?

El texto no es JSON válido en el punto en que el analizador se detuvo. Causas típicas: comillas, comas, texto extra o un cuerpo que no es JSON, como HTML.

¿Qué significa Unexpected token < in JSON?

El primer carácter ilegal puede ser <. Eso a menudo apunta a una página HTML, pero no es prueba de un 404 ni de HTML en todos los casos. Revisa el estado, Content-Type y el cuerpo en bruto.

¿Cómo encuentro la posición del error en JSON?

Si el motor informa una posición, línea o columna, mira cerca. El fallo real puede estar antes. Úsala como pista y luego valida.

¿Puede JSON usar comillas simples?

No. En JSON estándar, las cadenas y los nombres de miembro usan comillas dobles.

¿Puede JSON tener comas finales?

No. El JSON estándar no permite una coma después de la última propiedad o del último elemento de array.

¿Cómo compruebo si una cadena es JSON válido?

Llama a JSON.parse en un try/catch, o pega el texto en Formatear y comparar JSON. Si el análisis lanza SyntaxError, la cadena no es JSON válido.