Qué es JSON: sintaxis, reglas y errores comunes explicados

JSON (JavaScript Object Notation) es un formato de texto para representar datos estructurados: objetos, listas, números, cadenas y booleanos, todo escrito con una sintaxis mínima y legible tanto para humanos como para máquinas. Es el formato que usan la inmensa mayoría de las APIs web para enviar y recibir información, y también el que aparece en archivos de configuración, respuestas de bases de datos y mensajes entre servicios.

Qué es JSON en realidad

JSON solo admite seis tipos de valores: cadena de texto (siempre entre comillas dobles), número, booleano (true o false), null, objeto (delimitado por {}) y array (delimitado por []). No hay un séptimo tipo escondido en ningún lado, y esa limitación deliberada explica por qué el formato es tan portable entre lenguajes de programación distintos.

La sintaxis tiene reglas estrictas que no dan margen de interpretación:

• Las claves de un objeto deben ser siempre cadenas entre comillas dobles, nunca comillas simples.
• No se permite una coma sobrante después del último elemento de un array ni de la última propiedad de un objeto.
• No existen los comentarios, de ningún tipo, en ningún lugar del documento.
• Las claves nunca pueden dejarse sin comillas.
• NaN, Infinity y undefined no son valores válidos en JSON.
• Las funciones no se pueden representar como valor en JSON.

Esta rigidez es intencional. Un parser de JSON no tiene que adivinar nada: o el documento cumple exactamente estas reglas, o falla. Esa previsibilidad es justo lo que hace confiable pasar datos entre un backend en Python, un frontend en JavaScript y una base de datos, sin que ninguno de los tres interprete la sintaxis de forma distinta.

JSON frente a un objeto literal de JavaScript

La sintaxis de JSON se parece tanto a un objeto de JavaScript que es fácil asumir que son lo mismo y copiar código de un contexto a otro sin pensarlo. No lo son. La tabla siguiente resume dónde diverge cada uno:

Característica	JSON	Objeto literal de JavaScript
Las claves deben ir entre comillas	Sí, solo comillas dobles	No, las comillas son opcionales
Se permite coma sobrante	No	Sí
Se permiten comentarios	No	Sí
Cadenas con comillas simples	No	Sí
Funciones como valor	No	Sí
undefined como valor	No	Sí

JavaScript es un lenguaje de programación completo con su propia gramática flexible. JSON es apenas un formato de intercambio de datos, deliberadamente más estricto. Por eso un objeto escrito a mano en el editor puede ejecutarse sin problemas en JavaScript y, al mismo tiempo, fallar en cuanto se pega en un campo que espera JSON válido.

Ejemplo práctico: minificar y formatear una respuesta de API real

Toma este objeto, típico de lo que devolvería un endpoint de usuarios:

{
  "id": 1,
  "name": "Ada Lovelace",
  "email": "[email protected]",
  "roles": [
    "admin",
    "user"
  ],
  "active": true,
  "meta": null
}

Esta versión con sangría de 2 espacios ocupa exactamente 145 caracteres. La misma información, minificada (sin ningún espacio en blanco), se ve así y ocupa exactamente 107 caracteres:

{"id":1,"name":"Ada Lovelace","email":"[email protected]","roles":["admin","user"],"active":true,"meta":null}

La versión formateada es cerca de un 35% más grande que la minificada, y esa diferencia sale únicamente de los espacios y saltos de línea añadidos, ningún dato cambia entre una versión y otra. Esto explica por qué las APIs casi siempre envían JSON minificado por la red (menos bytes, transferencias más rápidas) mientras que los desarrolladores reformatean esa misma respuesta al leerla en la consola o en un editor, porque una sola línea de datos anidados es prácticamente ilegible a simple vista.

Formatea tu propio JSON

Prueba el proceso con tus propios datos: pega cualquier JSON, compacto o desordenado, y obtén al instante una versión indentada y validada.

Formateador y Validador de JSON

Gratis, sin registro, funciona en cualquier dispositivo.

Abrir la herramienta completa

Errores comunes y casos límite

Coma sobrante al final. Es probablemente el error más frecuente al editar JSON a mano. Con la entrada {"id":1,"name":"Ada",} el motor V8 (el mismo que usa Chrome y que corre el JSON.parse de este formateador en el navegador de la mayoría de tus visitantes) devuelve exactamente este mensaje: Expected double-quoted property name in JSON at position 21 (line 1 column 22). El navegador está esperando una nueva clave entre comillas justo después de esa coma, y como en vez de eso encuentra el cierre }, el análisis falla ahí mismo.

Clave sin comillas. Con {id:1} el error es Expected property name or '}' in JSON at position 1 (line 1 column 2). En JavaScript esto es perfectamente válido, pero JSON exige comillas dobles alrededor de cada clave sin excepción.

Clave con comillas simples. El mismo tipo de error aparece con {'a':1}: Expected property name or '}' in JSON at position 1 (line 1 column 2). El parser no reconoce la comilla simple como delimitador de cadena, así que simplemente no ve ahí un nombre de propiedad válido.

NaN como valor. La entrada {"a":NaN} produce Unexpected token 'N', "{"a":NaN}" is not valid JSON. NaN existe en JavaScript como resultado de operaciones numéricas inválidas, pero JSON no tiene forma de representarlo.

undefined como valor. De forma similar, {"a":undefined} produce Unexpected token 'u', "{"a":undefined}" is not valid JSON. JSON no tiene concepto de “ausencia de valor” más allá de null; undefined sencillamente no forma parte de su vocabulario.

Estos mensajes exactos vienen de V8, el motor de JavaScript de Chrome (y de Node.js, que usa el mismo motor). Firefox, con su motor SpiderMonkey, redacta los mensajes de forma distinta. El resultado final es siempre el mismo: el análisis falla ante una sintaxis inválida, solo cambia la forma en que se describe el problema.

Claves duplicadas: el error silencioso. A diferencia de todos los casos anteriores, {"a":1,"a":2} es JSON sintácticamente válido. No lanza ningún error. Pero al analizarlo, la mayoría de los parsers (incluido el de JavaScript) se quedan solo con la última aparición y descartan la anterior, así que el resultado termina siendo {"a":2}. Este es un origen de bugs particularmente traicionero: imagina un archivo de configuración editado a mano, o generado por una herramienta de build, donde la misma clave queda duplicada por accidente. No hay ningún mensaje de error que te avise, el programa simplemente usa el segundo valor y nadie nota que el primero fue silenciosamente ignorado hasta que algo empieza a comportarse mal en producción.

Preguntas frecuentes

¿Qué es JSON? Es un formato de texto para representar datos estructurados (objetos, arrays, números, cadenas, booleanos y null) con una sintaxis fija y estricta. Se usa como el estándar de facto para intercambiar información entre APIs, servicios y archivos de configuración.

¿JSON es lo mismo que un objeto de JavaScript? No. Se parecen mucho visualmente, pero JSON es más estricto: exige comillas dobles en todas las claves, no admite comas sobrantes, comentarios, comillas simples, funciones ni el valor undefined. Un objeto literal de JavaScript permite todo eso.

¿Por qué una coma sobrante rompe mi JSON? Porque la especificación de JSON no permite una coma después del último elemento de un array o la última propiedad de un objeto. El parser espera encontrar otra clave o valor tras la coma y, al toparse en cambio con el cierre } o ], falla con un error de sintaxis en esa posición exacta.

¿JSON acepta comentarios? No, en ningún formato ni posición del documento. Si necesitas documentar un archivo JSON, la práctica común es usar una clave dedicada a modo de nota o cambiar a un formato como JSON5 o YAML que sí los admite.

¿Cuál es la diferencia entre formatear y minificar JSON? Formatear (o embellecer) añade indentación y saltos de línea para que el documento sea legible para una persona. Minificar hace exactamente lo contrario: elimina todo espacio en blanco innecesario para reducir el tamaño del archivo, algo que interesa cuando ese JSON viaja por la red o se guarda en una base de datos donde el tamaño importa.

¿Se envían mis datos a un servidor al usar un formateador online? En el caso del formateador JSON de pluri.tools, no. Todo el análisis y formateo corre en tu propio navegador mediante JSON.parse y JSON.stringify, funciones estándar de JavaScript. No hay ninguna llamada de red de por medio: el JSON que pegas nunca sale de tu dispositivo.