Générateur de JSON Schema Gratuit

Générez un JSON Schema à partir de vos données JSON automatiquement. Gratuit, rapide et entièrement dans votre navigateur, sans inscription.

Mis à jour le

Share:
Lire le guide: How to Generate a JSON Schema from a Sample Payload
Home/Developer Tools/JSON Schema Generator

JSON Schema Generator

Generate JSON Schema with format detection, constraints, and support for multiple draft versions.

Generation Options
Show

JSON Input

Generated Schema
12 props, depth 2

{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "type": "object",
  "properties": {
    "id": {
      "type": "string",
      "format": "uuid",
      "minLength": 1,
      "maxLength": 255,
      "description": "Id"
    },
    "name": {
      "type": "string",
      "minLength": 1,
      "maxLength": 255,
      "description": "Name"
    },
    "email": {
      "type": "string",
      "format": "email",
      "minLength": 1,
      "maxLength": 255,
      "description": "Email"
    },
    "age": {
      "type": "integer",
      "minimum": 0,
      "maximum": 1000000,
      "description": "Age"
    },
    "isActive": {
      "type": "boolean",
      "description": "Is active"
    },
    "website": {
      "type": "string",
      "format": "uri",
      "minLength": 1,
      "maxLength": 255,
      "description": "Website"
    },
    "createdAt": {
      "type": "string",
      "format": "date-time",
      "minLength": 1,
      "maxLength": 255,
      "description": "Created at"
    },
    "tags": {
      "type": "array",
      "items": {
        "type": "string",
        "format": "hostname",
        "minLength": 1,
        "maxLength": 255,
        "description": "Item0"
      },
      "minItems": 1,
      "maxItems": 100,
      "uniqueItems": true,
      "description": "Tags"
    },
    "address": {
      "type": "object",
      "properties": {
        "street": {
          "type": "string",
          "minLength": 1,
          "maxLength": 255,
          "description": "Street"
        },
        "city": {
          "type": "string",
          "minLength": 1,
          "maxLength": 255,
          "description": "City"
        },
        "zipCode": {
          "type": "string",
          "format": "hostname",
          "minLength": 1,
          "maxLength": 255,
          "description": "Zip code"
        }
      },
      "additionalProperties": false,
      "required": [
        "street",
        "city",
        "zipCode"
      ],
      "description": "Address"
    }
  },
  "additionalProperties": false,
  "required": [
    "id",
    "name",
    "email",
    "age",
    "isActive",
    "website",
    "createdAt",
    "tags",
    "address"
  ]
}

Questions Fréquentes

Qu'est-ce que le JSON Schema Generator ?

Le JSON Schema Generator est un outil en ligne gratuit qui crée automatiquement des définitions JSON Schema à partir de données JSON d'exemple, pour la validation et la documentation d'API.

Le JSON Schema Generator est-il gratuit ?

Oui, il est entièrement gratuit et ne nécessite aucune inscription. Toute la génération du schéma s'effectue côté client, dans votre navigateur.

Mes données JSON sont-elles stockées ?

Non, tout le traitement s'effectue localement dans votre navigateur. Vos données JSON ne sont jamais envoyées à un serveur.

Le JSON Schema Generator fonctionne-t-il sur les appareils mobiles ?

Oui, le JSON Schema Generator est entièrement responsive et fonctionne sur smartphones et tablettes. Vous pouvez l'utiliser sur n'importe quel appareil doté d'un navigateur web moderne, sans aucune application à télécharger.

Dois-je créer un compte pour utiliser cet outil ?

Aucun compte ni inscription n'est nécessaire. Ouvrez simplement le JSON Schema Generator dans votre navigateur et commencez à l'utiliser immédiatement. Il n'y a ni page d'inscription ni restriction d'utilisation.

Quels langages de programmation ou formats prend-il en charge ?

Le JSON Schema Generator prend en charge un large éventail de formats et de langages populaires. Consultez l'interface de l'outil pour la liste complète des options prises en charge.

Comment utiliser le JSON Schema Generator ?

Saisissez simplement votre contenu dans le champ prévu, ajustez les paramètres selon vos préférences, et l'outil le traitera instantanément. Vous pouvez ensuite copier le résultat dans le presse-papiers ou le télécharger.

Quels navigateurs sont pris en charge ?

Le JSON Schema Generator fonctionne dans tous les navigateurs modernes, dont Chrome, Firefox, Safari, Edge et Opera. Pour une expérience optimale, utilisez la dernière version de votre navigateur préféré.

Quelle est la différence entre JSON et JSON Schema ?

JSON est la donnée elle-même — l'objet réel avec ses vraies valeurs, comme une fiche utilisateur ou une réponse d'API. JSON Schema est un document distinct qui décrit la forme de cette donnée : quels champs existent, quel type a chacun d'eux (string, integer, boolean, array, object), lesquels sont obligatoires, et quelles valeurs sont autorisées. Imaginez le JSON comme un formulaire rempli et le JSON Schema comme le modèle vierge accompagné de ses règles. Les validateurs lisent le schéma pour vérifier qu'une charge JSON donnée s'y conforme avant que votre code ne lui fasse confiance, ce qui permet aux API de détecter tôt les requêtes malformées. On écrit du JSON à la main en permanence, mais rédiger le schéma correspondant devient fastidieux dès que les données sont imbriquées. Cet outil inverse la logique : collez un exemple d'objet JSON et il en déduit un schéma complet que vous n'avez plus qu'à affiner.

Quelle version de draft JSON Schema dois-je choisir ?

Ce générateur cible quatre drafts, et le bon choix dépend de votre validateur. Draft-07 est la valeur par défaut recommandée pour les nouveaux projets — c'est la plus largement prise en charge par des bibliothèques comme Ajv, et c'est celle que la plupart des tutoriels supposent. Ne choisissez Draft-04 que si vous travaillez avec des outils anciens ou historiques qui n'ont pas été mis à jour. Draft-2019-09 a introduit $defs et les références récursives, tandis que Draft-2020-12 est la plus récente et utilise des mots-clés de tableau mis à jour ainsi que $dynamicRef ; optez pour ces versions lorsque votre stack les prend explicitement en charge ou que vous avez besoin de leurs nouveautés. Changer la version ici met à jour l'URL $schema en haut du résultat, afin que votre validateur charge le bon jeu de règles. En cas de doute, commencez par Draft-07 dans le sélecteur de version et changez plus tard si un outil s'en plaint.

Pourquoi le schéma généré inclut-il additionalProperties: false ?

Par défaut, cet outil ajoute additionalProperties: false à chaque objet, ce qui indique à un validateur de rejeter toute charge contenant des clés absentes de votre échantillon. C'est un point de départ délibérément strict : il verrouille le contrat sur exactement les champs que vous avez fournis, si bien que des clés inattendues ou mal orthographiées échouent à la validation au lieu de passer inaperçues. C'est idéal pour les API internes où vous voulez une forme précise et prévisible. Cela peut toutefois être trop rigide pour des API publiques ou évolutives susceptibles d'ajouter des champs optionnels au fil du temps — dans ce cas, un nouveau champ casserait les clients utilisant le schéma strict. La solution est simple : supprimez cette ligne ou passez-la à true pour autoriser des propriétés supplémentaires. Générez votre schéma ici, puis assouplissez additionalProperties sur les objets où votre API permet réellement l'extension.

Comment l'outil détermine-t-il quels champs sont obligatoires ?

Le générateur liste chaque clé non nulle de votre échantillon dans le tableau required du schéma, en partant du principe qu'un champ présent dans votre exemple est censé être présent dans les données réelles. Il sépare également integer de number afin que les nombres entiers soient typés avec précision, et avec la détection de format activée, il identifie les chaînes correspondant à des motifs connus comme email, uri, date-time, uuid, ipv4 et ipv6. La mise en garde importante est que les champs obligatoires reflètent un seul échantillon. Si une clé se trouve être absente ou nulle dans une charge mais optionnelle en pratique, l'outil ne peut pas le savoir à partir d'un seul exemple — vérifiez donc la liste required et retirez les champs réellement optionnels avant de mettre en production. Considérez le résultat comme un solide premier jet. Collez votre échantillon le plus complet et le plus représentatif pour obtenir de cet outil l'inférence des champs obligatoires la plus précise.

Les contraintes minLength et minimum du schéma sont-elles utilisables telles quelles ?

Pas sans vérification. Lorsque vous activez les contraintes, l'outil définit des bornes déduites de votre échantillon — minLength et maxLength pour les chaînes, minimum et maximum pour les nombres, ainsi que minItems, maxItems et uniqueItems pour les tableaux dont les éléments de l'échantillon sont tous distincts. Ces valeurs sont calculées à partir d'un seul exemple : elles décrivent ce que votre échantillon contenait, pas les véritables règles métier. Par exemple, si le nom d'utilisateur de votre échantillon comptait huit caractères, maxLength pourrait être fixé à huit alors que des noms plus longs sont valides, ce qui rejetterait à tort de vraies données. Considérez chaque contrainte générée comme une valeur par défaut raisonnable à resserrer ou assouplir, jamais comme une règle définitive. Le badge de statistiques affichant le nombre de propriétés et la profondeur d'imbrication vous aide à confirmer que la structure correspond à vos attentes. Générez le schéma ici, puis ajustez les bornes selon les plages de vos données réelles avant de le déployer.

À propos du générateur de JSON Schema

Le générateur de JSON Schema transforme un exemple de données JSON en une définition JSON Schema complète. Collez une vraie réponse d'API, un fichier de configuration ou n'importe quel objet JSON, et l'outil déduit pour vous les types, la structure et les contraintes — puis affiche un schéma prêt à l'emploi que vous pouvez copier ou télécharger. Il est conçu pour les développeurs backend et API, les ingénieurs d'intégration, et toute personne qui a besoin d'un contrat pour ses données sans vouloir écrire un schéma imbriqué à la main.

JSON Schema est le vocabulaire standard pour décrire la forme d'un JSON : quels champs existent, quel type a chacun d'eux, lesquels sont obligatoires, et quelles valeurs sont autorisées. L'écrire à la main est fastidieux et source d'erreurs dès que l'objet n'est plus plat. Ce générateur fait automatiquement les 90 premiers pour cent du travail, pour que vous puissiez peaufiner les 10 derniers pour cent.

Tout s'exécute dans votre navigateur. Le JSON que vous collez est analysé sur votre propre appareil — il n'est jamais envoyé vers un serveur. Vous pouvez donc y coller sans risque une charge utile de production, un exemple d'API interne, ou une configuration avec des secrets fictifs, sans que rien ne quitte votre machine. Pas d'inscription, pas de limite d'utilisation, rien à installer.

Ce que l'outil génère à partir de votre JSON

Le générateur parcourt vos données de façon récursive et construit un schéma typé qui reflète leur structure :

  • Inférence de type — distingue string, boolean, null, array et object, et sépare integer de number afin que les nombres entiers soient typés avec précision.
  • Objets et tableaux imbriqués — descend à chaque niveau, en produisant un bloc properties pour chaque objet et un schéma items pour les tableaux en fonction des éléments trouvés.
  • Champs obligatoires — liste les clés non nulles sous required, puisque leur présence dans votre échantillon laisse supposer qu'elles sont attendues.
  • Titre et description — ajoutez un titre et une description optionnels au schéma, ou laissez l'outil générer des descriptions par propriété à partir des noms de champs (ainsi createdAt devient « Created at »).

Par défaut, l'outil définit aussi additionalProperties: false, ce qui verrouille le schéma sur exactement les clés présentes dans votre échantillon — un point de départ strict que vous pouvez assouplir si votre API accepte des champs supplémentaires.

Détection de format et contraintes

Au-delà des types bruts, le générateur reconnaît les formats de chaînes courants et ajoute des indices de validation. Activez la détection de format et il identifiera les chaînes correspondant à des motifs connus : email, uri, date-time, date, time, uuid, ipv4, ipv6 et hostname. Ainsi, une valeur comme john@example.com sera typée comme une chaîne avec "format": "email", et un UUID sera reconnu automatiquement.

Activez les contraintes et l'outil définira des bornes que vous pourrez affiner ensuite : minLength/maxLength pour les chaînes, minimum/maximum pour les nombres, et minItems/maxItems ainsi que uniqueItems pour les tableaux lorsque les éléments de l'échantillon sont tous distincts. Ces valeurs sont déduites de votre exemple : considérez-les comme des valeurs par défaut raisonnables plutôt que comme des règles définitives.

Choisir une version de draft

JSON Schema a évolué à travers plusieurs versions de spécification (drafts), et les validateurs ne prennent pas tous en charge les mêmes. Le générateur vous permet d'en cibler quatre :

  • Draft-04 — la plus ancienne, encore largement intégrée dans les outils historiques.
  • Draft-07 — la plus couramment utilisée et la valeur par défaut recommandée pour les nouveaux projets.
  • Draft-2019-09 — a introduit $defs et les références récursives.
  • Draft-2020-12 — la plus récente, avec $dynamicRef et des mots-clés de tableau mis à jour.

Changer de version met à jour l'URL $schema en haut du résultat, afin que votre validateur charge les bonnes règles. Un badge de statistiques en direct affiche le nombre total de propriétés et la profondeur d'imbrication, un contrôle en un coup d'œil pour vérifier qu'une charge utile volumineuse a bien généré la structure attendue.

Un schéma généré est un solide premier jet, pas une vérité absolue : les types et les champs obligatoires reflètent un seul échantillon, alors vérifiez le caractère optionnel des champs et resserrez les contraintes au regard de vos données réelles avant de l'utiliser comme contrat d'API. Utilisez le bouton Format intégré pour nettoyer une saisie désordonnée, puis copiez ou téléchargez le résultat sous forme de fichier .json prêt à intégrer dans votre couche de validation ou votre définition OpenAPI.