---
title: "Mode JSON ou JSON Schema : sortie structurée, avec code"
description: "Le mode JSON donne du JSON valide ; json_schema donne votre structure. Les demander sur des modèles compatibles OpenAI, valider avec Pydantic et réparer en boucle."
url: https://broadrouter.com/fr/blog/structured-output-json-schema/
lang: fr
updated: 2026-11-14
publisher: BroadRouter (a BroadNet site); API by BroadNet Inference, https://inference.broadnet.ai
---

Traduit de l’anglais avec l’aide de l’IA. [Lire l’original en anglais](https://broadrouter.com/blog/structured-output-json-schema/) (mis à jour le 2026-11-14).

# Mode JSON ou json\_schema : une sortie structurée qui tient

Par l’équipe BroadNet Inference · 4 min de lecture · Publié 2026-11-14

Le mode JSON (response\_format json\_object) promet seulement un JSON valide. La sortie structurée (response\_format json\_schema) promet aussi vos champs et vos types, là où le fournisseur l’impose. Dans les deux cas, vérifiez finish\_reason, parsez et validez contre un schéma, par exemple un modèle Pydantic. Si la validation échoue, renvoyez l’erreur et redemandez, avec un nombre maximal de tentatives.

## À retenir

-   Le guide d’OpenAI : les deux modes produisent du JSON valide, mais « only Structured Outputs ensure schema adherence » (traduction : « seules les Structured Outputs garantissent le respect du schéma »).
-   La prise en charge varie selon les fournisseurs compatibles OpenAI. Testez d’abord json\_schema, rabattez-vous ensuite sur json\_object, puis sur les seules consignes du prompt.
-   Validez chaque réponse. Une réponse tronquée par max\_tokens est un JSON cassé, quoi que dise le schéma.
-   Les boucles de réparation fonctionnent quand vous renvoyez l’erreur de validation exacte. Plafonnez-les à deux ou trois tentatives.
-   Chez BroadNet Inference, GLM 5.3 et Qwen3.8 27B indiquent la sortie structurée.

**Sur cette page**

1.  Quelle est la différence entre le mode JSON et json\_schema ?
2.  Comment demander json\_schema ?
3.  Quel mode votre fournisseur prend-il en charge ?
4.  Comment valider et réparer une sortie incorrecte ?
5.  Quelles fonctionnalités de schéma posent problème ?
6.  Comment surveiller la sortie structurée en production ?
7.  Quand utiliser plutôt un outil ?
8.  La place de BroadNet Inference

Votre code a besoin de données, et les modèles écrivent du texte. La [sortie structurée](https://broadrouter.com/fr/glossary/structured-output/) comble cet écart, mais « le modèle renvoie du JSON » recouvre trois choses différentes selon la manière dont vous le demandez. Cet article compare les options sur des modèles ouverts compatibles OpenAI, montre comment demander chacune et propose une boucle de validation et de réparation à intégrer telle quelle en production.

## Quelle est la différence entre le mode JSON et json\_schema ?

| Méthode | Requête | Ce qui vous est promis |
| --- | --- | --- |
| Prompt seul | « Réponds en JSON avec les champs… » | Rien ; en général du JSON, parfois avec du texte en plus |
| Mode JSON | `response_format: {"type": "json_object"}` | Du JSON valide, de forme quelconque |
| Sortie structurée | `response_format: {"type": "json_schema", ...}` | Du JSON conforme à votre schéma, là où c’est imposé |

Le guide des Structured Outputs d’OpenAI le dit sans détour : « While both ensure valid JSON is produced, only Structured Outputs ensure schema adherence. » (traduction : « Si les deux garantissent la production d’un JSON valide, seules les Structured Outputs garantissent le respect du schéma. ») Il recommande la sortie structurée plutôt que le mode JSON chaque fois que c’est possible.

Chez les fournisseurs de modèles ouverts, la garantie dépend de la façon dont le serveur l’implémente. Beaucoup utilisent le décodage contraint (constrained decoding), qui bloque les tokens qui casseraient le schéma. Certains acceptent le champ sans l’imposer. C’est pourquoi le code ci-dessous valide dans tous les cas.

## Comment demander json\_schema ?

```python
import os
from openai import OpenAI
from pydantic import BaseModel, Field

client = OpenAI(base_url="https://inference.broadnet.ai/v1", api_key=os.environ["BROADNET_API_KEY"])

class Invoice(BaseModel):
    vendor: str
    currency: str = Field(pattern="^[A-Z]{3}$")
    total: float
    line_items: list[float]

schema = Invoice.model_json_schema()
schema["additionalProperties"] = False

response_format = {"type": "json_schema",
                   "json_schema": {"name": "invoice", "strict": True, "schema": schema}}
```

Pydantic génère le JSON Schema à partir de votre classe : le schéma et le validateur ne divergent jamais. Si vous n’utilisez pas Pydantic, le [générateur de JSON Schema](https://broadrouter.com/tools/json-schema-generator/) construit un schéma en mode strict à partir d’un objet d’exemple. En mode strict, OpenAI exige `additionalProperties: false` et que chaque propriété figure parmi les champs obligatoires.

## Quel mode votre fournisseur prend-il en charge ?

Faites ce test une fois par modèle avant de bâtir dessus :

1.  Envoyez `json_schema` avec un prompt qui invite à ajouter un champ (« ajoute aussi un court commentaire »).
2.  Si la requête renvoie une erreur, le fournisseur n’accepte pas `json_schema`. Essayez `json_object`.
3.  Si la réponse contient le champ en trop, le schéma n’est pas imposé. Traitez-le comme le mode JSON.
4.  Si `json_object` renvoie aussi une erreur, utilisez les seules consignes du prompt, avec validation.

Chez BroadNet Inference, la documentation indique la sortie structurée pour [GLM 5.3](https://broadrouter.com/fr/models/glm-5.3/) et [Qwen3.8 27B](https://broadrouter.com/fr/models/qwen3.8-27b/) ([comparés côte à côte](https://broadrouter.com/compare/glm-5.3-vs-qwen3.8-27b/)), mais ne nomme pas le paramètre de requête. Faites le test ci-dessus sur le modèle que vous mettez en production.

## Comment valider et réparer une sortie incorrecte ?

```python
import json
from pydantic import ValidationError

def extract(text: str, model="broadnet/glm-5.3", attempts=3) -> Invoice:
    messages = [
        {"role": "system", "content": "Extract the invoice. Reply with JSON only."},
        {"role": "user", "content": text},
    ]
    for attempt in range(attempts):
        r = client.chat.completions.create(model=model, messages=messages,
                                           response_format=response_format,
                                           max_tokens=4000)
        choice = r.choices[0]
        if choice.finish_reason == "length":
            raise RuntimeError("Cut off: raise max_tokens")  # retrying won't help
        if getattr(choice.message, "refusal", None):
            raise RuntimeError(f"Refused: {choice.message.refusal}")
        raw = choice.message.content or ""
        try:
            inv = Invoice.model_validate_json(raw)
            if abs(sum(inv.line_items) - inv.total) > 0.01:
                raise ValueError("total must equal the sum of line_items")
            return inv
        except (ValidationError, ValueError) as e:
            messages += [
                {"role": "assistant", "content": raw},
                {"role": "user", "content": f"That JSON is invalid: {e}. Return corrected JSON only."},
            ]
    raise RuntimeError(f"No valid JSON after {attempts} attempts")
```

Ce qui fait fonctionner cette boucle :

-   **Vérifier `finish_reason` en premier.** Une réponse qui a atteint [`max_tokens`](https://broadrouter.com/fr/glossary/max-tokens/) est un JSON tronqué. Relancer avec la même limite échoue de la même façon. Les deux modèles ci-dessus raisonnent avant de répondre, et [le raisonnement compte dans la limite](https://broadrouter.com/fr/guides/reasoning-tokens-empty-response/) : laissez de la marge.
-   **Traiter les refus à part.** Le guide d’OpenAI note qu’un refus « does not necessarily follow the schema you have supplied » (traduction : « ne suit pas forcément le schéma que vous avez fourni »).
-   **Renvoyer l’erreur exacte.** Un retry à l’aveugle renvoie souvent la même erreur. « line\_items: field required » donne au modèle quelque chose à corriger.
-   **Vérifier les règles métier dans le code.** Un schéma ne peut pas dire qu’un total doit être égal à la somme de ses lignes. La vérification ci-dessus, si.
-   **Plafonner les tentatives.** Chaque tentative renvoie tout le prompt en [tokens d’entrée](https://broadrouter.com/fr/glossary/input-and-output-tokens/).

## Quelles fonctionnalités de schéma posent problème ?

Gardez des schémas ennuyeux :

1.  **Plat plutôt qu’imbriqué.** Deux niveaux suffisent pour la plupart des extractions.
2.  **Des enums plutôt que des chaînes libres** pour les catégories.
3.  **Pas d’objets ouverts.** Des champs `dict` libres font perdre tout l’intérêt.
4.  **Des noms de champs courts, avec des descriptions.** Les descriptions du schéma guident le modèle.
5.  **Les champs optionnels en nullable.** En mode strict, déclarez chaque champ obligatoire et autorisez `null`.

Le guide d’OpenAI signale que certaines fonctionnalités de JSON Schema ne sont pas prises en charge en mode strict. Les serveurs de modèles ouverts ont leurs propres limites. Si un schéma est refusé, simplifiez-le avant de changer de mode.

## Comment surveiller la sortie structurée en production ?

Une boucle qui répare en silence peut masquer un problème qui vous coûte des tokens chaque jour. Journalisez trois chiffres par point d’appel :

| Indicateur | Ce qu’il vous apprend |
| --- | --- |
| Taux de réussite à la première tentative | L’adéquation entre modèle et schéma ; une baisse suit souvent un changement de prompt ou de modèle |
| Nombre moyen de tentatives par réussite | Le coût en tokens des réparations |
| Échecs définitifs | Les entrées que votre pipeline ne sait pas traiter ; relisez-les à la main |

Si le taux de réussite à la première tentative passe sous votre niveau habituel, simplifiez le schéma ou essayez un autre modèle avant d’ajouter des retries. Gardez un échantillon des réponses brutes en échec, pour tester vos corrections sur des cas réels.

## Quand utiliser plutôt un outil ?

Utilisez la sortie structurée pour la **réponse finale** : une extraction, une classification, un plan. Utilisez l’[appel d’outils](https://broadrouter.com/fr/blog/tool-calling-open-models/) quand le modèle a besoin que votre code **fasse** quelque chose avant de continuer. Beaucoup d’agents utilisent les deux : des outils pendant la boucle, un schéma pour la dernière étape. Pour un exemple d’image vers JSON, voir [lire des factures en arabe avec un modèle de vision](https://broadrouter.com/fr/guides/read-arabic-invoices-with-vision/).

## La place de BroadNet Inference

BroadNet Inference indique la sortie structurée pour GLM 5.3 et Qwen3.8 27B, derrière le format standard des chat completions : le code ci-dessus tourne donc sans modification avec le [SDK Python d’OpenAI](https://broadrouter.com/fr/guides/openai-python-sdk/). Qwen3.8 27B accepte aussi les images, ce qui convient à l’extraction de documents. La documentation de BroadNet n’indique pas de sortie structurée pour DeepSeek V4.1 Flash ni pour Gemma 4 VL 26B : utilisez-y la voie des consignes de prompt seules, avec validation. Comparez les prix au token sur la [page des prix](https://broadrouter.com/fr/pricing/).

Outils gratuits sur ce sujet (en anglais)

-   [OpenAI to BroadNet migration helper](https://broadrouter.com/tools/openai-to-broadnet-migration/) Paste OpenAI SDK code; get base URL, key and model edits, a diff and the checks that remain.
-   [max\_tokens calculator for reasoning models](https://broadrouter.com/tools/reasoning-token-budget/) Answer length + reasoning budget + margin = a max\_tokens that does not cut the answer off.
-   [JSON schema generator for LLM structured output](https://broadrouter.com/tools/json-schema-generator/) Sample JSON to strict schema, Pydantic, Zod and a ready request.
-   [LLM JSON output validator](https://broadrouter.com/tools/llm-json-output-validator/) Parse errors by line and column, safe repairs, cut-off detection and JSON Schema checks for model output.

[Outils gratuits (en anglais)](https://broadrouter.com/tools/)

## Termes de cet article

[Sortie structurée (structured output)](https://broadrouter.com/fr/glossary/structured-output/)

La sortie structurée est une fonction des API LLM qui contraint la réponse d’un modèle à un format défini par le développeur, en général un JSON Schema, pour que le code puisse l’analyser de façon fiable. Elle est plus stricte que le mode JSON, qui garantit un JSON valide mais pas une structure précise.

[Token](https://broadrouter.com/fr/glossary/token/)

Un token est l’unité de texte qu’un modèle de langage lit et écrit : un mot, une partie de mot, un signe de ponctuation ou une suite d’octets produite par le tokenizer du modèle. Les API LLM comptent, limitent et facturent généralement l’usage en tokens.

[JSON Schema](https://broadrouter.com/fr/glossary/json-schema/)

JSON Schema est un vocabulaire, écrit en JSON, qui sert à décrire et à valider la structure de données JSON : types, champs obligatoires, valeurs autorisées et imbrication. La version actuelle est la 2020-12. Les API de LLM l’utilisent pour définir les paramètres des outils et la forme exacte que doit suivre une sortie structurée.

[Appel d’outils (tool calling, function calling)](https://broadrouter.com/fr/glossary/tool-calling/)

L’appel d’outils, aussi appelé function calling, est une fonctionnalité des API LLM dans laquelle le modèle renvoie une demande structurée d’exécution d’une fonction définie par le développeur, avec des arguments JSON. L’application exécute la fonction et renvoie le résultat ; le modèle n’exécute jamais de code lui-même.

[Mode JSON (JSON mode)](https://broadrouter.com/fr/glossary/json-mode/)

Le mode JSON est un réglage des API de LLM, response\_format {"type": "json\_object"} dans les API de style OpenAI, qui fait de la réponse du modèle un JSON valide et analysable. Contrairement aux Structured Outputs avec un JSON Schema, il ne garantit pas les clés, les types ni les valeurs de l’objet.

[API Chat Completions](https://broadrouter.com/fr/glossary/chat-completions-api/)

L’API Chat Completions est l’endpoint HTTP d’OpenAI, POST /v1/chat/completions, qui reçoit un nom de modèle et une liste de messages associés à un rôle, et renvoie le message suivant du modèle. Sa forme de requête et de réponse est devenue le format commun que reprennent les fournisseurs et SDK compatibles OpenAI.

[Modèle vision-langage (VLM)](https://broadrouter.com/fr/glossary/vision-language-model/)

Un modèle vision-langage (VLM) est un modèle qui prend en entrée des images et du texte ensemble et produit du texte : il peut décrire des images, répondre à des questions à leur sujet et lire des documents, des graphiques ou des captures d’écran. On parle aussi de modèles image-texte-vers-texte ou multimodaux.

[Paiement à l’usage (pay-as-you-go)](https://broadrouter.com/fr/glossary/pay-as-you-go/)

Le paiement à l’usage (pay-as-you-go) est un modèle tarifaire où vous ne payez que ce que vous consommez, mesuré par unité, comme les tokens, les requêtes ou les minutes d’audio, sans abonnement ni engagement minimal. La plupart des API LLM facturent ainsi, à partir d’un solde prépayé ou d’une facture périodique.

## Questions fréquentes

### Quelle est la différence entre le mode JSON et la sortie structurée ?

Le mode JSON, response\_format de type json\_object, promet seulement que la réponse se parse en JSON. La sortie structurée, de type json\_schema, promet aussi les champs et les types que vous avez définis, là où le fournisseur l’impose. OpenAI recommande la sortie structurée plutôt que le mode JSON quand c’est possible.

### Les modèles ouverts prennent-ils en charge response\_format avec json\_schema ?

Cela dépend du fournisseur. Certains acceptent json\_schema, d’autres seulement json\_object, et d’autres ignorent le champ. Envoyez une requête de test avec un schéma et un prompt qui pousse le modèle à ajouter un champ en trop, puis vérifiez la réponse.

### Faut-il quand même valider la sortie structurée ?

Oui. Les réponses peuvent être tronquées par max\_tokens, être des refus, et enfreindre des règles métier qu’un schéma ne peut pas exprimer, comme des totaux qui doivent tomber juste.

### Combien de fois relancer en cas de JSON invalide ?

Deux ou trois tentatives en incluant l’erreur de validation suffisent en général. Au-delà, journalisez l’entrée et orientez-la vers une solution de repli, un modèle plus puissant ou une personne. Les boucles sans limite gaspillent des tokens.

### Sortie structurée ou appel d’outils : que choisir ?

Utilisez la sortie structurée quand vous voulez la réponse finale sous une forme fixe. Utilisez l’appel d’outils quand le modèle a besoin que votre code fasse quelque chose avant de continuer.

## À lire ensuite

-   [Classification de texte arabe par LLM : sentiment, intention, tri](https://broadrouter.com/fr/blog/arabic-text-classification-llm/)
-   [Appel d’outils et modèles ouverts : schémas, parallélisme, relances](https://broadrouter.com/fr/blog/tool-calling-open-models/)
-   [Passer à une API compatible OpenAI : la checklist de migration](https://broadrouter.com/fr/blog/openai-compatible-api-migration-checklist/)
-   [Agent IA n8n sur un LLM bon marché : configuration, modèle, coût](https://broadrouter.com/fr/blog/n8n-ai-agent-cheap-llm/)
-   [Corriger le JSON invalide d’un LLM : causes, réparation, relance](https://broadrouter.com/fr/blog/fix-invalid-json-from-llm/)
-   [Extraction d’entités nommées en arabe par LLM : JSON, dates, contrôles](https://broadrouter.com/fr/blog/arabic-named-entity-extraction-llm/)
-   [Matériel GPU et serving de BroadNet, tels que BroadNet les décrit](https://broadrouter.com/fr/blog/broadnet-gpu-fleet-and-serving/)
-   [Mettre en cache les réponses d’API LLM : un cache exact en Python](https://broadrouter.com/fr/blog/cache-llm-responses-cut-cost/)
-   [Guide : Utiliser le SDK Python d’OpenAI avec BroadNet Inference](https://broadrouter.com/fr/guides/openai-python-sdk/)
-   [Guide : Lire des factures et reçus arabes avec un modèle de vision](https://broadrouter.com/fr/guides/read-arabic-invoices-with-vision/)
-   [Guide : Pourquoi un modèle de raisonnement renvoie une réponse vide](https://broadrouter.com/fr/guides/reasoning-tokens-empty-response/)

Essayez-le sur votre vraie charge de travail. Les nouveaux comptes démarrent avec USD 5 de crédit pour Gemma et transcription. DeepSeek, GLM et Qwen3.8 nécessitent une recharge.

[Commencer](https://inference.broadnet.ai/account/?utm_source=broadrouter&utm_medium=referral&utm_campaign=fr-blog-structured-output-json-schema&utm_content=page-cta) ·

**Sources**

-   [OpenAI, guide des Structured Outputs (vérifié le 2026-11-14)](https://developers.openai.com/api/docs/guides/structured-outputs)
-   [Référence de l’API OpenAI, créer une chat completion (response\_format)](https://developers.openai.com/api/reference/resources/chat/subresources/completions/methods/create)
-   [Documentation de Pydantic, JSON Schema et validation](https://docs.pydantic.dev/latest/concepts/json_schema/)
-   [Référence de l’API de BroadNet Inference, modèles (en anglais)](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=fr-blog-structured-output-json-schema&utm_content=sources#models)
