Cómo formatear JSON en línea — La guía completa

¿Qué es JSON?

JSON (JavaScript Object Notation) es un formato de intercambio de datos ligero que es fácil de leer y escribir para los humanos, y fácil de analizar y generar para las máquinas. Es el formato dominante para respuestas de API, archivos de configuración y almacenamiento de datos en el desarrollo web moderno.

Si trabajas con APIs, encuentras JSON constantemente. Prácticamente cada respuesta de API REST, cada payload de webhook y cada archivo de configuración en un proyecto Node.js es JSON. Saber leer, formatear y depurar JSON es una habilidad fundamental para todo desarrollador.

¿Por qué formatear JSON?

El JSON minificado es difícil de leer. Las respuestas de API a menudo llegan como una sola línea sin espacios en blanco — una pesadilla para depurar. Formatear (o "pretty-print") JSON agrega sangría y saltos de línea apropiados para que puedas entender su estructura de inmediato.

Antes de formatear:

{"name":"John Doe","age":30,"city":"New York","hobbies":["reading","coding"],"address":{"street":"123 Main St","zip":"10001"}}

Después de formatear:

{
  "name": "John Doe",
  "age": 30,
  "city": "New York",
  "hobbies": [
    "reading",
    "coding"
  ],
  "address": {
    "street": "123 Main St",
    "zip": "10001"
  }
}

La diferencia es dramática. En la versión formateada puedes ver de un vistazo que hay cinco claves de nivel superior, que hobbies es un arreglo con dos elementos, y que address es un objeto anidado. En la versión minificada, tienes que analizar visualmente las llaves y corchetes correspondientes.

Cómo usar un formateador JSON

1. Pega tu JSON — coloca tus datos JSON en el campo de entrada
2. Haz clic en "Formatear" — obtenlo limpio con sangría de 2 o 4 espacios
3. Haz clic en "Minificar" — comprime el JSON de vuelta a una sola línea
4. Copia el resultado — un clic y está en tu portapapeles

El formateador valida tu JSON mientras pegas, dándote retroalimentación inmediata si algo está mal.

Errores JSON comunes (y cómo corregirlos)

JSON tiene reglas de sintaxis estrictas, y violar cualquiera de ellas causa un error de análisis. Aquí están los más frecuentes, ordenados por frecuencia de aparición en la práctica:

1. Comas finales

El error JSON más común. JavaScript permite comas finales en arreglos y objetos, por lo que los desarrolladores a menudo olvidan que JSON no lo permite.

// Incorrecto — coma final después de "coding"
{
  "hobbies": ["reading", "coding",]
}

// Correcto
{
  "hobbies": ["reading", "coding"]
}

2. Comillas simples en lugar de comillas dobles

JSON requiere comillas dobles para todas las cadenas. Las comillas simples son válidas en JavaScript y Python pero romperán el análisis JSON.

// Incorrecto
{'name': 'John Doe'}

// Correcto
{"name": "John Doe"}

3. Claves sin comillas

Los objetos JavaScript no necesitan claves entre comillas (para identificadores simples), pero en JSON cada clave debe ser una cadena entre comillas dobles.

// Incorrecto
{name: "John Doe", age: 30}

// Correcto
{"name": "John Doe", "age": 30}

4. Comentarios en JSON

JSON no soporta comentarios. Esto sorprende a la gente porque JSON se parece a JavaScript, y JavaScript sí soporta comentarios. Si necesitas comentarios en un archivo de configuración, usa JSONC (JSON with Comments, soportado en VS Code) o YAML.

// Incorrecto
{
  "port": 3000,  // puerto del servidor
  "host": "localhost"
}

// Correcto
{
  "port": 3000,
  "host": "localhost"
}

5. Caracteres especiales sin escapar

Las cadenas que contienen barras invertidas, comillas dobles o caracteres de control deben escaparse correctamente:

// Incorrecto — barra invertida y comilla sin escapar
{"path": "C:\Users\john", "note": "He said \"hello\""}

// Correcto
{"path": "C:\\Users\\john", "note": "He said \"hello\""}

6. Tipos de valores inválidos

JSON soporta exactamente estos tipos de valores: cadenas, números, booleanos (true/false), null, objetos y arreglos. Nada más es válido:

// Incorrecto
{"value": undefined}
{"count": NaN}
{"total": Infinity}
{"date": new Date()}

// Alternativas correctas
{"value": null}
{"count": 0}
{"total": 9999999}
{"date": "2026-03-15T10:30:00Z"}

Formateando JSON desde la línea de comandos

Cuando no tienes acceso a una herramienta web, o cuando necesitas formatear JSON como parte de un script, estos enfoques de línea de comandos son útiles:

Usando Python (disponible en la mayoría de sistemas)

# Formatear un archivo JSON
python3 -m json.tool input.json

# Formatear JSON por tubería
curl -s https://api.example.com/data | python3 -m json.tool

# Formatear con sangría personalizada
python3 -c "import json,sys; print(json.dumps(json.load(sys.stdin), indent=4))" < input.json

Usando jq (la navaja suiza para JSON)

jq es un procesador JSON dedicado y la herramienta más poderosa para trabajar con JSON en la línea de comandos:

# Pretty-print
cat data.json | jq '.'

# Formatear y extraer un campo específico
cat data.json | jq '.users[0].name'

# Formatear una respuesta de API
curl -s https://api.example.com/users | jq '.'

Si trabajas con JSON regularmente y no tienes jq instalado, instálalo ahora. Te ahorrará innumerables horas.

Usando Node.js

# Formato rápido
node -e "console.log(JSON.stringify(JSON.parse(require('fs').readFileSync('/dev/stdin','utf8')),null,2))" < input.json

Consejos para trabajar con JSON

Elige tu sangría con cuidado

• Sangría de 2 espacios: Más compacto, muestra más contenido en pantalla. Popular en proyectos JavaScript/TypeScript y la mayoría de frameworks web. Usado en la mayoría de la documentación de API.
• Sangría de 4 espacios: Más fácil de leer con estructuras profundamente anidadas. Común en proyectos Python y entornos Java empresariales.
• Sangría por tabulaciones: Técnicamente válido pero raro en JSON. Quédate con espacios.

Para la mayoría del desarrollo web, 2 espacios es la elección práctica. Proporciona suficiente jerarquía visual sin desperdiciar espacio horizontal.

Siempre valida antes de desplegar

Siempre valida JSON antes de usarlo en producción, especialmente cuando lo has escrito o modificado manualmente. Una sola coma faltante o corchete que no coincide puede hacer colapsar toda una aplicación. Nuestro formateador detecta errores de sintaxis en el momento en que pegas, permitiéndote detectar problemas rápidamente.

Usa JSON Schema para validación estructural

Si estás construyendo una API que acepta entrada JSON, el análisis simple no es suficiente. JSON Schema te permite definir la estructura, tipos y restricciones esperados:

{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "type": "object",
  "properties": {
    "name": { "type": "string", "minLength": 1 },
    "age": { "type": "integer", "minimum": 0 },
    "email": { "type": "string", "format": "email" }
  },
  "required": ["name", "email"]
}

Esto detecta campos requeridos faltantes, tipos incorrectos y valores fuera de rango — cosas que el análisis JSON básico nunca detectará.

Ordena las claves para diffs consistentes

Al comparar dos objetos JSON (en una revisión de código o un diff de configuración), las claves no ordenadas crean diffs ruidosos. Muchos formateadores, incluido el nuestro, ofrecen una opción para ordenar las claves de objetos alfabéticamente y recursivamente. Esto es especialmente útil para:

• Archivos de configuración en control de versiones (reduce diffs sin sentido)
• Comparar respuestas de API durante la depuración
• Instantáneas de prueba que necesitan ser deterministas

Escenarios reales de depuración de JSON

Depurar una respuesta de API

Enviaste una solicitud curl y obtuviste de vuelta una sola línea de JSON minificado. Para entender qué salió mal, primero necesitas ver la estructura:

curl -s https://api.example.com/users/123 | jq '.'

O pega la respuesta en el formateador JSON. Luego puedes ver si la estructura de la respuesta está equivocada, si falta un campo o si un valor es inesperado.

Comparar dos objetos JSON

Tienes dos respuestas de API que deberían ser idénticas pero algo difiere. Formatea ambas con claves ordenadas, luego ejecuta un diff:

jq -S '.' response1.json > sorted1.json
jq -S '.' response2.json > sorted2.json
diff sorted1.json sorted2.json

El indicador -S ordena las claves alfabéticamente para que las diferencias estructurales no creen ruido en la salida del diff.

Corregir errores de copiar-pegar

Un colega pegó JSON en Slack y las comillas tipográficas corrompieron el contenido. Pégalo en el formateador y resaltará el error (comillas curvas en lugar de rectas) para que sepas exactamente qué corregir.

Esto ocurre más a menudo de lo que piensas. Las aplicaciones de chat, los procesadores de texto y algunos editores de texto convierten automáticamente " a comillas curvas, que no son válidas en JSON.

Extraer datos de un archivo JSON grande

Recibiste un archivo JSON de varios megabytes pero solo necesitas una pequeña parte. En lugar de desplazarte por miles de líneas, usa jq para extraer exactamente lo que necesitas:

# Obtener el email del primer usuario
cat users.json | jq '.data.users[0].email'

# Obtener todos los nombres de usuario como lista plana
cat users.json | jq '[.data.users[].name]'

# Filtrar usuarios por estado
cat users.json | jq '[.data.users[] | select(.status == "active")]'

JSON vs otros formatos de datos

Propiedad	JSON	YAML	XML	TOML
Legibilidad	Buena	Excelente	Regular	Buena
Comentarios	No	Sí	Sí	Sí
Tipos de datos	Básicos	Ricos	Basados en cadenas	Ricos
Tamaño de archivo	Pequeño	Pequeño	Grande	Pequeño
Velocidad de análisis	Rápido	Moderado	Lento	Rápido
Ecosistema	Enorme	Grande	Grande	En crecimiento

JSON gana para comunicación de API e intercambio de datos gracias a su simplicidad y soporte universal de analizadores. YAML es más adecuado para archivos de configuración donde los comentarios y la legibilidad importan. XML aún mantiene su posición en sistemas empresariales y formatos de documentos. TOML está ganando terreno para configuración (Cargo de Rust, pyproject.toml de Python).

Consideraciones de seguridad

No pegues datos sensibles en formateadores del lado del servidor

Algunos formateadores JSON en línea envían tus datos a un servidor para procesamiento. Si trabajas con claves API, tokens, contraseñas o datos personales, usa solo un formateador del lado del cliente que procese todo en el navegador. Nuestra herramienta hace todo el formateo localmente — nada se transmite jamás.

Cuídate de la inyección JSON

Al crear aplicaciones que aceptan entrada JSON, siempre valida y sanea los datos. Nunca construyas JSON concatenando cadenas:

// Peligroso — riesgo de inyección JSON
const json = '{"name": "' + userInput + '"}';

// Seguro
const json = JSON.stringify({ name: userInput });

Ten cuidado con JSON.parse en datos no confiables

JSON.parse() es generalmente seguro (a diferencia de eval()), pero los datos analizados pueden tener tipos o estructura inesperados. Siempre valida la forma del JSON analizado antes de usarlo en tu aplicación.

Formatea tus datos JSON ahora mismo con el formateador JSON gratuito. Se ejecuta completamente en el navegador, soporta resaltado de sintaxis y detecta errores en el momento en que pegas.