Cómo formatear y validar JSON en línea

Si trabaja con API, archivos de configuracion o cualquier tipo de datos estructurados, trata con JSON regularmente. Y si alguna vez ha mirado una pared de JSON minificado tratando de encontrar un corchete que falta, sabe por que importa el formateo. Un formateador basado en navegador maneja todo el trabajo localmente sin subir sus datos a un servidor.

Lo que hace el formateo JSON

El JSON sin procesar de una respuesta API o un archivo minificado se ve asi:

{"users":[{"name":"Alice","age":30,"roles":["admin","editor"]},{"name":"Bob","age":25,"roles":["viewer"]}]}

Un formateador lo transforma en algo legible:

{
  "users": [
    {
      "name": "Alice",
      "age": 30,
      "roles": ["admin", "editor"]
    },
    {
      "name": "Bob",
      "age": 25,
      "roles": ["viewer"]
    }
  ]
}

Los mismos datos, pero ahora puede leerlos de verdad, detectar errores y entender la estructura.

Como formatear JSON en linea

1. Pegue su JSON en el campo de entrada. El formateador detectara inmediatamente los errores de sintaxis y validara la estructura.
2. Elija su sangria: seleccione 2 o 4 espacios, o haga clic en Minificar para comprimir el JSON en una sola linea.
3. Copie el resultado: la salida formateada incluye resaltado de sintaxis con codigo de colores. Copielo para usarlo en su codigo, archivo de configuracion o documentacion.

Una breve historia de JSON

JSON (JavaScript Object Notation) fue especificado por Douglas Crockford en 2001, formalmente documentado en el RFC 4627 (2006), y estandarizado como ECMA-404 en 2013 e ISO/IEC 21778 en 2017. Crockford no invento JSON: lo extrajo de un subconjunto de la sintaxis de literal de objeto de JavaScript que ya estaba en uso, y le dio un nombre mas una especificacion de una sola pagina en json.org.

JSON desplazo rapidamente a XML para las API web porque es dramaticamente mas simple. Una respuesta XML es verbosa con etiquetas de apertura/cierre; el JSON equivalente es la mitad del tamano. Los navegadores pueden analizar JSON de forma nativa (JSON.parse, JSON.stringify desde ECMAScript 5 en 2009) sin necesidad de un analizador XML.

Para 2015, cada API importante del mundo hablaba JSON: API REST, consultas GraphQL, mensajes WebSocket, archivos de configuracion (package.json, tsconfig.json, .vscode/settings.json), e incluso bases de datos (PostgreSQL JSONB, MongoDB BSON que es tipo JSON). Se convirtio en la lingua franca de los datos estructurados en la web.

La simplicidad de JSON es tambien su limitacion: sin comentarios, sin comas finales, sin tipo de fecha, sin soporte binario. Surgieron varias variantes de JSON para abordar estas brechas (vea «Formatos alternativos tipo JSON» a continuacion).

Errores JSON comunes y como detectarlos

La mayoria de los errores JSON se reducen a unos pocos errores comunes:

• Comas faltantes o adicionales: una coma despues del ultimo elemento en un arreglo u objeto es invalida en JSON (a diferencia de JavaScript)
• Claves sin comillas: JSON requiere comillas dobles alrededor de todas las claves: "name" no name
• Comillas simples: JSON solo acepta comillas dobles: "value" no 'value'
• Comas finales: {"a": 1,} es invalido; elimine la coma despues de la ultima entrada
• Comentarios: JSON no admite comentarios // linea o /* bloque */; la mayoria de los analizadores los rechazan
• Undefined / NaN / Infinity: JSON solo permite numeros, cadenas, booleanos, null, arreglos y objetos. Valores de JavaScript como undefined, NaN o Infinity no son validos
• Valores de funcion: una referencia de funcion no puede aparecer en JSON
• Numeros hexadecimales u octales: solo los numeros decimales son validos (0xFF y 0o17 no lo son)
• Ceros iniciales: 01 es invalido en JSON; use 1
• Escapes hexadecimales: solo los escapes Unicode \u estan permitidos en cadenas, no \x o \0
• Claves duplicadas: tecnicamente validas segun la especificacion, pero la mayoria de los analizadores usan silenciosamente el ultimo valor; confie en esto bajo su propio riesgo
• BOM UTF-8: una marca de orden de bytes al inicio de un archivo no es JSON valido y rompe los analizadores estrictos
• Espacios o contenido al final: cualquier texto despues del ] o } de cierre hace que el documento sea invalido

Un buen formateador resalta exactamente donde esta el error, para que pueda corregirlo de inmediato en lugar de adivinar.

Tipos de datos JSON

JSON tiene exactamente 6 tipos de datos:

Notablemente faltan: fechas (use cadenas ISO 8601), datos binarios (use cadenas Base64), comentarios (use un campo de documentacion separado), y bigint (los numeros JSON son de doble precision; los valores >= 2^53 pierden precision).

Cuando formatear vs minificar

Formatear (pretty-print) cuando necesite:

• Leer y entender los datos
• Depurar respuestas API
• Editar archivos de configuracion
• Compartir JSON con colegas
• Hacer commit al control de version (diferencias mas limpias)

Minificar cuando necesite:

• Enviar datos por una red (carga util mas pequena = transferencia mas rapida)
• Almacenar JSON en una base de datos o registro donde la legibilidad no importa
• Incrustar JSON en un parametro URL o campo de formulario
• Generar respuestas API compactas

La diferencia de tamano es significativa: un JSON tipico de 50 KB pretty-printed se minifica a aproximadamente 30 KB. Para API de alto trafico, las respuestas minificadas ahorran ancho de banda. Para archivos editados por humanos, formateado es esencial.

Formatos alternativos tipo JSON

Cuando la estrictez de JSON es un problema, varias variantes flexibilizan las reglas:

Para intercambio de datos (respuestas API, configuracion), quedese con JSON estricto. Para configuracion editada por humanos, JSON5 o JSONC son mas amigables. Para streaming de datos, NDJSON es el estandar de facto.

Errores comunes

• Numeros perdiendo precision: los numeros JSON son dobles IEEE 754. Los enteros mayores que 2^53 (9.007.199.254.740.992) pierden precision. Transmita IDs grandes como cadenas ("id": "12345678901234567890").
• Escapes Unicode danados por editores: algunos editores convierten automaticamente caracteres al guardar, lo que puede hacer que los analizadores se comporten de manera inesperada. Use UTF-8 en todo.
• Pretty-print de fechas incorrecto: las fechas como cadenas ISO 8601 ("2026-05-20T13:00:00Z") son estandar. Evite marcas de tiempo Unix como cadenas; parecen numeros pero generalmente estan destinados a ser fechas.
• Espacios en claves: {"first name": "..."} es JSON valido pero rompe muchos ORM y generadores de codigo que esperan claves seguras como identificadores.
• Valores vacios vs claves faltantes: {"a": null} y {} (sin a en absoluto) son cosas diferentes. Elija una convencion y documentela.
• Incompatibilidad bigint: las columnas bigint de PostgreSQL serializadas como numeros JSON pueden perder precision. Use cadenas para IDs por encima de 2^53.
• Salto de linea final: algunas herramientas anaden un salto de linea despues de la llave de cierre; algunos analizadores estrictos lo rechazan. JSON-stringify no produce salto de linea final.
• Discrepancia de codificacion: la especificacion JSON requiere UTF-8 (o UTF-16/UTF-32 con BOM). Latin-1 con caracteres no ASCII falla. Siempre serialice como UTF-8.
• JSON stringificado en JSON: los caracteres de escape anidados se vuelven inmanejables rapidamente. Anide el objeto directamente o elija una convencion JSON codificada en base64.
• Comentarios en el archivo fuente: si hace commit de JSONC o JSON5 a un sistema que espera JSON estricto, el analisis falla. Convierta a JSON estricto en su paso de compilacion.

Consejos para trabajar con JSON

• Valide antes de enviar: si esta construyendo una solicitud API manualmente, pegue su JSON en un validador primero. Una sola coma fuera de lugar puede causar errores confusos en el lado del servidor.
• Use sangria de 2 espacios para datos profundamente anidados. Mantiene las lineas mas cortas y la estructura mas facil de escanear.
• Marque la herramienta: si trabaja con JSON regularmente, tener un formateador a un clic de distancia ahorra tiempo en comparacion con buscar uno cada vez.
• Use jq para el trabajo en linea de comandos: jq (y las alternativas de lenguaje jq como gron, dasel, yq) son esenciales para filtrar y transformar JSON en la linea de comandos.
• Use un esquema JSON para la validacion: para formatos importantes (contratos API, archivos de configuracion), defina un Esquema JSON y valide contra el. Herramientas como ajv (JavaScript), python-jsonschema o la validacion de esquema integrada de VS Code previenen errores de forma.
• Use Postman o Insomnia para solicitudes API: estas herramientas tienen formateadores y validadores JSON integrados, resaltado de sintaxis e historial de solicitudes.
• Ejecute JSON a traves de prettier en su base de codigo: Prettier formatea JSON de manera consistente; integrelo como un hook de pre-commit para que el formateo nunca sea una preocupacion de revision de codigo.
• Para diferencias, ordene las claves primero: las claves de objeto JSON no estan ordenadas. Una diferencia de {"a":1,"b":2} vs {"b":2,"a":1} muestra que todo cambio a menos que ordene las claves primero. Use jq -S o similar.

Privacidad y JSON confidencial

El formateador JSON se ejecuta completamente en su navegador. El JSON que pega, el procesamiento intermedio y la salida formateada se quedan todos en su dispositivo. Nada se sube a un servidor, se registra o se comparte con nadie.

Esto importa porque JSON a menudo contiene datos extremadamente sensibles: respuestas API con registros de clientes y direcciones de correo electronico, tokens de autenticacion y datos de sesion, esquemas API internos que revelan la arquitectura del producto, archivos de configuracion con contrasenas de base de datos, datos financieros de API contables, registros medicos de API FHIR, estructura interna de la empresa de API de RRHH, cargas utiles de depuracion con trazas de pila que revelan infraestructura. Los formateadores JSON en la nube registran cada pegado en sus registros de solicitud, a veces los retienen para «mejora del servicio», y han estado involucrados en incidentes reales donde respuestas API pegadas filtraron datos de clientes y claves API. Un formateador basado en navegador tiene exposicion cero: el JSON nunca sale de su maquina.

El formateo basado en navegador tambien funciona sin conexion una vez cargada la pagina, util para formatear JSON en aviones, en entornos seguros sin acceso a internet, o en cualquier lugar donde no pueda o no deba pegar datos API (especialmente con credenciales integradas) en un servicio de terceros.