Comment obtenir une sortie JSON de ChatGPT et d'autres LLM

Ce qui marche vraiment pour la sortie JSON en 2026 (et ce qui a arrêté de marcher)

La question « comment obtenir du JSON fiable » a été répondue, re-répondue et obsolètée plusieurs fois depuis 2022. Le consensus actuel sur r/OpenAI, r/ClaudeAI, r/LocalLLaMA et le Discord LangChain est beaucoup plus étroit que ce que le contenu de blog plus ancien suggère.

Ce qui marche vraiment en 2026 :

• →Structured outputs / mode JSON strict. Les structured outputs d'OpenAI et l'usage d'outils d'Anthropic avec schémas d'input stricts appliquent le schéma JSON au niveau du décodage. Ils sont dramatiquement plus fiables que les requêtes JSON basées sur prompt.
• →Function calling / usage d'outils comme mécanisme de mise en forme JSON. Même si vous n'avez pas vraiment besoin d'outils, définir un outil avec le schéma que vous voulez et demander au modèle de « l'appeler » produit du JSON propre.
• →Décodage contraint par grammaire pour les modèles locaux. Les grammars GBNF de llama.cpp, outlines et le decoding guidé de vLLM contraignent la sortie à du JSON valide au niveau du token. Pour les setups auto-hébergés c'est le gold standard.
• →JSON Schema avec exemples explicites. Même avec les structured outputs, fournir 1-2 exemples concrets réduit significativement les échecs sur cas limites.

Ce qui a arrêté de marcher (ou n'a jamais vraiment marché) :

• →Les prompts « Réponds UNIQUEMENT avec du JSON » sur les modèles non-stricts. Les vieux modèles ignoraient ça 5-15 % du temps. Ne faites pas confiance à l'application basée sur prompt pour la production.
• →Demander du JSON dans des blocs de code markdown. Ça marche la plupart du temps et casse sur les longues sorties. L'extraction markdown est fragile ; utilisez le paramètre response_format de l'API.
• →Post-traitement regex comme seul garde-fou. Nécessaire comme fallback, insuffisant comme mécanisme primaire. Les modèles hallucinent des structures qui ressemblent à du JSON mais sont cassées régulièrement.
• →Exemples JSON faits à la main dans le system prompt sans schéma. Mieux que rien, mais les modes schema-aware le surperforment régulièrement.

Ce que les praticiens font vraiment pour la sortie structurée en production :

• →Définir un schéma Pydantic / Zod comme source de vérité, puis l'exporter en JSON Schema pour l'appel d'API. Pydantic en Python et Zod en TypeScript sont les choix dominants.
• →Valider après parsing, à chaque fois. Même avec le mode strict, les cas limites arrivent. Rejetez et retentez avec un feedback d'erreur clair plutôt que de passer silencieusement de mauvaises données en aval.
• →Loguer la sortie brute pour l'analyse d'échec. Quand quelque chose casse, il vous faut les tokens exacts que le modèle a produits.
• →Évaluer la qualité de sortie, pas juste la conformité de format. Un objet JSON bien formé avec des valeurs hallucinées est toujours un bug. Vos évals devraient tester les champs, pas juste la structure.
• →Utiliser des bibliothèques qui gèrent le boilerplate. Instructor (Python), la sortie structurée de LangChain et BAML emballent tous proprement la boucle schéma-validation-retry.

Ce qui est encore dur :

• →Schémas profondément imbriqués avec beaucoup d'enums. Le mode strict aide mais dégrade encore la qualité sur des schémas extrêmement complexes. Aplatissez quand possible.
• →Contenu mixte (un peu de prose, un peu de JSON). L'approche la plus propre est deux appels séparés ou un schéma à deux champs (reasoning: string, result: object). Essayer d'embarquer du JSON dans la prose casse plus souvent que ça ne marche.
• →Streaming de sortie structurée. Possible avec les APIs plus récentes mais requiert un handling UI soigneux. Pour la plupart des cas d'usage, attendre-et-parser est plus simple.

Le cadrage honnête : en 2026 vous ne devriez pas écrire votre propre logique d'extraction JSON depuis zéro. Utilisez les structured outputs, function calling ou décodage contraint par grammaire selon votre stack. Définissez les schémas en code, validez sur chaque réponse, et traitez la sortie comme non fiable jusqu'à validation. Les astuces de prompting de 2023 sont maintenant largement obsolètes.

Pourquoi la sortie JSON est importante

Quand vous construisez des applications avec l'IA, vous ne voulez pas de la prose, vous voulez des données analysables.

Le problème de la sortie non structurée

Utilisateur : Liste les 3 meilleurs langages de programmation

IA : Bien sûr ! Voici les 3 meilleurs langages de programmation :
1. Python - Idéal pour les débutants et la data science
2. JavaScript - Essentiel pour le développement web
3. TypeScript - JavaScript avec des types

Ce sont tous d'excellents choix selon vos besoins...

C'est agréable pour les humains mais terrible pour le code. Vous ne pouvez pas extraire les données de manière fiable.

La puissance de la sortie structurée

{
  "languages": [
    {"name": "Python", "use_case": "Data science, débutants"},
    {"name": "JavaScript", "use_case": "Développement web"},
    {"name": "TypeScript", "use_case": "JavaScript typé"}
  ]
}

Maintenant votre code peut analyser cela directement. Plus besoin d'acrobaties avec les regex.

Techniques de base pour la sortie JSON

1. Instructions de format explicites

Dites à l'IA exactement quel format vous souhaitez :

Retournez votre réponse sous forme d'objet JSON avec cette structure :
{
  "title": "string",
  "summary": "string",
  "tags": ["tableau", "de", "chaînes"]
}

Ne produisez que le JSON, aucun autre texte.

2. Fournir un exemple

Montrez à l'IA ce que vous attendez :

Extrayez les informations produit de cette description et retournez le résultat en JSON.

Exemple de sortie :
{"name": "Widget Pro", "price": 29.99, "category": "Outils"}

Description : "Le SuperBlender 3000 coûte 149 € et fait partie de notre catégorie Cuisine"

3. Utiliser les messages système (API)

Avec l'API, le message système peut imposer le format :

System : Vous êtes un répondeur JSON uniquement. Produisez du JSON valide et rien d'autre.

Problèmes courants

1. Texte supplémentaire autour du JSON

Le modèle peut dire « Voici le JSON : » avant la sortie effective.

Solution : Soyez explicite : « Produisez UNIQUEMENT du JSON valide. Pas d'introduction, pas d'explication. »

2. Syntaxe JSON invalide

Guillemets manquants, virgules en trop ou crochets cassés.

Solution : Demandez au modèle de valider : « Assurez-vous que le JSON est valide et analysable. »

3. Structure incohérente

Parfois les clés sont présentes, parfois non.

Solution : Définissez le schéma explicitement et indiquez quels champs sont obligatoires.

Quand la sortie structurée excelle

La sortie structurée est essentielle pour :

• →Intégrations API, Alimenter d'autres systèmes avec la sortie IA
• →Stockage en base de données, Stocker les réponses dans un format structuré
• →Workflows d'automatisation, Intégrations Zapier, Make, n8n
• →Rendu frontend, Afficher les sorties IA dans des composants UI
• →Extraction de données, Extraire des informations structurées de texte non structuré

JSON vs. autres formats

Le JSON est le choix le plus universel pour l'usage programmatique.

Mode JSON natif (API)

Les API modernes proposent désormais un mode JSON qui garantit une sortie JSON valide. C'est un changement majeur pour la fiabilité.

Mode JSON OpenAI (GPT-5.2)

import openai

client = openai.OpenAI()

response = client.chat.completions.create(
    model="gpt-5.2",
    response_format={"type": "json_object"},
    messages=[
        {"role": "system", "content": "Output valid JSON only."},
        {"role": "user", "content": "List top 3 programming languages with use cases"}
    ]
)

# JSON valide garanti
import json
data = json.loads(response.choices[0].message.content)

Mode JSON Claude

import anthropic

client = anthropic.Anthropic()

message = client.messages.create(
    model="claude-sonnet-4-5-20250514",
    max_tokens=1024,
    messages=[
        {
            "role": "user",
            "content": """Return a JSON object with this exact structure:
            {"languages": [{"name": "...", "use_case": "..."}]}
            
            List top 3 programming languages. Output ONLY the JSON."""
        }
    ]
)

Sortie structurée Gemini

Gemini prend en charge la sortie structurée basée sur un schéma :

import google.generativeai as genai

model = genai.GenerativeModel('gemini-3-pro')

response = model.generate_content(
    "List top 3 programming languages",
    generation_config=genai.GenerationConfig(
        response_mime_type="application/json",
        response_schema={
            "type": "object",
            "properties": {
                "languages": {
                    "type": "array",
                    "items": {
                        "type": "object",
                        "properties": {
                            "name": {"type": "string"},
                            "use_case": {"type": "string"}
                        }
                    }
                }
            }
        }
    )
)

Sortie JSON par modèle

Patterns JSON avancés

Pattern 1 : Définition de schéma

Définissez votre schéma explicitement pour des résultats cohérents :

Retournez un objet JSON correspondant à cette interface TypeScript :

interface ProductAnalysis {
  name: string;
  category: string;
  sentiment: "positive" | "negative" | "neutral";
  keyFeatures: string[];  // exactement 3 éléments
  priceRange: {
    min: number;
    max: number;
    currency: "USD" | "EUR";
  };
}

Pattern 2 : Instructions de validation

Demandez au modèle de s'auto-valider :

Avant de produire la sortie, vérifiez votre JSON :
1. Tous les champs obligatoires sont présents
2. Les tableaux ont la longueur correcte
3. Pas de virgules en trop
4. Les chaînes sont correctement entre guillemets
5. Compatible avec JSON.parse()

Si un contrôle échoue, corrigez avant de produire la sortie.

Pattern 3 : Récupération d'erreurs

Gérez le JSON malformé avec élégance :

import json
import re

def parse_llm_json(response: str) -> dict:
    # Essayer l'analyse directe
    try:
        return json.loads(response)
    except json.JSONDecodeError:
        pass
    
    # Extraire le JSON d'un bloc de code markdown
    match = re.search(r'```json?\s*([\s\S]*?)```', response)
    if match:
        try:
            return json.loads(match.group(1))
        except json.JSONDecodeError:
            pass
    
    # Extraire le premier bloc { }
    match = re.search(r'\{[\s\S]*\}', response)
    if match:
        try:
            return json.loads(match.group(0))
        except json.JSONDecodeError:
            pass
    
    raise ValueError("Impossible d'analyser le JSON de la réponse")

FAQ

Le mode JSON consomme-t-il plus de tokens ?

Non. Le mode JSON n'augmente pas l'utilisation de tokens. Cependant, demander une sortie structurée produit souvent des réponses plus concises.

Peut-on utiliser le mode JSON avec le streaming ?

Oui, mais vous devrez mettre la réponse en mémoire tampon et l'analyser une fois complète, car du JSON partiel n'est pas valide.

Que faire si le modèle retourne du JSON invalide malgré le mode JSON ?

Avec le mode JSON natif, c'est extrêmement rare. Si cela arrive, relancez la requête. Pour les applications critiques, implémentez une logique de validation et de relance.

Faut-il utiliser le function calling au lieu du mode JSON ?

Le function calling (tool use) est préférable quand vous avez besoin que le modèle choisisse entre des actions. Le mode JSON est préférable pour l'extraction de données pure.

• →Techniques de meta-prompting, Patterns avancés de prompting
• →GPT-5.2-Codex en détail, Codage avec sortie structurée
• →Commandes slash Claude Code, Sortie structurée en CLI

En bref

1. →La sortie structurée rend les réponses IA lisibles par les machines
2. →Utilisez des instructions de format explicites et des exemples
3. →Indiquez « JSON uniquement, aucun autre texte » pour éviter les ajouts
4. →Définissez clairement votre schéma pour la cohérence
5. →Le mode JSON des API modernes offre des garanties

Prêt à maîtriser les sorties structurées ?

Cet article a couvert le quoi et le pourquoi de l'obtention de JSON depuis l'IA. Mais une sortie structurée fiable nécessite des techniques plus avancées.

Dans notre Module 2, Sorties structurées, vous apprendrez :

• →Les techniques avancées de définition de schéma
• →Comment gérer les champs optionnels vs obligatoires
• →Les stratégies de validation pour les systèmes de production
• →Le travail avec les structures imbriquées et complexes
• →L'utilisation du mode JSON et des API de function calling

→ Explorer le Module 2 : Sorties structurées

Dernière mise à jour : 28 janvier 2026