Validador de JSON Schema

¿Qué es la validación de JSON Schema?

La validación de JSON Schema es el proceso de comprobar si un documento JSON cumple con un conjunto de restricciones estructurales y de valores definidas en un JSON Schema. El schema en sí es un documento JSON que describe la forma esperada de tus datos: qué propiedades son obligatorias, qué tipos deben tener, los rangos permitidos para números, patrones de cadenas, longitudes de arrays y más. La especificación de JSON Schema se mantiene en json-schema.org y se publica como una serie de borradores IETF; Draft 7 y Draft 2020-12 son los más adoptados.

Mientras que la validación JSON simple solo comprueba la sintaxis (¿están los corchetes correctamente cerrados? ¿están las cadenas entre comillas?), la validación por schema va más allá. Responde preguntas como: ¿la respuesta de esta API contiene un campo "id" que siempre es un entero? ¿El campo "status" toma uno de tres valores permitidos? ¿Los objetos anidados tienen la estructura correcta? Este tipo de verificación estructural detecta errores que las comprobaciones de sintaxis no detectan, porque un JSON sintácticamente válido puede ser semánticamente incorrecto para tu aplicación.

JSON Schema se usa en definiciones OpenAPI/Swagger, validación de archivos de configuración, validación de formularios, restricciones de documentos en bases de datos y pruebas automatizadas. Herramientas como Ajv (JavaScript), jsonschema (Python) y check-jsonschema (CLI) implementan la especificación para que puedas validar datos mediante programación. Este validador online te permite pegar un schema y un documento de datos para comprobar la conformidad al instante, sin instalar ninguna librería.

¿Por qué usar un validador de JSON Schema online?

Escribir schemas y depurar errores de validación a mano es lento. Un validador de JSON Schema online te da retroalimentación inmediata sobre si tus datos coinciden con tu schema, con mensajes de error claros que apuntan exactamente a la propiedad que falló.

Casos de uso de la validación de JSON Schema

Referencia de palabras clave de JSON Schema

Un JSON Schema se construye a partir de palabras clave que imponen restricciones sobre los datos validados. La tabla siguiente lista las palabras clave más usadas en Draft 7 y versiones posteriores. Cualquier palabra clave puede combinarse con otras en el mismo objeto de schema.

Comparación de versiones de JSON Schema: Draft 7 vs 2019-09 vs 2020-12

JSON Schema ha pasado por varias versiones de borrador. Draft 7 (publicado en 2018) es el más ampliamente soportado en herramientas. Draft 2019-09 introdujo $defs (en sustitución de definitions), unevaluatedProperties y $recursiveRef. Draft 2020-12 (la última versión estable) reemplazó $recursiveRef por $dynamicRef e introdujo prefixItems para la validación de tuplas. Al elegir un borrador, comprueba que tu librería de validación lo soporte. Ajv soporta los tres borradores. La librería jsonschema de Python soporta hasta 2020-12 desde la versión 4.0.

Ejemplos de código

Estos ejemplos muestran cómo validar JSON contra un schema mediante programación. Cada uno usa una librería bien mantenida para su ecosistema de lenguaje.

import Ajv from 'ajv';

const ajv = new Ajv();

const schema = {
  type: 'object',
  properties: {
    name: { type: 'string', minLength: 1 },
    age: { type: 'integer', minimum: 0 },
    email: { type: 'string', format: 'email' }
  },
  required: ['name', 'email'],
  additionalProperties: false
};

const data = { name: 'Alice', age: 30, email: 'alice@example.com' };

const validate = ajv.compile(schema);
const valid = validate(data);
console.log(valid);          // → true
console.log(validate.errors); // → null

// Invalid data — missing required "email"
validate({ name: 'Bob', age: 25 });
console.log(validate.errors);
// → [{ instancePath: '', keyword: 'required', params: { missingProperty: 'email' } }]

from jsonschema import validate, ValidationError

schema = {
    "type": "object",
    "properties": {
        "name": {"type": "string", "minLength": 1},
        "age": {"type": "integer", "minimum": 0},
        "tags": {
            "type": "array",
            "items": {"type": "string"},
            "uniqueItems": True
        }
    },
    "required": ["name"]
}

# Valid data
validate(instance={"name": "Alice", "age": 30, "tags": ["admin"]}, schema=schema)
# → No exception raised

# Invalid data — wrong type for "age"
try:
    validate(instance={"name": "Alice", "age": "thirty"}, schema=schema)
except ValidationError as e:
    print(e.message)
    # → 'thirty' is not of type 'integer'
    print(e.json_path)
    # → $.age

package main

import (
    "fmt"
    "strings"
    "github.com/santhosh-tekuri/jsonschema/v5"
)

func main() {
    schemaJSON := `{
        "type": "object",
        "properties": {
            "id": { "type": "integer" },
            "status": { "enum": ["active", "inactive"] }
        },
        "required": ["id", "status"]
    }`

    compiler := jsonschema.NewCompiler()
    compiler.AddResource("schema.json", strings.NewReader(schemaJSON))
    schema, _ := compiler.Compile("schema.json")

    // Valid data
    data := map[string]interface{}{"id": 1, "status": "active"}
    err := schema.Validate(data)
    fmt.Println(err) // → <nil>

    // Invalid — missing "status"
    bad := map[string]interface{}{"id": 2}
    err = schema.Validate(bad)
    fmt.Println(err) // → validation failed: missing properties: 'status'
}

# Install via pip
pip install check-jsonschema

# Validate a file against a schema
check-jsonschema --schemafile schema.json data.json
# → ok -- validation done

# Validate against a remote schema (e.g., GitHub Actions workflow)
check-jsonschema --builtin-schema vendor.github-workflows my-workflow.yml

# Validate multiple files at once
check-jsonschema --schemafile schema.json file1.json file2.json file3.json

Preguntas frecuentes