Générateur de JSON Schema
Générer automatiquement des définitions JSON Schema conformes aux normes à partir de données JSON
// Le JSON Schema sera généré automatiquementQu'est-ce que JSON Schema ?
JSON Schema est une spécification pour décrire et valider des structures de données JSON. Il définit des règles pour la structure, les types de données, les contraintes et est largement utilisé pour la validation d'API, la validation de formulaires, la vérification de fichiers de configuration.
Avec JSON Schema, vous pouvez :
- Validation des données : Vérifier que les données JSON correspondent au format et aux contraintes attendus
- Génération de documentation : Générer automatiquement la documentation API et les définitions de types
- Intelligence de code : Obtenir une complétion intelligente et une vérification de type dans les IDE
- Tests automatisés : Valider automatiquement le format des données de réponse dans les tests
Cet outil prend en charge la spécification JSON Schema Draft-07, déduisant intelligemment les objets imbriqués, les types de tableau, les valeurs enum et autres structures complexes.
Comment utiliser
Comment utiliser
- Collez des données JSON dans la zone de saisie de gauche, ou cliquez sur « Sample » pour charger un exemple
- Configurez les options : définissez l'identifiant du Schema, choisissez si tous les champs sont requis, ajoutez des valeurs par défaut, etc.
- La définition JSON Schema correspondante est générée automatiquement à droite
- Cliquez sur « Copy » pour copier le Schema généré dans le presse-papiers
- Utilisez le Schema pour la validation d'API, de formulaires ou de fichiers de configuration
Conseils pour les Schema
- Les schémas générés reflètent l'échantillon JSON fourni ; veillez à inclure des champs optionnels représentatifs, des valeurs null, des tableaux et des cas limites avant de copier le résultat.
- Vérifiez manuellement les champs requis et les formats numérique/chaîne ; l'inférence à partir d'un échantillon ne peut pas toujours deviner vos règles métier.
Cas d’utilisation
Principe technique
JSON Schema est un vocabulaire déclaratif pour annoter et valider des documents JSON, défini à travers plusieurs brouillons IETF (Draft 4 / 6 / 7 / 2019-09 / 2020-12). Le plus récent est le Draft 2020-12, qui définit sept types primitifs (string, number, integer, boolean, array, object, null), un vocabulaire de formats ouvert (email, uri, date-time, uuid, ipv4, hostname, ...) et des dizaines de mots-clés de contrainte : pattern (regex), minimum/maximum/exclusiveMinimum/exclusiveMaximum (plage numérique), minLength/maxLength (longueur de chaîne), minItems/maxItems/uniqueItems (contraintes de tableau), required (tableau required au niveau objet), additionalProperties (si des champs supplémentaires sont autorisés), enum et const (valeurs autorisées), et $ref (réutilisation de sous-schémas). La page génère par défaut une sortie Draft 2020-12, avec l'ancien Draft-07 (encore le plus courant dans les schémas de production) sélectionnable depuis le menu déroulant. L'inférence du générateur est un passage unique sur le JSON fourni par l'utilisateur, construisant un objet schéma de manière récursive. La table au cœur de l'inférence est : entier (Number.isInteger et sans partie fractionnaire) -> {type: 'integer'}, flottant -> {type: 'number'}, chaîne -> {type: 'string'}, booléen -> {type: 'boolean'}, tableau -> {type: 'array', items: <récursion sur le premier élément>} ou {type: 'array', prefixItems: [...]} pour les tuples dans le Draft 2020-12, objet -> {type: 'object', properties: <récursion sur chaque clé>}, null -> {type: 'null'}. Pour les tableaux à types d'éléments mélangés, le générateur émet un sous-schéma oneOf couvrant chaque type observé. Pour plusieurs objets d'échantillon, le générateur les compare pour assembler la liste des champs requis : un clé est requise si elle apparaît dans chaque échantillon, optionnelle si un échantillon l'omet. Les patterns et contraintes sont inférés lorsque les échantillons se regroupent : si tous les nombres d'un champ tombent dans [1, 100], le générateur émet {type: 'integer', minimum: 1, maximum: 100} ; si un champ chaîne est toujours un UUID, le générateur le marque avec format: 'uuid' et émet un pattern regex : '^[0-9a-f]{8}-...'. L'heuristique d'enum se déclenche lorsqu'un champ chaîne prend au plus 10 valeurs distinctes dans les échantillons (par ex. role : 'admin' | 'editor' | 'viewer' tous observés), auquel cas le générateur émet un tableau enum. Les objets profondément imbriqués et les structures récursives sont extraits dans une section $defs (Draft 2020-12 ; l'ancien $definitions est le mot-clé du Draft-07) et référencés via $ref. Les structures récursives — par ex. un nœud d'arbre avec un champ 'children' de type nœud d'arbre — reçoivent un stub $ref pointant vers l'entrée $defs du parent, que le validateur résout au moment de la validation. Le générateur choisit automatiquement le bon compromis ref vs inline : les schémas peu profonds restent inline, les profonds sont découpés en définitions pour garder la sortie lisible. Les schémas générés sont déterministes pour une entrée donnée : les mêmes échantillons JSON produisent toujours le même schéma, et le générateur est implémenté en JavaScript pur sans appels distants.
- Règles d'inférence de type : nombres entiers -> integer, nombres à virgule flottante -> number, chaînes -> string, booléens -> boolean, tableaux -> array + items, objets -> object + properties. JSON null -> type : null (Draft 6+) ou type : 'null' en chaîne.
- Détection des champs requis : en comparant tous les objets d'échantillon, les champs présents dans chaque objet sont traités comme requis et ajoutés au tableau required ; ceux manquants sont optionnels. Une entrée à un seul échantillon laisse required : [] car l'heuristique nécessite au moins deux échantillons.
- Heuristique d'inférence d'enum : lorsqu'un champ prend un petit ensemble fini de valeurs de chaîne distinctes dans les échantillons (cardinalité <= 10), il est automatiquement reconnu comme une contrainte enum. Les cardinalités plus grandes restent en type chaîne simple.
- Format auto-détecté : basé sur les signatures de chaînes, les champs sont marqués avec des indices de format comme email, uri, date-time, uuid pour la documentation et la validation. Le mot-clé format est informatif dans le Draft 2020-12 — les validateurs peuvent choisir de l'appliquer ou de l'ignorer.
- Extraction de $ref imbriqués : les objets profondément imbriqués sont extraits dans des $defs internes (mot-clé du Draft 2020-12 ; l'ancien $definitions vient du Draft 7) et référencés via $ref, empêchant le Schéma de devenir trop verbeux. Les structures récursives reçoivent un stub $ref pointant vers l'entrée $defs du parent.
- Extension des contraintes : au-delà des types de base, vous pouvez aussi ajouter minimum/maximum (plage numérique), minLength/maxLength (longueur de chaîne), pattern (regex) et des contraintes similaires. Le générateur les émet lorsque les échantillons d'entrée se regroupent sur des valeurs spécifiques.
- Choix du draft : 2020-12 (le plus récent) est la valeur par défaut et utilise $defs ; 2019-09 utilise aussi $defs ; Draft-07 utilise $definitions et est ce que la plupart des outils existants émettent encore. Le Draft 6 a introduit la sémantique strict-required où les champs requis sont listés dans le tableau required du parent plutôt que comme propriété sœur.
- Mots-clés de composition (Draft 2019-09+) : allOf (doit correspondre à tous les sous-schémas), anyOf (au moins un), oneOf (exactement un), not (ne doit pas correspondre). Le générateur choisit oneOf lorsque les valeurs d'échantillon correspondent à deux sous-schémas disjoints (par ex. integer vs string).
Exemples
Objet simple -> Schéma
{"name": "Alice", "age": 25}
->
{
"type": "object",
"properties": {
"name": { "type": "string" },
"age": { "type": "integer" }
},
"required": ["name", "age"]
}Schéma avec tableau
{"tags": ["js", "ts"]}
->
{
"type": "object",
"properties": {
"tags": {
"type": "array",
"items": { "type": "string" }
}
}
}Schéma avec énumération
{"role": "admin"}
->
{
"type": "object",
"properties": {
"role": { "type": "string", "enum": ["admin", "user", "guest"] }
}
}FAQ
Qu'est-ce que JSON Schema ?
JSON Schema (actuellement le draft 2020-12) est un vocabulaire pour valider des documents JSON. Il décrit la forme attendue d'un document — quels champs existent, leurs types, plages et motifs — à la manière de XML Schema ou des types TypeScript. Des outils comme Ajv, Hyperjump et la plupart des frameworks d'API le consomment pour la validation à l'exécution.
Quel draft JSON Schema le générateur produit-il ?
Les drafts modernes (typiquement 2020-12 ou draft-07). La sortie commence par $schema déclarant la version, $id le cas échéant, type, et les mots-clés appropriés pour les objets, tableaux, chaînes, nombres, booléens, null. Modifiez l'option de draft si votre validateur exige une version antérieure spécifique.
Comment infère-t-il les types à partir d'un échantillon JSON ?
Il parcourt l'échantillon en enregistrant le type de chaque propriété. Pour les tableaux, il infère le schéma items à partir d'un ou plusieurs éléments (en prenant l'union si les éléments diffèrent). Pour les propriétés de types mixtes, il utilise oneOf ou anyOf. Le résultat est un schéma de départ permissif ; resserrez les contraintes (required, minLength, pattern) à la main.
Toutes les propriétés sont-elles marquées comme requises ?
Configurable. Par défaut, chaque propriété observée est marquée comme requise. Activez « toutes optionnelles » si votre échantillon n'est qu'un seul exemple et que d'autres instances peuvent légitimement omettre des champs. Vous pouvez modifier le tableau required après génération.
Comment les objets et tableaux imbriqués sont-ils traités ?
Les objets imbriqués deviennent des blocs « properties » imbriqués ; les tableaux deviennent des définitions « items ». L'imbrication profonde fonctionne sans problème. Si la même forme apparaît plusieurs fois, vous pouvez refactoriser ensuite avec $defs / $ref — le générateur ne déduplique pas automatiquement.
Que ne peut-il pas inférer à partir des échantillons ?
Les contraintes de format (date-time, email, uuid), l'appartenance à un enum, les motifs regex, minimum/maximum, minItems/maxItems et les dépendances doivent être ajoutés à la main, car un seul échantillon ne les révèle pas. Utilisez le schéma généré comme squelette, puis resserrez-le.
Mon JSON est-il téléversé ?
Non. L'inférence s'exécute localement. Le JSON collé ne quitte pas votre navigateur.