Formateur JSON & Validateur : Formatez et Validez JSON en Ligne

Les outils de formatage JSON et de validation JSON sont essentiels pour tout developpeur travaillant avec des API, des fichiers de configuration et l'echange de donnees. Que vous ayez besoin de formater du JSON pour la lisibilite, de valider du JSON en ligne pour detecter les erreurs de syntaxe ou de l'embellir pour le debogage, ce guide complet couvre tout. Notre outil gratuit de formatage JSON en ligne gere le formatage, la validation, la minification et la detection des erreurs de syntaxe instantanement dans votre navigateur.

Essayez notre outil gratuit de formatage et validation JSON.

Qu'est-ce que JSON ?

JSON (JavaScript Object Notation) est un format d'echange de donnees leger, base sur le texte, facile a lire et ecrire pour les humains, et facile a analyser et generer pour les machines. Devenu le standard de facto pour l'echange de donnees dans les API web, les fichiers de configuration et les bases de donnees NoSQL.

Un document JSON se compose de deux structures : des objets (collections de paires cle-valeur entre accolades {}) et des tableaux (listes ordonnees de valeurs entre crochets []). Les valeurs peuvent etre des chaines, des nombres, des booleens, null, des objets ou des tableaux.

JSON est defini par RFC 8259 et ECMA-404. Le type media est application/json et l'extension de fichier est .json. Contrairement a XML, JSON ne supporte pas les commentaires, les espaces de noms ou les attributs.

Pourquoi utiliser un formateur JSON

Lisibilite : Le JSON brut des API est souvent une longue ligne sans espaces. Un formateur JSON ajoute une indentation et des sauts de ligne pour faciliter la lecture des structures imbriquees.

Debogage : Quand une reponse API pose probleme, la premiere etape est de formater le JSON et d'inspecter la structure. Un validateur JSON identifie l'emplacement exact des erreurs.

Validation : Avant de deployer, validez toujours votre JSON pour s'assurer qu'il est conforme a la specification. Un JSON invalide peut causer des echecs silencieux.

Minification : Pour reduire la taille des donnees transmises, la minification JSON supprime tous les espaces inutiles, accelerant les reponses API.

Erreurs de syntaxe JSON courantes

Une erreur de syntaxe JSON peut casser toute votre application. Voici les erreurs les plus frequentes :

Virgules finales : JSON n'autorise pas de virgule apres le dernier element. {"a": 1, "b": 2,} est invalide.

// INVALID: trailing comma
{
  "name": "John",
  "age": 30,
}

// VALID: no trailing comma
{
  "name": "John",
  "age": 30
}

Guillemets simples : JSON exige des guillemets doubles. {'name': 'John'} est invalide.

// INVALID: single quotes
{'name': 'John', 'age': 30}

// VALID: double quotes
{"name": "John", "age": 30}

Cles sans guillemets : Chaque cle doit etre une chaine entre guillemets doubles. {name: "John"} est invalide.

Commentaires : Le JSON standard ne supporte pas les commentaires. Utilisez JSONC, YAML ou TOML si vous avez besoin de commentaires.

// INVALID: comments not allowed in JSON
{
  "name": "John", // this is a comment
  "age": 30       /* block comment */
}

// VALID: no comments
{
  "name": "John",
  "age": 30
}

undefined ou NaN : JSON ne supporte que null, pas undefined, NaN ou Infinity.

// INVALID in JSON (JavaScript-specific values)
{
  "value1": undefined,
  "value2": NaN,
  "value3": Infinity
}

// VALID: use null instead
{
  "value1": null,
  "value2": null,
  "value3": null
}

Crochets/accolades manquants : Chaque { ou [ doit avoir son equivalent fermant.

Sequences d'echappement invalides : JSON supporte des sequences specifiques : \", \\, \n, \r, \t, \uXXXX.

Comment formater du JSON

Plusieurs methodes pour formater du JSON selon votre flux de travail :

Formateur JSON en ligne : Collez vos donnees dans notre outil gratuit pour un formatage et une validation instantanes.

Ligne de commande avec jq : jq est le processeur JSON en ligne de commande le plus puissant.

Module Python integre : python -m json.tool fichier.json formate directement depuis le terminal.

Extensions IDE : VS Code a un formatage JSON integre (Shift+Alt+F). JetBrains propose Ctrl+Alt+L.

DevTools du navigateur : Les DevTools formatent automatiquement les reponses JSON dans l'onglet Reseau.

Regles de validation JSON

Pour valider correctement du JSON, voici les regles definies par RFC 8259 :

Types de donnees : JSON supporte six types : string, number, boolean, null, object et array.

// All six JSON data types demonstrated:
{
  "string": "Hello World",
  "number": 42.5,
  "boolean": true,
  "nullValue": null,
  "object": {
    "nested": "value"
  },
  "array": [1, "two", false, null, {"key": "val"}, [1,2,3]]
}

Chaines : Doivent etre entre guillemets doubles avec des sequences d'echappement specifiques.

Nombres : Entiers ou decimaux, notation scientifique autorisee, pas de zeros initiaux ni de NaN/Infinity.

// Valid JSON numbers:
42          // integer
-17         // negative integer
3.14        // floating point
2.5e10      // scientific notation
-1.23e-4    // negative scientific notation

// INVALID JSON numbers:
01          // leading zero not allowed
.5          // must have digit before decimal
+1          // leading plus not allowed
0xFF        // hex not allowed
0o77        // octal not allowed
NaN         // not a valid JSON value
Infinity    // not a valid JSON value

Objets : Les cles doivent etre des chaines uniques. Les objets vides {} sont valides.

Tableaux : Elements de types mixtes autorises. Tableaux vides [] valides. Imbrication arbitraire.

Encodage : UTF-8 est l'encodage par defaut et le plus utilise.

Valeur de niveau superieur : RFC 8259 autorise toute valeur JSON au niveau superieur.

Exemples de code : formater et valider JSON

JavaScript : formater et valider JSON

JavaScript fournit JSON.parse() et JSON.stringify() pour la validation et le formatage :

// ===== JSON.parse(): Validate JSON =====

// Valid JSON string
const jsonString = '{"name": "Alice", "age": 30, "active": true}';
const data = JSON.parse(jsonString);
console.log(data.name); // "Alice"

// Validate JSON safely with try/catch
function isValidJSON(str) {
  try {
    JSON.parse(str);
    return true;
  } catch (e) {
    console.error('JSON syntax error:', e.message);
    return false;
  }
}

isValidJSON('{"valid": true}');     // true
isValidJSON('{invalid: true}');     // false — "Unexpected token i"
isValidJSON('{"trailing": 1,}');    // false — "Unexpected token }"

// ===== JSON.stringify(): Format / Pretty Print JSON =====

const obj = {
  name: "Alice",
  age: 30,
  address: {
    city: "New York",
    zip: "10001"
  },
  hobbies: ["reading", "coding", "hiking"]
};

// Pretty print with 2-space indentation
const formatted = JSON.stringify(obj, null, 2);
console.log(formatted);
/*
{
  "name": "Alice",
  "age": 30,
  "address": {
    "city": "New York",
    "zip": "10001"
  },
  "hobbies": [
    "reading",
    "coding",
    "hiking"
  ]
}
*/

// Pretty print with 4-space indentation
console.log(JSON.stringify(obj, null, 4));

// Pretty print with tab indentation
console.log(JSON.stringify(obj, null, "\t"));

// Minify JSON (no whitespace)
const minified = JSON.stringify(obj);
// {"name":"Alice","age":30,"address":{"city":"New York","zip":"10001"},...}

// Custom replacer: filter specific keys
const filtered = JSON.stringify(obj, ["name", "age"], 2);
/*
{
  "name": "Alice",
  "age": 30
}
*/

// Reviver function: transform values during parsing
const parsed = JSON.parse('{"date": "2025-01-15T00:00:00Z"}', (key, value) => {
  if (key === 'date') return new Date(value);
  return value;
});
console.log(parsed.date instanceof Date); // true

Python : formater et valider JSON

Le module json de Python fournit json.dumps() avec le parametre indent :

import json

# ===== json.loads(): Validate JSON =====

json_string = '{"name": "Alice", "age": 30, "active": true}'
data = json.loads(json_string)
print(data["name"])  # "Alice"

# Validate JSON safely
def is_valid_json(s):
    try:
        json.loads(s)
        return True
    except json.JSONDecodeError as e:
        print(f"JSON syntax error at line {e.lineno}, col {e.colno}: {e.msg}")
        return False

is_valid_json('{"valid": true}')      # True
is_valid_json('{invalid: true}')      # False
is_valid_json('{"trailing": 1,}')     # False

# ===== json.dumps(): Format / Pretty Print JSON =====

data = {
    "name": "Alice",
    "age": 30,
    "address": {
        "city": "New York",
        "zip": "10001"
    },
    "hobbies": ["reading", "coding", "hiking"]
}

# Pretty print with 2-space indentation
formatted = json.dumps(data, indent=2)
print(formatted)

# Pretty print with sorted keys
formatted_sorted = json.dumps(data, indent=2, sort_keys=True)
print(formatted_sorted)

# Minify JSON (compact output)
minified = json.dumps(data, separators=(",", ":"))
print(minified)
# {"name":"Alice","age":30,"address":{"city":"New York","zip":"10001"},...}

# Handle non-ASCII characters (useful for i18n)
data_intl = {"city": "Tokyo", "greeting": "Hello"}
print(json.dumps(data_intl, ensure_ascii=False, indent=2))

# Read and format a JSON file
with open("data.json", "r") as f:
    data = json.load(f)

with open("data_formatted.json", "w") as f:
    json.dump(data, f, indent=2)

# Command line: python -m json.tool
# $ echo '{"a":1,"b":2}' | python -m json.tool
# {
#     "a": 1,
#     "b": 2
# }

Ligne de commande : jq, python et node

La ligne de commande offre plusieurs outils pour formater et valider du JSON :

# ===== jq: The Swiss Army knife for JSON =====

# Pretty print JSON
echo '{"name":"Alice","age":30}' | jq .
# {
#   "name": "Alice",
#   "age": 30
# }

# Minify JSON (compact output)
echo '{
  "name": "Alice",
  "age": 30
}' | jq -c .
# {"name":"Alice","age":30}

# Extract specific fields
echo '{"name":"Alice","age":30,"city":"NYC"}' | jq '{name, city}'
# {"name": "Alice", "city": "NYC"}

# Format a JSON file
jq . input.json > formatted.json

# Validate JSON (exit code 0 = valid, non-zero = invalid)
echo '{"valid": true}' | jq . > /dev/null 2>&1 && echo "Valid" || echo "Invalid"
echo '{invalid}' | jq . > /dev/null 2>&1 && echo "Valid" || echo "Invalid"

# Sort keys
echo '{"b":2,"a":1,"c":3}' | jq -S .
# {"a": 1, "b": 2, "c": 3}

# ===== python -m json.tool =====

# Format JSON from stdin
echo '{"a":1,"b":2}' | python3 -m json.tool

# Format a JSON file
python3 -m json.tool input.json output.json

# Sort keys
echo '{"b":2,"a":1}' | python3 -m json.tool --sort-keys

# ===== Node.js one-liner =====

# Pretty print JSON
echo '{"a":1,"b":2}' | node -e "process.stdin.resume();let d='';process.stdin.on('data',c=>d+=c);process.stdin.on('end',()=>console.log(JSON.stringify(JSON.parse(d),null,2)))"

# Simpler: use node -p
node -p "JSON.stringify({a:1,b:[2,3]}, null, 2)"

Pipeline curl + jq

Un flux de travail courant : recuperer du JSON depuis une API et le formater avec curl pipe vers jq :

# Fetch and format JSON from a REST API
curl -s https://api.github.com/users/octocat | jq .

# Fetch, extract specific fields, and format
curl -s https://api.github.com/users/octocat | jq '{login, name, bio, public_repos}'

# Fetch and validate (check exit code)
curl -s https://api.example.com/data | jq . > /dev/null 2>&1
if [ $? -eq 0 ]; then
  echo "Response is valid JSON"
else
  echo "Response is NOT valid JSON"
fi

# POST JSON and format the response
curl -s -X POST https://api.example.com/data \
  -H "Content-Type: application/json" \
  -d '{"name":"Alice","age":30}' | jq .

# Save formatted JSON to file
curl -s https://api.github.com/users/octocat | jq . > user.json

# Minify before sending (reduce payload size)
DATA=$(jq -c . large-payload.json)
curl -s -X POST https://api.example.com/data \
  -H "Content-Type: application/json" \
  -d "$DATA" | jq .

Bonnes pratiques JSON

Suivez ces bonnes pratiques pour ecrire du JSON propre et performant :

camelCase pour les cles : La plupart des API JSON utilisent camelCase. Soyez coherent dans toute votre API.

// camelCase (recommended for most APIs)
{
  "firstName": "Alice",
  "lastName": "Smith",
  "phoneNumber": "+1-555-0123",
  "isActive": true
}

// snake_case (common in Python/Ruby ecosystems)
{
  "first_name": "Alice",
  "last_name": "Smith",
  "phone_number": "+1-555-0123",
  "is_active": true
}

Imbrication peu profonde : Un JSON profondement imbrique (plus de 3-4 niveaux) est difficile a lire. Envisagez l'aplatissement.

// BAD: deeply nested (hard to read and parse)
{
  "company": {
    "departments": {
      "engineering": {
        "teams": {
          "frontend": {
            "members": [{"name": "Alice"}]
          }
        }
      }
    }
  }
}

// BETTER: flattened structure
{
  "companyId": "acme",
  "departmentId": "engineering",
  "teamId": "frontend",
  "members": [{"name": "Alice"}]
}

Fichiers volumineux : Pour les fichiers JSON de plusieurs Mo, utilisez des parseurs en streaming comme ijson ou JSONStream.

JSON Schema : Validez les payloads JSON contre une definition JSON Schema avec ajv ou jsonschema.

// JSON Schema example for validating user objects
{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "type": "object",
  "properties": {
    "name": { "type": "string", "minLength": 1 },
    "age": { "type": "integer", "minimum": 0 },
    "email": { "type": "string", "format": "email" },
    "roles": {
      "type": "array",
      "items": { "type": "string" },
      "minItems": 1
    }
  },
  "required": ["name", "email"]
}

Evitez les donnees binaires : JSON est un format texte. Utilisez Base64 ou des URLs pour les donnees binaires.

Gestion coherente de null : Decidez si vous omettez ou incluez explicitement les cles null.

JSON vs Alternatives : YAML, TOML, XML

JSON n'est pas le seul format de serialisation. Voici une comparaison rapide :

Choisissez JSON pour les API, YAML pour les fichiers de configuration editables, TOML pour les configurations simples, XML pour les standards existants (SOAP, RSS).

Questions frequemment posees

Comment formater du JSON en ligne ?

Collez votre JSON brut dans un outil de formatage comme le notre. L'outil valide automatiquement la syntaxe, ajoute l'indentation et met en surbrillance les erreurs. Vous pouvez choisir entre 2 ou 4 espaces d'indentation. L'outil fonctionne entierement dans votre navigateur.

Quelles sont les erreurs de syntaxe JSON courantes ?

Les erreurs les plus courantes sont : virgules finales, guillemets simples au lieu de doubles, cles sans guillemets, commentaires, valeurs undefined/NaN, crochets manquants et sequences d'echappement invalides.

Quelle est la difference entre JSON et YAML ?

JSON utilise des accolades et des guillemets doubles, YAML utilise l'indentation. YAML supporte les commentaires et les chaines multi-lignes. JSON est meilleur pour l'echange machine-a-machine, YAML pour les fichiers de configuration. JSON est un sous-ensemble strict de YAML.

Maitriser le formatage et la validation JSON est essentiel pour les developpeurs modernes. Utilisez notre outil gratuit pour un formatage et une validation instantanes.

Formatez, validez et minifiez JSON instantanement avec notre outil gratuit.