Validar JSON contra un esquema
Sepa si un registro cumple las reglas que debe seguir: en el ejemplo, Ada con 37 años y las etiquetas math y code cumple todas las reglas, así que la lista de problemas vuelve vacía. Cuando algo falla, recibe todos los problemas de una vez. Gratis en su navegador.
- Gratis
- Funciona en su navegador
- Sin registro
- Sus datos no salen de su equipo
Ejecutar — gratis
Corre en su navegador. Gratis y sin límite: sus datos no salen de esta página.
Un identificador ausente, una propiedad inesperada, una cadena demasiado corta o un número fuera del intervalo permitido pueden interrumpir una importación mucho después del análisis sintáctico. Cada incidencia incluye la ruta del documento, la ruta del esquema, la palabra clave y una explicación clara, para que usted pueda localizar de inmediato el campo que debe corregir.
Bien escrito no es lo mismo que correcto
Unos datos pueden leerse perfectamente y aun así ser incorrectos para el sistema que los recibe. Un identificador que falta, una entrada inesperada, un texto demasiado corto o un número fuera de su margen pueden romper una importación mucho después de que los datos se leyeran sin problemas. Leerlos solo comprueba que la puntuación está en orden. El esquema es donde viven las expectativas reales: qué entradas deben estar, qué tipo de valor lleva cada una, qué límites se aplican y si se admite algo más. Esta herramienta compara los datos con ese esquema y enumera todas las infracciones que encuentra, sin detenerse en la primera.
Cómo leer el resultado y aprovecharlo
Una lista de problemas vacía significa que se cumplió cada regla, como en el ejemplo: Ada, de 37 años, con las etiquetas math y code, satisface un esquema que pide un nombre de al menos dos letras, una edad en número entero que no baje de cero, etiquetas que no se repitan y ninguna entrada más. Cada problema indica dónde está en los datos, qué regla incumplió y un mensaje legible. Use el mensaje para las personas y la ubicación y la regla para la automatización: un formulario puede resaltar el control correspondiente y una importación puede agrupar los fallos repetidos antes de que los registros de un socio lleguen a su base de datos.
Compruebe el contrato, no solo la puntuación
No sabe si un pedido debe incluir un número, si una cantidad debe ser positiva ni si un objeto debe rechazar campos desconocidos. El resultado contiene el veredicto booleano <code>valid</code> y el array <code>violations</code>. Un array vacío indica que el documento cumple todas las restricciones evaluadas.
Si falla, se conservan todas las incidencias, en lugar de detenerse en la primera. Se admiten tipos, propiedades obligatorias y dependientes, propiedades adicionales, elementos de arrays, longitudes, patrones, límites numéricos, constantes, enumeraciones, referencias locales y composiciones.
Interprete las rutas de las infracciones sin adivinar
La cadena vacía identifica la raíz; <code>/customer/email</code> señala el correo dentro de customer; y <code>/lines/2/quantity</code> señala quantity en el tercer elemento. Use el mensaje para interfaces y registros, y la ruta y palabra clave para automatización. Un formulario puede asociar la incidencia con su control, mientras una canalización puede agrupar fallos recurrentes.
El orden de recorrido es determinista: el mismo documento y esquema siempre producen la misma salida.
Qué puede hacer con ella
Proteger las importaciones de datos
Valide registros de socios antes de cargarlos para evitar que campos ausentes y formas inesperadas lleguen a procesos posteriores.
Preguntas frecuentes
¿Qué devuelve una validación correcta?
Devuelve valid con valor true y un array violations vacío.
¿Se detiene ante el primer problema?
No. Informa de cada infracción con su ruta del documento, ruta del esquema, palabra clave y mensaje.
¿Cómo se lee la ubicación que acompaña a cada problema?
Una ubicación vacía se refiere al documento entero. Una ubicación como /customer/email señala el correo dentro de customer, y /lines/2/quantity señala la cantidad del tercer elemento de lines, porque las posiciones se cuentan desde cero.
¿Qué tipos de reglas puede expresar el esquema?
El tipo de cada valor, qué entradas son obligatorias o dependen de otras, si se admiten entradas inesperadas, la longitud y el patrón de los textos, los márgenes de los números, los valores fijos y las listas de valores permitidos, las reglas de los elementos de una lista y combinaciones de varias reglas.
¿Por qué unos datos que se leen bien pueden no pasar la comprobación?
Porque leerlos solo confirma que llaves, comillas y comas están en orden. No sabe que un pedido debe llevar número, que una cantidad debe ser positiva o que hay que rechazar entradas desconocidas: esas expectativas viven en el esquema.
Herramientas relacionadas
Para desarrolladores — acceso por API
Todo lo de esta página está disponible por programación. Esta sección es para equipos que quieren integrarlo en sus sistemas; el resto puede usar la herramienta de arriba sin más.
Endpoint de API
¿Prefiere automatizarlo? Un POST autenticado crea la tarea; el resultado llega por webhook o enlace firmado. La misma capacidad también se ejecuta aquí en la web, por email y desde Telegram — y pronto también desde nuestra app.
Llámela desde su stack
curl -X POST https://api.kit.forhosting.com/data/json-schema-validate \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"document":{"name":"Ada","age":37},"schema":{"type":"object","required":["name"],"properties":{"name":{"type":"string"}}}}'const res = await fetch("https://api.kit.forhosting.com/data/json-schema-validate", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"document": {
"name": "Ada",
"age": 37
},
"schema": {
"type": "object",
"required": [
"name"
],
"properties": {
"name": {
"type": "string"
}
}
}
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/data/json-schema-validate",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"document": {
"name": "Ada",
"age": 37
},
"schema": {
"type": "object",
"required": [
"name"
],
"properties": {
"name": {
"type": "string"
}
}
}
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/data/json-schema-validate", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"document":{"name":"Ada","age":37},"schema":{"type":"object","required":["name"],"properties":{"name":{"type":"string"}}}}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"document":{"name":"Ada","age":37},"schema":{"type":"object","required":["name"],"properties":{"name":{"type":"string"}}}}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/data/json-schema-validate", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Ejemplo de solicitud
{
"document": {
"name": "Ada",
"age": 37
},
"schema": {
"type": "object",
"required": [
"name"
],
"properties": {
"name": {
"type": "string"
}
}
}
}Ejemplo de respuesta
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "data.json_schema_validate",
"status": "queued",
"_links": {
"result": "/tasks/tsk_…/result"
}
}La API es asíncrona: la llamada devuelve un task_id al instante y el resultado llega por webhook. El polling está limitado a 1 req/s por tarea.
Precio
Precio publicado — sin tokens ni créditos inventados. Una tarea fallida no se cobra.
Límites
max_mb | 25 |
Errores
| HTTP | Código | Significado |
|---|---|---|
401 | unauthorized | API key ausente o inválida. |
402 | insufficient_balance | El saldo no cubre el precio de la tarea. |
404 | unknown_type | El tipo de tarea no existe. |
429 | rate_limited | Demasiadas peticiones. Use el webhook en vez de sondear. |
Notas técnicas
Un JSON puede estar perfectamente formado y, aun así, ser incorrecto para el sistema que lo recibe. Este validador compara un documento JSON con un JSON Schema y devuelve todas las infracciones detectadas en una sola respuesta.
Valide el contrato, no solo la sintaxis JSON
Un analizador JSON solo confirma que las llaves, comillas, comas y valores forman un JSON legal. JSON Schema expresa esas reglas como un contrato legible por máquinas. Envíe el documento analizado en <code>document</code> y el contrato en <code>schema</code>.
Interprete las rutas de las infracciones sin adivinar
Cada infracción incluye un <code>path</code> expresado como JSON Pointer. El escape de Pointer mantiene inequívocas incluso las propiedades con barra o virgulilla. <code>schema_path</code> apunta a la regla que originó la incidencia y <code>keyword</code> ofrece una categoría estable, como <code>required</code>, <code>type</code> o <code>minimum</code>.
Distinga un esquema mal formado de datos no válidos
Un documento no válido genera un resultado normal: la solicitud termina con <code>valid</code> en false y enumera todas las infracciones. Un esquema mal formado es distinto, porque no permite validar con garantías. Así, un contrato roto no se confunde con datos defectuosos. Si una palabra clave tiene una forma incorrecta, el tipo es desconocido, una expresión regular no compila, un límite numérico carece de sentido o una referencia local no se resuelve, la capacidad devuelve <code>invalid_input</code>. La implementación es pura y no accede a la red, por lo que no recupera referencias remotas; use referencias JSON Pointer locales que empiecen por <code>#/</code>. Resulta adecuada en límites de API, antes de importar datos, al aceptar salidas estructuradas y en canalizaciones de compilación. Las solicitudes API empiezan en $0.002, y la misma lógica puede ejecutarse en el navegador.
Casos de integración
Rechazar cargas API defectuosas
Compruebe los cuerpos de las solicitudes y devuelva rutas precisas para cada campo que los clientes deban corregir.
Comprobar JSON generado
Verifique salidas estructuradas frente a tipos, intervalos y propiedades obligatorias antes de que otro sistema actúe.
Preguntas técnicas
¿Qué ocurre si el propio esquema está mal formado?
La solicitud falla con invalid_input, porque un contrato incorrecto no permite obtener un resultado fiable.
¿Admite referencias remotas de esquemas?
No. El validador no accede a la red y admite referencias JSON Pointer locales dentro del esquema enviado.
¿Cuánto cuesta una validación por API?
Cada solicitud empieza en $0.002. El ejecutor del navegador emplea la misma lógica pura para comprobaciones interactivas.