¿Qué es JSON? Guía completa para principiantes

JSON en 30 segundos

JSON (Notación de Objetos de JavaScript) es un formato de datos ligero basado en texto que se ha convertido en la lengua franca del intercambio de datos en la web. Si alguna vez has llamado a una API REST, abierto un archivo package.json o trabajado con MongoDB, ya has utilizado JSON — probablemente sin pensarlo mucho.

En su núcleo, JSON es solo una forma de representar datos estructurados como texto plano. Es legible para los humanos (en su mayoría), fácilmente analizables por máquinas (muy fácilmente) y es compatible con prácticamente todos los lenguajes de programación existentes. Esa combinación es exactamente la razón por la que ganó.

Una breve historia

JSON fue popularizado por Douglas Crockford a principios de los años 2000. No lo "inventó" realmente — la sintaxis es un subconjunto de JavaScript que ha existido desde 1999 — pero le dio un nombre, un sitio web (json.org) y una especificación. A veces, la marca importa más que la invención.

El formato fue especificado formalmente en RFC 4627 (2006) y posteriormente reemplazado por RFC 8259 (2017) y el estándar ECMA-404. Pero, honestamente, la especificación no ha cambiado mucho desde el principio. La simplicidad de JSON es su mayor fortaleza — simplemente no hay mucho que cambiar.

Antes de que JSON se apoderara, XML era el formato de intercambio de datos dominante. Si quieres ver por qué los desarrolladores se volcaron a JSON, consulta nuestra comparación de JSON vs XML.

Los 6 tipos de datos de JSON

JSON admite exactamente seis tipos de datos. Ni más, ni menos. Esta restricción es intencional — mantiene las cosas simples e interoperables entre lenguajes.

Tipo	Descripción	Ejemplo
Cadena	Texto envuelto en comillas dobles	"hola mundo"
Número	Entero o de punto flotante (sin hex, sin NaN, sin Infinity)	42, 3.14, -7
Booleano	Literal true o false	true
Nulo	Representa un valor vacío o desconocido	null
Objeto	Colección desordenada de pares clave-valor	{"nombre": "Ada"}
Arreglo	Lista ordenada de valores	[1, 2, 3]

Nota lo que no está en la lista: fechas, funciones, indefinido, comentarios o datos binarios. JSON no admite ninguno de esos de forma nativa. Las fechas se suelen pasar como cadenas ISO 8601 ("2025-01-15T10:30:00Z"), y los datos binarios se codifican en Base64. Es un poco molesto, pero mantiene el formato universal.

Reglas de sintaxis de JSON

La sintaxis de JSON es estricta. Si vienes de JavaScript, podrías tropezar con algunas de estas reglas. Aquí están, sin adornos:

• Las claves deben ser cadenas entre comillas dobles. Las comillas simples no funcionan. Las claves sin comillas no funcionan. Esto no es JavaScript.
• Las cadenas deben usar comillas dobles. 'hola' es JSON inválido. "hola" es válido.
• Sin comas finales. ¿Esa última coma después de la última propiedad? JSON dice que no.
• Sin comentarios. Esta es probablemente la decisión de diseño más controvertida de JSON. Douglas Crockford las eliminó deliberadamente para prevenir abusos.
• Sin raíz de valor único (en especificaciones más antiguas). RFC 8259 ahora permite cualquier valor JSON como raíz, pero muchos analizadores aún esperan un objeto o un arreglo.

Aquí hay un documento JSON válido:

{
  "nombre": "Grace Hopper",
  "edad": 85,
  "idiomas": ["COBOL", "FORTRAN"],
  "jubilado": true,
  "cónyuge": null,
  "dirección": {
    "ciudad": "Arlington",
    "estado": "VA"
  }
}

Y aquí está lo que lo rompe:

{
  nombre: "Grace Hopper",     // ❌ Clave sin comillas
  'edad': 85,                 // ❌ Clave entre comillas simples
  "idiomas": ["COBOL",],      // ❌ Coma final
  // Este es un comentario      // ❌ Comentarios no permitidos
}

¿Tienes JSON inválido? Pégalo en nuestro Formateador de JSON para detectar instantáneamente errores de sintaxis y corregir automáticamente problemas comunes como comas finales.

JSON vs objetos de JavaScript

Esto confunde a casi todos los desarrolladores de JavaScript en algún momento. JSON se parece a un literal de objeto JS, pero no son lo mismo. Aquí es donde divergen:

Característica	JSON	Objeto de JavaScript
Claves	Deben ser cadenas entre comillas dobles	Pueden ser identificadores sin comillas, símbolos o computados
Cadenas	Solo comillas dobles	Comillas simples, comillas dobles o backticks
Comas finales	No permitidas	Permitidas
Comentarios	No permitidos	Permitidos
Valores	Cadenas, números, booleanos, nulo, objetos, arreglos	Todos los anteriores más funciones, indefinido, Date, RegExp, etc.
Métodos	No soportados	Soportados
Uso	Formato de intercambio de datos (texto)	Estructura de datos en memoria

En la práctica, puedes convertir entre ellos con JSON.parse() y JSON.stringify():

// Cadena → Objeto
const data = JSON.parse('{"nombre": "Ada", "año": 1843}');
console.log(data.nombre); // "Ada"

// Objeto → Cadena
const json = JSON.stringify({ nombre: "Ada", año: 1843 });
console.log(json); // '{"nombre":"Ada","año":1843}'

// Impresión bonita con indentación de 2 espacios
const pretty = JSON.stringify(data, null, 2);

Casos de uso comunes

1. APIs REST

Este es el pan y la mantequilla de JSON. La gran mayoría de las APIs web modernas envían y reciben JSON. Cuando fetch() datos de un servidor, casi seguramente estás recibiendo JSON de vuelta:

const response = await fetch("https://api.ejemplo.com/usuarios/1");
const user = await response.json();
// { "id": 1, "nombre": "Alice", "correo": "alice@ejemplo.com" }

2. Archivos de configuración

package.json, tsconfig.json, .eslintrc.json, composer.json — la lista continúa. JSON está en todas partes en las herramientas para desarrolladores. La falta de comentarios es genuinamente dolorosa aquí, por lo que algunas herramientas admiten JSON5 o JSONC (JSON con Comentarios) como alternativas.

3. Bases de datos NoSQL

MongoDB almacena documentos como BSON (JSON Binario). CouchDB utiliza JSON plano. DynamoDB, Firestore y muchos otros utilizan estructuras similares a JSON. Si estás trabajando con una base de datos de documentos, estás trabajando con JSON.

4. Almacenamiento local y gestión de estado

El localStorage del navegador solo almacena cadenas, por lo que serializar el estado a JSON es el enfoque estándar:

// Guardar
localStorage.setItem("prefs", JSON.stringify({ tema: "oscuro", lang: "es" }));

// Cargar
const prefs = JSON.parse(localStorage.getItem("prefs") ?? "{}");

5. Intercambio de datos entre microservicios

Las colas de mensajes (RabbitMQ, Kafka), webhooks y la comunicación entre servicios se basan en gran medida en JSON. No siempre es la opción más eficiente para escenarios de alto rendimiento (Protobuf y MessagePack son más rápidos), pero es la más depurable.

Mejores prácticas de JSON

Después de años de trabajar con JSON a diario, aquí están los hábitos que recomiendo desarrollar:

1. Usa convenciones de nomenclatura consistentes. Elige camelCase o snake_case para las claves y mantente con ello en toda tu API. Mezclarlos es un camino rápido hacia errores.
2. Valida temprano. No confíes ciegamente en el JSON entrante. Usa validación de JSON Schema para detectar datos mal formados antes de que lleguen a tu lógica de negocio.
3. Mantén la anidación poco profunda. Si tu JSON tiene más de 3–4 niveles de profundidad, considera aplanarlo. Las estructuras profundamente anidadas son difíciles de consultar, difíciles de leer y difíciles de diferenciar.
4. Usa arreglos para listas, objetos para registros. Suena obvio, pero he visto a personas usar objetos con claves de cadena numérica ({"0": "a", "1": "b"}) en lugar de arreglos. No hagas eso.
5. Prefiere null sobre claves faltantes cuando un campo no tiene valor. Hace que el esquema sea explícito y evita ambigüedades sobre si un campo fue omitido intencionalmente.
6. Formatea para humanos durante el desarrollo. JSON minificado ahorra bytes pero mata la legibilidad. Usa impresión bonita al depurar, minifica al enviar. Nuestro Minificador de JSON se encarga de esto último.

Pruébalo tú mismo: Pega cualquier JSON en nuestro Formateador de JSON para validar, formatear y explorar su estructura con resaltado de sintaxis y vista de árbol.

¿Qué pasa con JSON5 y JSONC?

Si la rigidez de JSON te molesta, no estás solo. Dos extensiones populares relajan las reglas:

• JSON5 permite cadenas entre comillas simples, comas finales, comentarios, claves sin comillas y más. Es genial para archivos de configuración donde los humanos son el público principal.
• JSONC (JSON con Comentarios) es una extensión mínima utilizada por VS Code y configuraciones de TypeScript. Solo agrega soporte para comentarios — nada más.

Sin embargo, ninguna de estas es JSON válido. Si estás construyendo una API o intercambiando datos entre sistemas, mantente con JSON estándar. Usa extensiones solo donde las herramientas las admitan explícitamente.

Conclusión

JSON tuvo éxito no porque sea perfecto, sino porque es lo suficientemente bueno para casi todo y muy simple de trabajar. Su sistema de tipos limitado es frustrante a veces (¿dónde están mis fechas?), y la regla de no comentarios es un verdadero punto de dolor. Pero esas restricciones son también lo que lo hace universalmente interoperable.

Si recién estás comenzando, la mejor manera de aprender JSON es trabajar con él de manera práctica. Intenta pegar algunos datos en nuestras herramientas, romper cosas a propósito y ver qué sucede. Entender los mensajes de error es la mitad de la batalla.

Sigue explorando:

• JSON vs YAML — cuándo usar cada formato
• JSON vs XML — por qué JSON reemplazó a XML para la mayoría de los casos de uso
• Validador de JSON — verifica si tu JSON es válido
• Generador de JSON Schema — genera esquemas automáticamente a partir de datos JSON