ForHosting KIT · Données et fichiers

Valider un JSON avec un schéma

Sachez si un enregistrement respecte les règles qu'il doit suivre : dans l'exemple, Ada, 37 ans, avec les étiquettes math et code, respecte chaque règle, et la liste des problèmes revient vide. En cas d'échec, vous obtenez tous les problèmes en une fois. Gratuit dans votre navigateur.

Gratuit
Fonctionne dans votre navigateur
Sans inscription
Vos données restent sur votre appareil

Lancer gratuitement Voir l’API

Utilisez-le depuis WebAPIE-mailTelegramApp bientôt

Un identifiant absent, une propriété inattendue, une chaîne trop courte ou un nombre hors limites peut interrompre un import bien après l’analyse syntaxique. Chaque problème comprend le chemin du document, celui du schéma, le mot-clé et une explication claire, afin que vous puissiez identifier immédiatement le champ à corriger.

Bien écrit ne veut pas dire correct

Des données peuvent se lire parfaitement et pourtant être fausses pour le système qui les reçoit. Un identifiant manquant, une entrée inattendue, un texte trop court ou un nombre hors de sa plage peuvent faire échouer un import bien après une lecture sans problème. La lecture ne vérifie que la ponctuation. Le schéma porte les vraies attentes : quelles entrées doivent figurer, quelle nature de valeur chacune contient, quelles limites s'appliquent et si autre chose est permis. Cet outil compare les données à ce schéma et dresse la liste de toutes les infractions trouvées, sans s'arrêter à la première.

Lire le résultat et s'en servir

Une liste de problèmes vide signifie que chaque règle est respectée, comme dans l'exemple : Ada, 37 ans, avec les étiquettes math et code, satisfait un schéma qui demande un nom d'au moins deux lettres, un âge entier qui ne descend pas sous zéro, des étiquettes sans doublon et aucune autre entrée. Chaque problème indique son emplacement dans les données, la règle enfreinte et un message lisible. Servez-vous du message pour les personnes, de l'emplacement et de la règle pour l'automatisation : un formulaire peut mettre en évidence la zone concernée, et un import peut regrouper les échecs récurrents avant que les enregistrements d'un partenaire n'arrivent dans votre base.

Vérifiez le contrat, pas seulement la ponctuation

Il ignore qu’une commande doit avoir un numéro, qu’une quantité doit être positive ou qu’un objet doit refuser les champs inconnus. Le résultat fournit le verdict booléen <code>valid</code> et le tableau <code>violations</code>. Un tableau vide signifie que toutes les contraintes évaluées sont respectées.

En cas d’échec, tous les problèmes sont conservés au lieu de s’arrêter au premier. Le validateur couvre notamment types, propriétés obligatoires ou dépendantes, propriétés supplémentaires, éléments de tableau, longueurs, motifs, bornes numériques, constantes, énumérations, références locales et compositions de schémas.

Lisez précisément les chemins des violations

La chaîne vide désigne la racine ; <code>/customer/email</code> désigne l’adresse dans customer ; et <code>/lines/2/quantity</code> désigne quantity dans le troisième élément. Utilisez le message dans les interfaces et journaux, mais le chemin et le mot-clé dans vos traitements. Un formulaire peut rattacher un problème au bon contrôle, tandis qu’un pipeline peut regrouper les erreurs récurrentes.

L’ordre déterministe garantit une sortie identique pour le même document et le même schéma.

Cas d’usage

Sécuriser les imports de données

Validez les enregistrements partenaires avant chargement pour bloquer les champs absents et structures inattendues.

Questions fréquentes

Que renvoie une validation réussie ?

Elle renvoie valid à true et un tableau violations vide.

Le contrôle s’arrête-t-il au premier problème ?

Non. Chaque violation comporte le chemin du document, celui du schéma, le mot-clé et le message.

Comment lire l'emplacement indiqué pour chaque problème ?

Un emplacement vide désigne le document entier. Un emplacement comme /customer/email désigne l'adresse dans customer, et /lines/2/quantity désigne la quantité du troisième élément de lines, car les positions se comptent à partir de zéro.

Quels types de règles le schéma peut-il exprimer ?

La nature de chaque valeur, les entrées obligatoires ou dépendant d'autres entrées, l'acceptation ou non d'entrées inattendues, la longueur et le motif des textes, les bornes des nombres, les valeurs fixes et les listes de valeurs permises, les règles des éléments d'une liste et leurs combinaisons.

Pourquoi des données qui se lisent bien peuvent-elles échouer au contrôle ?

Parce que la lecture vérifie seulement que les accolades, guillemets et virgules sont en ordre. Elle ignore qu'une commande doit porter un numéro, qu'une quantité doit être positive ou que des entrées inconnues doivent être refusées : ces attentes figurent dans le schéma.

Outils associés

Pour les développeurs — accès API

Tout sur cette page est disponible par programmation. Cette section s'adresse aux équipes qui veulent l'intégrer à leurs systèmes ; les autres peuvent simplement utiliser l'outil ci-dessus.

Endpoint

POSThttps://api.kit.forhosting.com/data/json-schema-validate

Authentification par jeton Bearer : un seul POST met la tâche en file d’attente, et le résultat vous parvient par webhook ou lien signé.

Appeler depuis votre 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)

Exemple de requête

{
  "document": {
    "name": "Ada",
    "age": 37
  },
  "schema": {
    "type": "object",
    "required": [
      "name"
    ],
    "properties": {
      "name": {
        "type": "string"
      }
    }
  }
}

Exemple de réponse

{
  "task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
  "type": "data.json_schema_validate",
  "status": "queued",
  "_links": {
    "result": "/tasks/tsk_…/result"
  }
}

L’API est asynchrone : chaque appel renvoie un task_id immédiatement, puis vous interrogez l’état à raison d’une requête par seconde.

Tarifs

par requête$0.002

Le prix est publié, sans tokens ni crédits. Une tâche qui échoue n’est pas facturée.

Limites

max_mb 25

Erreurs

HTTP	Code	Signification
`401`	`unauthorized`	Clé API absente ou invalide : vérifiez l’en-tête Authorization.
`402`	`insufficient_balance`	Solde insuffisant : rechargez votre compte pour lancer cette tâche.
`404`	`unknown_type`	Type de tâche inconnu : vérifiez le champ type de votre requête.
`429`	`rate_limited`	Trop de requêtes : ralentissez la cadence, puis réessayez.

Notes techniques

Un JSON peut être parfaitement bien formé tout en étant incorrect pour le système qui le reçoit. Ce validateur compare un document JSON à un JSON Schema et renvoie toutes les violations détectées dans une seule réponse.

Validez le contrat, pas seulement la syntaxe JSON

Un analyseur JSON indique seulement si les accolades, guillemets, virgules et valeurs constituent un JSON légal. JSON Schema formalise ces attentes dans un contrat exploitable par une machine. Placez le document dans <code>document</code> et le contrat dans <code>schema</code>.

Lisez précisément les chemins des violations

Chaque violation possède un <code>path</code> au format JSON Pointer. L’échappement Pointer rend aussi les noms contenant une barre oblique ou un tilde non ambigus. <code>schema_path</code> mène à la règle concernée et <code>keyword</code> donne une catégorie stable telle que <code>required</code>, <code>type</code> ou <code>minimum</code>.

Distinguez un schéma incorrect de données invalides

Un document invalide produit un résultat normal : la requête réussit avec <code>valid</code> à false et détaille chaque violation. Un schéma mal formé est différent, car aucune validation fiable n’est possible. Un contrat cassé n’est donc pas confondu avec de mauvaises données. Si un mot-clé a une forme incorrecte, si un type est inconnu, si une expression régulière ne compile pas, si une limite numérique est incohérente ou si une référence locale reste introuvable, la capacité renvoie <code>invalid_input</code>. L’implémentation pure n’accède pas au réseau et ne récupère aucune référence distante ; utilisez des références JSON Pointer locales commençant par <code>#/</code>. Ce contrôle convient aux frontières d’API, aux imports, aux sorties structurées et aux pipelines de build. Les requêtes API commencent à $0.002, avec la même logique dans le navigateur.

Cas d'intégration

Refuser des charges API incorrectes

Contrôlez les corps de requête et renvoyez le chemin précis de chaque champ que les clients doivent corriger.

Tester du JSON généré

Vérifiez les sorties structurées par rapport aux types, bornes et propriétés requises avant toute action automatisée.

Questions techniques

Que se passe-t-il si le schéma est mal formé ?

La requête échoue avec invalid_input, car un contrat incorrect ne permet pas une validation fiable.

Les références de schéma distantes sont-elles acceptées ?

Non. Le validateur reste hors réseau et accepte les références JSON Pointer locales du schéma fourni.

Quel est le prix d’une validation par API ?

Chaque requête commence à $0.002. L’exécuteur web emploie la même logique pure pour les contrôles interactifs.

Consulter la documentation complète du KIT →

Lancer gratuitement

Bien écrit ne veut pas dire correct

Lire le résultat et s'en servir

Vérifiez le contrat, pas seulement la ponctuation

Lisez précisément les chemins des violations

Cas d’usage

Sécuriser les imports de données

Questions fréquentes

Outils associés

Pour les développeurs — accès API

Endpoint

Appeler depuis votre stack

Exemple de requête

Exemple de réponse

Tarifs

Limites

Erreurs

Notes techniques

Validez le contrat, pas seulement la syntaxe JSON

Lisez précisément les chemins des violations

Distinguez un schéma incorrect de données invalides

Cas d'intégration

Refuser des charges API incorrectes

Tester du JSON généré

Questions techniques

merci