Validateur JSON Schema

Qu'est-ce qu'un Validateur JSON Schema ?

// A 5-line schema that catches three real bugs
const schema = {
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "type": "object",
  "properties": {
    "id":    { "type": "integer", "minimum": 1 },
    "email": { "type": "string", "format": "email" },
    "age":   { "type": "integer", "minimum": 0, "maximum": 150 }
  },
  "required": ["id", "email"],
  "additionalProperties": false
};

// Three bugs the schema catches:
const bad = { "id": "42", "age": 200 };
//   /id   → type: expected integer, got string
//   /email → required: missing
//   /age   → maximum: 200 > 150

// In Node:        new Ajv().compile(schema)(bad)  // false; ajv.errors has the paths
// In Python:      jsonschema.validate(bad, schema)
// In the browser: this tool — same errors, same paths, no install

Fonctionnalités clés

Exemples

{
  "id": 42,
  "email": "alice@example.com",
  "age": 30
}

{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "type": "object",
  "properties": {
    "id": { "type": "integer", "minimum": 1 },
    "email": { "type": "string", "format": "email" },
    "age": { "type": "integer", "minimum": 0, "maximum": 150 }
  },
  "required": ["id", "email"],
  "additionalProperties": false
}

{
  "id": "42",
  "age": 200
}

{
  "type": "object",
  "properties": {
    "id": { "type": "integer" },
    "email": { "type": "string", "format": "email" },
    "age": { "type": "integer", "maximum": 150 }
  },
  "required": ["id", "email"]
}

{
  "type": "order.created",
  "data": { "orderId": "ORD-001234", "totalUsd": 49.99 }
}

{
  "oneOf": [
    {
      "properties": {
        "type": { "const": "order.created" },
        "data": {
          "type": "object",
          "properties": {
            "orderId": { "type": "string", "pattern": "^ORD-[0-9]{6}$" },
            "totalUsd": { "type": "number", "minimum": 0 }
          },
          "required": ["orderId", "totalUsd"]
        }
      },
      "required": ["type", "data"]
    },
    {
      "properties": {
        "type": { "const": "order.refunded" },
        "data": { "type": "object", "required": ["refundId"] }
      },
      "required": ["type", "data"]
    }
  ]
}

[
  { "sku": "A1", "qty": 3 },
  { "sku": "B2", "qty": 5 },
  { "sku": "A1", "qty": 3 }
]

{
  "type": "array",
  "minItems": 1,
  "uniqueItems": true,
  "items": {
    "type": "object",
    "properties": {
      "sku": { "type": "string", "pattern": "^[A-Z][0-9]+$" },
      "qty": { "type": "integer", "minimum": 1 }
    },
    "required": ["sku", "qty"]
  }
}

Comment utiliser

1. 1

   Collez votre JSON Schema

   Déposez votre schéma dans le panneau de droite. Le validateur détecte automatiquement le draft à partir de l'URI $schema s'il est présent ; sinon, choisissez Draft 2020-12, 2019-09 ou Draft-07 dans la barre d'outils.

2. 2

   Collez vos données JSON

   Déposez le document JSON à vérifier dans le panneau de gauche. La validation s'exécute pendant que vous tapez ; les grandes entrées (>200 Ko) basculent sur un bouton Validate manuel pour garder la frappe réactive.

3. 3

   Lisez la liste des erreurs

   Chaque erreur a un chemin JSON Pointer, un mot-clé et un message en une ligne. Cliquez sur une erreur pour sauter à l'emplacement dans vos données, corrigez-la et regardez le compteur baisser en temps réel.

Pièges courants de JSON Schema

{ "qty": 1.0 }   schema: { "type": "integer" }   → error: not an integer

{ "qty": 1 }     schema: { "type": "integer" }   → valid

{ "properties": { "name": { "type": "string", "required": true } } }

{ "properties": { "name": { "type": "string" } }, "required": ["name"] }

{ "properties": { "id": { "type": "integer" } } }   accepts: { "id": 1, "foo": "bar", "x": null }

{ "properties": { "id": { "type": "integer" } }, "additionalProperties": false }

{ "type": "string", "nullable": true }   in 2020-12: nullable is just an unknown keyword

{ "type": ["string", "null"] }   in 2020-12: explicitly allows null

pattern: "[A-Z]+"   accepts: "helloX"   (because X matches)

pattern: "^[A-Z]+$"   accepts only: "HELLO"

oneOf: [ { type: "string" }, { type: "string", maxLength: 10 } ]   on: "hi"   → error: matches both

anyOf: [ { type: "string" }, { type: "string", maxLength: 10 } ]   on: "hi"   → valid

Cas d'usage courants

Validation de requête API

Collez un corps de requête et le schéma de votre endpoint avant le déploiement. Attrapez les réponses 400 que vos tests n'ont pas couvertes — champs requis manquants, types incorrects, nombres hors plage.

Vérification de payload webhook

Le fournisseur a envoyé un payload que votre handler rejette ? Validez le payload réel contre votre schéma, puis contre le schéma publié du fournisseur. La différence entre les deux, c'est votre bug.

Linting de fichiers de configuration

package.json, tsconfig.json, helm values.yaml — chaque fichier de configuration a un schéma public. Collez le schéma, collez la configuration, trouvez la faute de frappe. Évitez l'essai-erreur.

Test de composant OpenAPI

Extrayez un composant de schéma d'un document OpenAPI 3.1, collez-le ici, validez des payloads d'exemple. Plus rapide que de monter un serveur mock, déterministe, sans SDK.

Pré-vol de soumission de formulaire

Collez un payload de formulaire d'exemple avant de câbler la validation côté frontend. Confirmez que le schéma rejette ce qu'il faut et accepte ce qu'il faut, puis envoyez le même schéma au client et au serveur.

Vérification de contrat de pipeline de données

La sortie ETL a dérivé ? Collez une ligne d'exemple et le schéma en aval. Identifiez quel producteur a changé et quelles clés sont cassées avant que le pipeline ne reprenne 10 000 enregistrements.

Détails techniques

Conforme Draft 2020-12

Implémente la spécification Draft 2020-12 publiée — mots-clés, système de types, vocabulaire format. Vérifié contre la sortie d'Ajv 8.x et ajv-formats.

Chemins d'erreur JSON Pointer

Les erreurs utilisent JSON Pointer RFC 6901 (/user/email/0). Chaque échec de mot-clé pointe vers un emplacement résolvable unique dans les données — pas d'ambiguïté, pas de recherche par chaîne.

Résolution interne des $ref

Résout les pointeurs $ref dans un seul document (#/$defs/foo, #/properties/bar). Les cycles sont détectés et signalés. Les $ref HTTP externes sont désactivés pour la confidentialité.

Bonnes pratiques

Activez toujours additionalProperties: false

Sur les contrats d'entrée (corps de requête, fichiers de configuration, messages de file), les clés inconnues sont généralement des bugs — fautes de frappe, champs accidentels ou sondages d'attaquant. Rejetez-les par défaut.

Utilisez $defs pour les sous-schémas réutilisables

Inlinez la même forme deux fois et elle dérive. Déplacez les définitions partagées dans $defs et référencez avec $ref — une seule source de vérité, chaque changement s'applique partout.

Validez avant la logique métier

Lancez la validation de schéma juste après JSON.parse, avant de toucher à la structure analysée. Le rétrécissement de types, les valeurs par défaut et la persistance supposent tous que le contrat tient — assurez-vous qu'il tient.

Foire aux questions