Validateur JSON Schema

Qu'est-ce que la validation par JSON Schema ?

La validation par JSON Schema est le processus qui consiste à vérifier qu'un document JSON est conforme à un ensemble de contraintes structurelles et de valeurs définies dans un JSON Schema. Le schéma lui-même est un document JSON qui décrit la forme attendue de vos données : quelles propriétés sont requises, quels types elles doivent avoir, les plages autorisées pour les nombres, les patterns de chaînes, les longueurs de tableaux, et bien plus. La spécification JSON Schema est maintenue sur json-schema.org et publiée sous forme de séries de brouillons IETF — Draft 7 et Draft 2020-12 sont les plus largement adoptés.

Là où la validation JSON simple ne vérifie que la syntaxe (les accolades sont-elles appariées ? les chaînes sont-elles entre guillemets ?), la validation par schéma va plus loin. Elle répond à des questions comme : la réponse de cette API contient-elle un champ "id" qui est toujours un entier ? Le champ "status" est-il l'une des trois valeurs autorisées ? Les objets imbriqués ont-ils la bonne forme ? Ce type de vérification structurelle détecte des bugs que les vérifications syntaxiques manquent entièrement, car un JSON syntaxiquement valide peut encore être sémantiquement incorrect pour votre application.

JSON Schema est utilisé dans les définitions OpenAPI/Swagger, la validation de fichiers de configuration, la validation de formulaires, les contraintes de documents en base de données et les tests automatisés. Des outils comme Ajv (JavaScript), jsonschema (Python) et check-jsonschema (CLI) implémentent la spécification pour valider des données par programmation. Ce validateur en ligne vous permet de coller un schéma et un document de données pour vérifier la conformité instantanément, sans installer de bibliothèque.

Pourquoi utiliser un validateur JSON Schema en ligne ?

Écrire des schémas et déboguer les erreurs de validation manuellement est lent. Un validateur JSON Schema en ligne vous donne un retour instantané sur la conformité de vos données à votre schéma, avec des messages d'erreur précis indiquant la propriété exacte qui a échoué.

Cas d'utilisation de la validation JSON Schema

Référence des mots-clés JSON Schema

Un JSON Schema est construit à partir de mots-clés qui imposent chacun une contrainte sur les données validées. Le tableau ci-dessous liste les mots-clés les plus utilisés dans Draft 7 et les versions ultérieures. Chaque mot-clé peut être combiné avec d'autres dans le même objet de schéma.

Comparaison des versions JSON Schema : Draft 7 vs 2019-09 vs 2020-12

JSON Schema a traversé plusieurs versions de brouillon. Draft 7 (publié en 2018) est le plus largement supporté par les outils. Draft 2019-09 a introduit $defs (remplaçant definitions), unevaluatedProperties et $recursiveRef. Draft 2020-12 (la dernière version stable) a remplacé $recursiveRef par $dynamicRef et introduit prefixItems pour la validation de tuples. Lors du choix d'un brouillon, vérifiez que votre bibliothèque de validation le supporte. Ajv supporte les trois brouillons. La bibliothèque jsonschema de Python supporte jusqu'à 2020-12 depuis la version 4.0.

Exemples de code

Ces exemples montrent comment valider du JSON par rapport à un schéma par programmation. Chacun utilise une bibliothèque bien maintenue pour son écosystème de langage.

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

Questions fréquemment posées