Saltar al contenido
W Webtoolia
Desarrollo 6 min de lectura

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

Aprende qué es JSON, cómo funciona, su sintaxis y por qué es el formato estándar de las APIs modernas. Con ejemplos prácticos y errores comunes.

Cada vez que abres una app en el móvil, consultas el tiempo o compras online, hay una buena probabilidad de que, detrás de escena, dos sistemas estén intercambiando datos en formato JSON. Es el lenguaje silencioso que conecta servidores, aplicaciones web, móviles e incluso dispositivos del hogar inteligente. Si trabajas con desarrollo web, análisis de datos o simplemente quieres entender cómo funcionan las APIs modernas, dominar JSON es un primer paso imprescindible.

¿Qué significa JSON?

JSON son las siglas de JavaScript Object Notation (notación de objetos de JavaScript). A pesar del nombre, no es JavaScript ejecutable: es un formato de texto plano diseñado exclusivamente para representar y transportar datos estructurados.

Fue popularizado a principios de los años 2000 por Douglas Crockford, quien buscaba una alternativa más ligera que XML para intercambiar información entre aplicaciones. La clave de su éxito fue la simplicidad: cualquier persona puede leer un JSON con un poco de práctica, y prácticamente todos los lenguajes de programación modernos incluyen librerías nativas para parsearlo.

Hoy JSON es el estándar de facto en APIs REST, configuraciones de aplicaciones, logs estructurados, bases de datos NoSQL como MongoDB y mensajería entre microservicios. Si has visto una respuesta de fetch() en la consola del navegador o un archivo package.json en un proyecto Node.js, ya has tenido contacto con este formato.

Tipos de datos en JSON

El estándar JSON (definido en el RFC 8259) admite exactamente seis tipos de dato. No hay fechas nativas, funciones, undefined ni comentarios: solo estructuras simples que cualquier lenguaje puede interpretar.

String (cadena de texto)

Todo texto va entre comillas dobles. Las comillas simples no son válidas.

"nombre": "Ana García",
"email": "ana@ejemplo.com",
"mensaje": "Dijo: \"Hola mundo\""

Si el texto contiene comillas dobles, deben escaparse con \". Los saltos de línea dentro de un string requieren el carácter de escape \n.

Number (número)

Enteros, decimales y notación científica. No admite NaN ni Infinity.

"edad": 28,
"precio": 19.99,
"distancia": 1.5e6

Boolean (booleano)

Solo dos valores posibles, siempre en minúsculas:

"activo": true,
"verificado": false

Null

Representa la ausencia intencionada de valor. No confundir con 0, false o una cadena vacía "".

"direccion": null

Array (lista ordenada)

Colección de valores separados por comas, entre corchetes. Puede mezclar tipos, aunque en la práctica suele mantenerse homogéneo.

"roles": ["admin", "editor", "lector"],
"puntuaciones": [95, 87, 92, 78]

Object (objeto)

Colección de pares clave-valor entre llaves. Las claves siempre son strings entre comillas dobles.

"usuario": {
  "id": 1,
  "nombre": "Ana García"
}

Los objetos pueden anidarse sin límite práctico, lo que permite representar estructuras complejas como perfiles de usuario, catálogos de productos o configuraciones de aplicación.

Estructura de un JSON real: respuesta de una API

Imagina que tu aplicación consulta un endpoint de usuarios. La respuesta típica de una API REST podría verse así:

{
  "status": "ok",
  "total": 2,
  "usuarios": [
    {
      "id": 1,
      "nombre": "Ana García",
      "email": "ana@ejemplo.com",
      "activo": true,
      "roles": ["admin", "editor"],
      "direccion": null,
      "creado_en": "2025-03-15T10:30:00Z"
    },
    {
      "id": 2,
      "nombre": "Carlos López",
      "email": "carlos@ejemplo.com",
      "activo": false,
      "roles": ["lector"],
      "direccion": {
        "ciudad": "Madrid",
        "pais": "ES"
      },
      "creado_en": "2025-06-01T14:22:00Z"
    }
  ]
}

Observa varios patrones habituales en APIs reales:

  • Un campo de estado (status) que indica si la petición tuvo éxito.
  • Metadatos como total junto a los datos principales.
  • Arrays de objetos para listas de recursos.
  • Valores null cuando un campo opcional no tiene dato.
  • Fechas representadas como strings en formato ISO 8601 (JSON no tiene tipo fecha nativo).

Cuando recibes una respuesta así desde curl, Postman o la consola del navegador, suele llegar comprimida en una sola línea. Ahí es donde un formateador resulta indispensable para inspeccionar la estructura durante la depuración.

Reglas de sintaxis: los errores más comunes

JSON es estricto. Un solo carácter fuera de lugar hace que el documento completo sea inválido y que cualquier parser rechace el análisis. Estos son los fallos que más aparecen al escribir JSON a mano o al copiar fragmentos desde otros formatos.

Comillas simples en lugar de dobles

// ❌ Inválido
{ 'nombre': 'Ana' }

// ✅ Válido
{ "nombre": "Ana" }

Coma final (trailing comma)

JSON estándar no permite una coma después del último elemento de un objeto o array. Muchos lenguajes como JavaScript sí la toleran, lo que genera confusión.

// ❌ Inválido
{
  "id": 1,
  "nombre": "Ana",
}

// ✅ Válido
{
  "id": 1,
  "nombre": "Ana"
}

Claves sin comillas

En JavaScript puedes escribir { nombre: "Ana" }, pero en JSON las claves deben ir siempre entre comillas dobles.

// ❌ Inválido
{ nombre: "Ana" }

// ✅ Válido
{ "nombre": "Ana" }

Comentarios no permitidos

A diferencia de JSONC (usado en tsconfig.json o archivos de VS Code), el JSON estándar no admite comentarios con // ni /* */.

Llaves o corchetes desbalanceados

Olvidar cerrar un {, } o ] es el error más frustrante en documentos grandes. Un formateador te indica exactamente dónde falla el análisis en lugar de obligarte a contar llaves manualmente.

JSON vs XML: ¿por qué ganó JSON?

Antes de JSON, XML dominaba el intercambio de datos en servicios web SOAP y configuraciones empresariales. Ambos formatos cumplen la misma función, pero con filosofías distintas.

El mismo dato de usuario en XML:

<usuario>
  <id>1</id>
  <nombre>Ana García</nombre>
  <activo>true</activo>
  <roles>
    <rol>admin</rol>
    <rol>editor</rol>
  </roles>
</usuario>

Y en JSON:

{
  "id": 1,
  "nombre": "Ana García",
  "activo": true,
  "roles": ["admin", "editor"]
}

JSON ganó terreno por varias razones concretas:

  • Menor tamaño: sin etiquetas de apertura y cierre repetitivas, el payload ocupa menos bytes. En APIs con millones de peticiones diarias, eso se traduce en ahorro real de ancho de banda.
  • Lectura directa: la estructura es visible sin conocer un esquema XSD.
  • Integración con JavaScript: los objetos JSON se mapean directamente a objetos nativos del lenguaje más usado en frontend.
  • Parsing más rápido: los parsers JSON son más simples y eficientes que los de XML.

XML sigue vigente en sectores regulados, documentos con namespaces complejos y sistemas legacy. Pero si construyes una API nueva en 2026, la elección predeterminada es JSON.

Cómo validar y formatear JSON

Trabajar con JSON implica dos operaciones frecuentes: validar que la sintaxis es correcta y formatear el documento para leerlo con comodidad.

La validación comprueba que el texto cumple el RFC 8259: tipos correctos, comillas equilibradas, sin comas finales. El formateo (también llamado beautify) añade indentación y saltos de línea; la minificación hace lo contrario, eliminando espacios innecesarios para reducir el tamaño del archivo.

Puedes hacer ambas cosas con el Formateador JSON de Webtoolia. Pega el contenido tal como lo recibes de una API, un log o tu editor de código y obtén al instante una versión legible o compacta. Todo el procesamiento ocurre en tu navegador: tus datos no se envían a ningún servidor.

Casos de uso habituales:

  • Depurar respuestas de fetch() o curl durante el desarrollo.
  • Preparar ejemplos legibles para documentación o pull requests.
  • Detectar errores de sintaxis antes de desplegar un archivo de configuración.
  • Comparar visualmente dos estructuras JSON anidadas.

Si necesitas validar que los campos cumplen un esquema concreto (por ejemplo, que email es obligatorio y tiene formato válido), eso va un paso más allá: se hace con herramientas como JSON Schema, Zod o AJV en tu proyecto.

Conclusión

JSON es el formato de intercambio de datos más extendido en el ecosistema web moderno. Su sintaxis es deliberadamente simple —seis tipos de dato, objetos anidados y arrays— pero su rigor exige atención a los detalles: comillas dobles, sin comas finales y sin comentarios.

Si estás empezando, practica leyendo respuestas de APIs públicas y experimentando con objetos anidados. Si ya trabajas con JSON a diario, un buen formateador te ahorrará tiempo cada vez que necesites inspeccionar un payload comprimido o localizar un error de sintaxis en un documento grande.

Recursos para profundizar:

#json #apis #programación #desarrollo web
Compartir: X LinkedIn