← Tous les articles
Mis à jour le May 29, 20268 min read

Comment valider du JSON : syntaxe et validation de schéma

Validez la syntaxe JSON avec JSON.parse, json.loads de Python, jq ou dans votre navigateur — et apprenez à vérifier structure et types avec JSON Schema.

Valider du JSON, c’est confirmer qu’une chaîne est à la fois syntaxiquement correcte (elle suit la grammaire JSON) et, en option, structurellement correcte (elle correspond à la forme attendue par votre application). Ce guide montre comment valider du JSON en JavaScript, Python, en ligne de commande et dans votre navigateur —— et explique la différence cruciale entre validation de syntaxe et validation par schéma.

Deux types de validation JSON

Avant de valider quoi que ce soit, décidez quelle question vous posez réellement :

  • Validation de syntaxe —— « Est-ce que c’est du JSON valide tout court ? » Vérifie guillemets, virgules, accolades et types de valeurs contre la grammaire JSON. JSON.parse() fait ça.
  • Validation par schéma —— « Ce JSON a-t-il les bons champs, types et contraintes ? » Vérifie que id est un entier, que email est présent, etc. Nécessite JSON Schema et un validateur comme Ajv.

La plupart des recherches « validate JSON » concernent la validation de syntaxe —— commençons par là.

Comment valider du JSON en JavaScript

La vérification de syntaxe la plus simple et fiable est d’essayer de parser et de capturer l’erreur. JSON.parse() lève un SyntaxError sur toute entrée invalide :

function isValidJson(text) {
  try {
    JSON.parse(text);
    return true;
  } catch {
    return false;
  }
}

isValidJson('{"name":"Ada"}');  // true
isValidJson("{'name':'Ada'}");  // false —— guillemets simples
isValidJson('{"a":1,}');        // false —— virgule finale

Si vous avez besoin de la raison pour laquelle une chaîne est invalide, capturez le message d’erreur —— il inclut généralement une position :

function validateJson(text) {
  try {
    return { valid: true, value: JSON.parse(text) };
  } catch (err) {
    return { valid: false, error: err.message };
  }
}

validateJson('{"a":1,}');
// { valid: false, error: "Expected double-quoted property name in JSON at position 7" }

N’utilisez pas d’expression régulière pour valider du JSON. JSON est une grammaire récursive et ne peut pas être correctement validée avec une regex —— JSON.parse() est le validateur canonique et est déjà intégré à tout runtime JavaScript.

Comment valider du JSON en Python

json.loads() de Python lève json.JSONDecodeError sur entrée invalide, avec la ligne et la colonne exactes :

import json

def is_valid_json(text):
    try:
        json.loads(text)
        return True
    except json.JSONDecodeError as e:
        print(f"Invalid JSON: {e.msg} at line {e.lineno} column {e.colno}")
        return False

is_valid_json('{"name": "Ada"}')   # True
is_valid_json('{"name": "Ada",}')  # False —— virgule finale

Valider un fichier JSON en ligne de commande

Avec jq

jq sort avec un code non-zéro si l’entrée n’est pas du JSON valide, ce qui le rend idéal pour les scripts et la CI :

# N’affiche rien et sort 0 si valide ; affiche une erreur et sort non-zéro sinon
jq empty data.json && echo "valid" || echo "invalid"

Avec Python (aucune installation)

python3 -m json.tool data.json > /dev/null && echo "valid"

Dans un pipeline CI

Validez chaque fichier JSON du dépôt comme étape pre-commit ou CI pour qu’une config mal formée n’atteigne jamais la prod :

# Échoue la build si un .json est invalide
find . -name '*.json' -not -path './node_modules/*' \
  -exec sh -c 'jq empty "$1" || exit 255' _ {} \;

Valider du JSON dans votre navigateur

Pour une vérification rapide sans écrire de code, collez votre JSON dans le validateur JSON de fixjson. Il signale la ligne et la position exactes de toute erreur de syntaxe au fil de la frappe, et tout se déroule en local —— aucune donnée n’est envoyée au serveur, ce qui rend l’outil sûr pour les payloads sensibles. Si le JSON est cassé et que vous voulez le réparer plutôt que simplement le marquer, JSON Fix corrige automatiquement les erreurs courantes.

Au-delà de la syntaxe : valider la structure avec JSON Schema

Un JSON syntaxiquement valide peut quand même être incorrect pour votre application —— un champ requis manquant, une chaîne là où vous attendiez un nombre, une valeur hors plage. Pour imposer une structure, décrivez la forme attendue avec JSON Schema et validez avec Ajv (JavaScript) ou la librairie jsonschema (Python) :

import Ajv from 'ajv';

const ajv = new Ajv();
const validate = ajv.compile({
  type: 'object',
  required: ['id', 'email'],
  properties: {
    id:    { type: 'integer' },
    email: { type: 'string' },
  },
});

validate({ id: 42, email: 'a@b.com' }); // true
validate({ id: '42' });                 // false —— mauvais type, email manquant
// validate.errors contient le détail

Validation par schéma en ligne de commande

Pour des vérifications CI de JSON contre un schéma, deux CLI couvrent l’essentiel :

# Python —— installer une fois, puis valider
pip install jsonschema
jsonschema --instance data.json schema.json && echo OK

# Node —— Ajv en CLI
npm i -g ajv-cli ajv-formats
ajv validate -c ajv-formats -s schema.json -d "data.*.json"

Valider du JSON à chaque commit (hook pre-commit)

Pour empêcher tout JSON non validé d’être commité, branchez un hook avec husky + lint-staged :

// package.json
{
  "lint-staged": {
    "*.json": [
      "jq empty",
      "ajv validate -s schemas/$name.schema.json -d"
    ]
  }
}

# installer le hook
npx husky add .husky/pre-commit "npx lint-staged"

Pour les projets Python, le framework officiel pre-commit fournit un hook check-json qui exécute json.loads sur chaque fichier indexé.

Erreurs courantes de validation JSON

Quand la validation échoue, la cause est presque toujours l’une de ces erreurs —— chacune a son guide dédié :

Questions fréquentes

Comment vérifier qu’une chaîne est du JSON valide ?

Passez-la à JSON.parse() dans un try/catch (JavaScript) ou à json.loads() dans un try/except (Python). Si ça ne lève pas, c’est valide. Pour une vérification sans code, utilisez un validateur dans le navigateur.

Puis-je valider du JSON avec une expression régulière ?

Non. JSON est une grammaire récursive qu’une regex ne peut pas exprimer correctement. Utilisez toujours un vrai parseur comme JSON.parse().

Quelle est la différence entre valider et parser du JSON ?

Parser convertit le texte en valeur utilisable ; valider confirme juste qu’il pourrait être parsé. En pratique, un parse réussi est la validation —— c’est la même opération, vous jetez simplement le résultat quand seule la validité vous intéresse.

Comment valider du JSON contre un schéma ?

Utilisez JSON Schema avec Ajv (JavaScript) ou la librairie jsonschema (Python). La validation par schéma vérifie types, champs requis et contraintes —— pas seulement la syntaxe.

Validez du JSON maintenant —— sans installation

Collez votre JSON dans le validateur JSON pour voir instantanément les erreurs de syntaxe, avec la ligne et la position surlignées. Tout tourne dans votre navigateur ; aucune donnée ne quitte votre machine.