Cómo Validar JSON Online: Sintaxis, Esquema y Errores Comunes

JSON (JavaScript Object Notation) tiene una especificación formal definida por RFC 8259 y el estándar ECMA-404. Un documento JSON es válido cuando se ajusta completamente a esta especificación: ni más ni menos. Las reglas son más estrictas de lo que la mayoría espera, y varias cosas que JavaScript permite están explícitamente prohibidas en JSON.

Las reglas de la especificación JSON

• Las cadenas deben usar comillas dobles - las cadenas con comillas simples (`'value'`) no son JSON válido aunque JavaScript las acepte.
• Sin comas finales - `[1, 2, 3,]` y `{"a": 1,}` son inválidos; la coma tras el último elemento debe eliminarse.
• Sin comentarios - los `// comentarios de línea` y `/* comentarios de bloque */` no forman parte de la especificación JSON.
• Sin valores undefined - `undefined` es un concepto de JavaScript; JSON solo permite `null`, números, cadenas, booleanos, arrays y objetos.
• Los números no pueden tener ceros a la izquierda - `012` no es JSON válido; usa `12`.
• Las claves de objeto deben ser cadenas - `{1: "value"}` es inválido; las claves deben ser cadenas entre comillas dobles.
• Sin caracteres de control en cadenas - los saltos de línea, tabuladores y otros caracteres de control sin procesar deben escaparse (`\n`, `\t`, etc.).

Válido sintácticamente frente a válido semánticamente

Un documento JSON puede ser sintácticamente válido (bien formado según la especificación) pero semánticamente inválido para tu aplicación. Por ejemplo, un objeto JSON con "age" establecido en -5 es JSON válido, pero una edad inválida para un perfil de usuario. La validación de sintaxis es lo que comprueba un parser JSON; la validación de esquema es lo que detecta los errores semánticos. Ambas capas importan, y esta guía cubre las dos.

La forma más rápida de comprobar si una cadena JSON es válida es pegarla en un validador JSON online. Sin instalación, sin configuración, sin cuenta. El resultado es instantáneo y, cuando usas una herramienta basada en navegador, tus datos nunca salen de tu dispositivo.

Un texto JSON es un valor serializado. Nótese que ciertas especificaciones anteriores de JSON restringían el texto JSON a ser un objeto o un array.

Usar el Formateador y Validador de JSON

El Formateador y Validador de JSON de Aback Tools valida y formatea JSON simultáneamente. Pega cualquier cadena JSON y te dirá de inmediato si la entrada es válida. Si es inválida, la herramienta resalta la posición del error con un número de línea y una descripción en lenguaje llano de qué salió mal. Si es válida, genera JSON limpio e indentado que puedes copiar directamente a tu proyecto.

Este enfoque de doble propósito importa en la práctica. Cuando recibes JSON de una API, lo copias de un archivo de configuración o lo extraes de una línea de log, el texto sin procesar suele estar minificado y ser difícil de leer. Formatearlo como parte de la validación te da dos cosas a la vez: la confirmación de que el JSON es válido y una versión legible que sí puedes inspeccionar.

La mayoría de los documentos JSON inválidos fallan por una de cinco razones. Conocer estos patrones te permite corregir errores rápidamente sin depender por completo de una herramienta para diagnosticarlos.

// ❌ Inválido - coma tras la última propiedad
{
  "name": "Alice",
  "age": 30,
}

// ✓ Válido - sin coma final
{
  "name": "Alice",
  "age": 30
}

// ❌ Inválido - clave y valor con comillas simples
{'city': 'London'}

// ✓ Válido - clave y valor con comillas dobles
{"city": "London"}

// ❌ Inválido - los comentarios no forman parte de la especificación JSON
{
  // Este es el objeto de usuario
  "name": "Alice",
  "role": "admin" /* permisos elevados */
}

// ❌ Inválido - salto de línea sin procesar dentro del valor
{"message": "line one
line two"}

// ✓ Válido - salto de línea escapado
{"message": "line one\nline two"}

// ❌ Inválido - array abierto pero objeto cerrado
{
  "items": [1, 2, 3
}

// ✓ Válido - delimitadores emparejados
{
  "items": [1, 2, 3]
}

La validación de sintaxis confirma que el JSON está bien formado. La validación de esquema confirma que el JSON contiene los datos correctos: los campos correctos, los tipos correctos, los rangos de valores correctos. Son dos comprobaciones distintas y ambas se necesitan en sistemas de producción.

¿Qué es JSON Schema?

JSON Schema es un vocabulario para describir la estructura y las restricciones de un documento JSON. Un documento de esquema especifica qué campos son obligatorios, qué tipo debe tener cada campo, valores mínimos y máximos para números, patrones de cadena permitidos y más. Al validar un documento JSON contra un esquema, obtienes errores precisos como "el campo 'email' es obligatorio" o "el campo 'age' debe ser un entero positivo" - no solo "JSON inválido".

Usar el Validador de JSON Schema

El Validador de JSON Schema de Aback Tools acepta un payload JSON y un JSON Schema y valida el payload contra las restricciones del esquema. Informa de errores a nivel de regla con la ruta de campo exacta que falló - así sabes no solo que la validación falló, sino qué campo violó qué regla. Es la herramienta adecuada cuando necesitas verificar que una respuesta de API cumple un contrato o que un archivo de configuración contiene todos los ajustes requeridos.

Validación de sintaxis frente a validación de esquema

Generar un esquema desde un payload existente

La forma más rápida de añadir validación de esquema a un proyecto existente es generar el esquema a partir de un payload known-good. Pega un objeto JSON representativo en el Generador de JSON Schema y producirá un esquema completo con definiciones de tipos, campos obligatorios y pistas de formato. Copia la salida a tu proyecto y úsala como contrato de validación para todos los payloads futuros de ese tipo.

Las herramientas online son la opción más rápida para comprobaciones puntuales, pero los sistemas de producción necesitan validación de JSON incrustada en el código. Cada lenguaje de programación importante tiene al menos una librería de análisis JSON bien mantenida, y la mayoría tiene también librerías dedicadas de validación de esquemas.

JavaScript y TypeScript

En JavaScript, `JSON.parse()` lanza un `SyntaxError` cuando recibe JSON inválido - envuélvelo en un try/catch para manejar el error con elegancia. Para validación de esquema, AJV (Another JSON Validator) es la librería más utilizada, con soporte de JSON Schema Draft-07 hasta Draft 2020-12 y alto rendimiento. Zod es una alternativa popular orientada a TypeScript que valida JSON contra esquemas de tipos en tiempo de ejecución con inferencia completa de TypeScript. El convertidor de JSON a Esquema Zod de Aback Tools genera un esquema Zod a partir de cualquier payload JSON automáticamente.

function isValidJson(input: string): boolean {
  try {
    JSON.parse(input);
    return true;
  } catch {
    return false;
  }
}

// Or get the parsed value and the error together:
function parseJson<T>(input: string): { data: T } | { error: string } {
  try {
    return { data: JSON.parse(input) as T };
  } catch (e) {
    return { error: (e as SyntaxError).message };
  }
}

Python

El módulo `json` integrado de Python lanza `json.JSONDecodeError` (subclase de `ValueError`) cuando el análisis falla. El objeto de error incluye el número de línea, la columna y una descripción. Para validación de esquema, jsonschema y pydantic son las opciones estándar - pydantic es especialmente popular en proyectos FastAPI porque valida y deserializa JSON en objetos Python tipados en un solo paso.

import json

def is_valid_json(text: str) -> bool:
    try:
        json.loads(text)
        return True
    except json.JSONDecodeError as e:
        print(f"Invalid JSON at line {e.lineno}, col {e.colno}: {e.msg}")
        return False

Línea de comandos

En cualquier sistema con Python instalado, `python3 -m json.tool input.json` valida y da formato bonito a un archivo JSON en un solo comando. El código de salida es distinto de cero en caso de fallo, lo que lo hace adecuado para scripts de shell y pipelines de CI. La herramienta `jq` es una alternativa más potente: `jq . input.json` valida y formatea, mientras que `jq 'empty' input.json` valida sin producir salida.

# Validate and pretty-print with Python (built-in, no install)
python3 -m json.tool input.json

# Validate silently with jq (exit code 0 = valid, 1 = invalid)
jq empty input.json && echo "Valid" || echo "Invalid"

# Validate multiple files with a loop
for f in *.json; do
  jq empty "$f" && echo "$f: valid" || echo "$f: INVALID"
done

La validación JSON estándar cubre archivos `.json` y payloads de API. Pero el JSON aparece en varios otros formatos con sus propios requisitos de validación - formatos donde un parser JSON estándar produce resultados incorrectos o rechaza toda la entrada.

JSONL y NDJSON (JSON Lines)

Los archivos JSON Lines (`.jsonl`) contienen un objeto JSON por línea sin array envolvente. Este formato es estándar para archivos de log, conjuntos de datos de ML y APIs de streaming. Un parser JSON estándar rechaza un archivo JSONL porque el archivo como conjunto no es un documento JSON válido - cada línea debe analizarse individualmente. El Validador y Reparador de JSON Lines valida cada línea por separado, informa de qué números de línea tienen errores y ofrece autocorrecciones seguras para problemas de formato comunes.

JSON con claves duplicadas

La especificación JSON técnicamente permite claves duplicadas en objetos, pero el comportamiento es indefinido - distintos parsers lo manejan de forma diferente. El `json.loads()` de Python conserva el último valor; algunos parsers conservan el primero; otros lanzan un error. En la práctica, las claves duplicadas son casi siempre un error - una fusión mal hecha o un error de plantilla. El Detector de Claves Duplicadas en JSON encuentra todas las claves repetidas y te dice exactamente dónde ocurren.

JSON en archivos de configuración YAML

YAML es un superconjunto de JSON, así que todo JSON válido es también YAML válido. Pero el JSON incrustado en archivos YAML - como valor de un campo de cadena, por ejemplo - necesita su propia validación. Si trabajas con configs YAML que contienen valores JSON incrustados, valida las porciones JSON por separado con el formateador JSON y luego valida el YAML general con un validador YAML. Si tu proyecto usa ambos formatos y necesitas comparar dos archivos de configuración, el Resaltador de Diferencias JSON/YAML maneja ambos simultáneamente.

Validar JSON una vez antes de una operación importante está bien. Construir la validación en cada punto donde el JSON entra o sale de tu sistema es mejor. Estas prácticas aplican tanto si construyes una API, procesas pipelines de datos o gestionas archivos de configuración.

Validar en la ingesta, no en el consumo

El momento adecuado para validar JSON es cuando entra por primera vez en tu sistema - en el límite de la API, en el gestor de subida de archivos, en el consumidor de la cola de mensajes. Validar en el consumo (en la función que lee un valor en lo profundo de tu código) significa que los datos inválidos se propagan más lejos antes de fallar, haciendo el error más difícil de rastrear. Valida temprano y rechaza la entrada inválida en el punto de entrada.

Usa un esquema, no solo una comprobación de sintaxis

La validación de sintaxis es el mínimo exigible. En cualquier sistema donde el JSON transporta datos críticos para el negocio - registros de usuarios, payloads de pago, valores de configuración - un esquema añade una segunda capa que detecta tipos erróneos, campos obligatorios ausentes y valores fuera de rango que la validación de sintaxis no puede detectar. Genera tu esquema inicial a partir de un payload known-good con el Generador de JSON Schema y refínalo a medida que evoluciona tu modelo de datos.

Maneja los errores de validación explícitamente

Una llamada a `JSON.parse()` envuelta en un try/catch que se traga el error y devuelve null es peor que no validar - oculta el problema. Cuando la validación de JSON falla, registra el error con la fuente de entrada, el mensaje de error exacto y suficiente contexto para reproducir el problema. Devuelve un error significativo al llamante en lugar de un resultado vacío que provoque un error secundario en otro lugar.

• Registra la entrada sin procesar - cuando la validación de JSON falla en producción, la entrada sin procesar es el artefacto de depuración más valioso. Registra una versión truncada (primeros 500 caracteres) junto con el error.
• Incluye contexto de origen - anota de dónde vino el JSON: qué endpoint de API, qué archivo, qué mensaje de cola. Esto convierte un error de análisis genérico en un incidente accionable.
• Configura alertas para fallos de análisis - un pico de errores de validación JSON suele señalar un cambio disruptivo en una API aguas arriba o un despliegue que introdujo un bug de serialización.
• Prueba con entradas inválidas - incluye JSON inválido (coma final, comilla ausente, tipo erróneo) en tu suite de pruebas para confirmar que tu manejo de errores se comporta correctamente.