---
title: "JSON invalide renvoyé par un LLM : causes, réparation"
description: "Pourquoi les LLM renvoient du JSON cassé (balises de code, texte, coupure à max_tokens, virgules finales) et une fonction Python testée qui ne répare que le sûr."
url: https://broadrouter.com/fr/blog/fix-invalid-json-from-llm/
lang: fr
updated: 2026-11-15
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/fix-invalid-json-from-llm/) (mis à jour le 2026-11-16).

# Corriger le JSON invalide d’un LLM : causes, réparation, relance

Par l’équipe BroadNet Inference · 7 min de lecture · Publié 2026-11-15 · Mis à jour 2026-11-16

Vérifiez d’abord finish\_reason : une réponse coupée à max\_tokens ne se répare pas sans risque, alors augmentez la limite et relancez la requête. Sinon, retirez les balises de code et le texte autour, décodez la première valeur JSON, puis corrigez seulement les erreurs sans ambiguïté, comme les virgules finales. Validez contre un schéma et, en cas d’échec, renvoyez l’erreur exacte une ou deux fois. La sortie structurée, là où elle existe, évite l’essentiel.

## À retenir

-   Le plus souvent, ce n’est pas le JSON qui est cassé mais l’emballage : une balise de code, une phrase avant ou après, un bloc de raisonnement. raw\_decode, en Python, lit la première valeur et ignore le reste.
-   finish\_reason "length" signifie que le JSON a été coupé. Refermer les accolades le rend parsable mais perd des données sans bruit : renvoyez plutôt la requête avec plus de place.
-   Ne corrigez que ce qui n’a qu’un sens : virgules finales, True/None à la Python et apostrophes simples. Rejetez tout le reste et redemandez.
-   Le module json de Python accepte NaN et Infinity par défaut ; la RFC 8259, non. Rejetez-les, sinon d’autres parseurs plus loin dans la chaîne échoueront.
-   Chez BroadNet Inference, seuls GLM 5.3 et Qwen3.8 27B documentent la sortie structurée. Sur les autres modèles, demandez le JSON dans le prompt et appliquez cette réparation et cette validation.

**Sur cette page**

1.  Pourquoi les LLM renvoient-ils du JSON invalide ?
2.  Pourquoi ne pas réparer un JSON tronqué ?
3.  Une fonction de réparation qui ne corrige que les cas sûrs
4.  Comment relancer quand la réparation échoue ?
5.  La sortie structurée rend-elle tout cela inutile ?
6.  La place de BroadNet Inference

Votre code appelle `json.loads()` sur la réponse d’un modèle et obtient `JSONDecodeError: Expecting value: line 1 column 1`. Ou bien le parsing passe, mais un champ est une chaîne là où vous attendiez un nombre. Cet article classe les causes selon ce que vous pouvez faire sans risque pour chacune, fournit une fonction Python testée qui ne répare que les cas sans ambiguïté, et montre une boucle de relance qui sait quand une relance ne servira à rien.

Le choix entre le [mode JSON](https://broadrouter.com/fr/glossary/json-mode/) et `json_schema` est traité dans [mode JSON ou json\_schema](https://broadrouter.com/fr/blog/structured-output-json-schema/). Ici, il s’agit de ce qu’il faut faire de la réponse que vous avez réellement reçue.

## Pourquoi les LLM renvoient-ils du JSON invalide ?

Un modèle écrit du texte un token à la fois. Tant que le serveur ne contraint pas le décodage, rien ne l’empêche d’ajouter une phrase aimable ou de manquer de place. Les échecs courants :

| Ce que vous voyez | Cause | Réparable sans risque dans le code ? |
| --- | --- | --- |
| ` ```json ` … ` ``` ` autour de l’objet | Habitude de mise en forme du chat | Oui : retirer la balise |
| « Here is the JSON: » avant, « Let me know… » après | Même habitude | Oui : ne lire que la première valeur |
| `<think>...</think>` avant l’objet | Texte de raisonnement dans le champ content sur certains serveurs | Oui : retirer le bloc |
| Se termine au milieu d’une chaîne, accolades ouvertes | `max_tokens` atteint | Non : renvoyer avec plus de place |
| Contenu vide | Le raisonnement a consommé tout le budget | Non : renvoyer avec plus de place |
| `{"a": 1,}` | Virgule finale ; JavaScript l’accepte, la [RFC 8259](https://www.rfc-editor.org/rfc/rfc8259) non | Oui : un seul sens possible |
| `{'a': True, 'b': None}` | Syntaxe Python | Oui : `ast.literal_eval` la lit sans risque |
| `NaN`, `Infinity` | Pas du JSON ; Python les accepte par défaut | Non : rejeter |
| JSON valide, mauvais types ou champs manquants | Schéma non imposé | Non : redemander avec l’erreur |

La ligne de partage, c’est l’ambiguïté. S’il n’y a qu’une seule chose que le modèle a pu vouloir dire, corrigez-la dans le code et journalisez-le. S’il faudrait deviner, rejetez la réponse.

## Pourquoi ne pas réparer un JSON tronqué ?

Parce que la version réparée a l’air juste et ne l’est pas. Nous avons passé [json\_repair](https://github.com/mangiucugna/json_repair) 0.64.9, une bibliothèque populaire sous licence MIT, sur une réponse coupée au milieu d’un mot :

```text
'{"name": "Omar", "city": "Jed'  ->  {'name': 'Omar', 'city': 'Jed'}
```

Elle a renvoyé un JSON valide avec la ville « Jed ». Son README le dit franchement : elle « automatically completes missing values in JSON fields with reasonable defaults » (traduction : « complète automatiquement les valeurs manquantes des champs JSON avec des valeurs par défaut raisonnables »). C’est utile pour lire des logs. Pour des données que vous stockez ou sur lesquelles vous agissez, cela transforme un échec visible en échec silencieux.

Vérifiez `finish_reason` avant de parser. `"length"` signifie que la réponse a atteint [`max_tokens`](https://broadrouter.com/fr/glossary/max-tokens/). Renvoyer la même requête avec la même limite échoue de la même façon : doublez la limite ou demandez moins par appel. Les modèles de raisonnement rendent ce cas plus fréquent : la [référence de l’API](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=fr-blog-fix-invalid-json-from-llm&utm_content=body) de BroadNet indique que DeepSeek V4.1 Flash, GLM 5.3 et Qwen3.8 27B raisonnent avant de répondre, et que le raisonnement compte dans `max_tokens`. Avec une petite limite, la réponse peut revenir vide. Laissez 1 000 tokens ou plus, ou réglez `reasoning_effort` sur `low` ; [l’article sur le budget de raisonnement](https://broadrouter.com/fr/blog/reasoning-model-max-tokens-budget/) donne les chiffres.

## Une fonction de réparation qui ne corrige que les cas sûrs

Elle n’utilise que la bibliothèque standard. Elle renvoie la valeur parsée et la liste des réparations effectuées, pour que vous puissiez les compter.

```python
import ast, json, re

class Truncated(Exception): pass
class NotJSON(Exception): pass

FENCE = re.compile(r"```(?:json|JSON)?\s*\n(.*?)```", re.S)
THINK = re.compile(r"<think>.*?</think>", re.S)

def _reject_constant(name):                 # NaN, Infinity: Python accepts them, JSON does not
    raise NotJSON(f"non-standard constant {name}")

_decoder = json.JSONDecoder(parse_constant=_reject_constant)

def _first_value(s):
    """Decode the first JSON object or array in s, ignoring prose before and after it."""
    for i, ch in enumerate(s):
        if ch in "{[":
            try:
                return _decoder.raw_decode(s, i)[0]
            except json.JSONDecodeError:
                continue                    # a stray brace in prose; try the next one
    raise NotJSON("no JSON object or array found")

def _scan(s):
    """Drop commas before } or ] outside strings; report brackets left open."""
    out, stack, in_str, esc = [], [], False, False
    for i, ch in enumerate(s):
        if in_str:
            if esc:
                esc = False
            elif ch == "\\":
                esc = True
            elif ch == '"':
                in_str = False
        elif ch == '"':
            in_str = True
        elif ch in "{[":
            stack.append(ch)
        elif ch in "}]" and stack:
            stack.pop()
        elif ch == ",":
            rest = s[i + 1:].lstrip()
            if rest[:1] in ("}", "]"):
                continue                    # trailing comma: skip it
        out.append(ch)
    return "".join(out), len(stack) + (1 if in_str else 0)

def _python_literal(s):
    """Output in Python syntax: single quotes, True/False/None, trailing commas."""
    start = min((i for i in (s.find("{"), s.find("[")) if i >= 0), default=-1)
    end = max(s.rfind("}"), s.rfind("]"))
    if start < 0 or end <= start:
        raise NotJSON("no braces")
    value = ast.literal_eval(s[start:end + 1])       # literals only; never runs code
    if not isinstance(value, (dict, list)):
        raise NotJSON("not an object or array")
    json.dumps(value, allow_nan=False)               # must round-trip as strict JSON
    return value

def parse_llm_json(content, finish_reason=None):
    """Return (value, repairs). Raises Truncated or NotJSON."""
    if finish_reason == "length":
        raise Truncated("hit max_tokens; raise the limit or shorten the output")
    if not content or not content.strip():
        raise NotJSON("empty content (reasoning may have used the whole budget)")
    repairs = []
    s = content.strip().lstrip("\ufeff")
    if THINK.search(s):
        s = THINK.sub("", s).strip(); repairs.append("removed <think> block")
    m = FENCE.search(s)
    if m:
        s = m.group(1).strip(); repairs.append("removed code fence")
    try:
        value = _decoder.decode(s)
        return value, repairs
    except json.JSONDecodeError:
        pass
    try:
        value = _first_value(s); repairs.append("ignored text around JSON")
        return value, repairs
    except NotJSON:
        pass
    fixed, open_count = _scan(s)
    if open_count:
        raise NotJSON(f"incomplete JSON, {open_count} bracket(s) or string left open: treat as truncated")
    if fixed != s:
        try:
            value = _first_value(fixed); repairs.append("removed trailing commas")
            return value, repairs
        except NotJSON:
            pass
    try:
        value = _python_literal(s); repairs.append("parsed Python-style literal")
        return value, repairs
    except (ValueError, SyntaxError, TypeError, MemoryError, RecursionError, NotJSON) as e:
        raise NotJSON(f"unrepairable: {e}") from None
```

Le rôle de chaque étape :

1.  **Les réponses tronquées et vides** lèvent une exception avant tout parsing : elles ne deviennent jamais des données.
2.  **Les balises de code et les blocs de raisonnement** sont retirés par deux expressions régulières.
3.  **`raw_decode`** est l’outil clé. Selon la documentation Python, il décode un document « from a string that may have extraneous data at the end » (traduction : « à partir d’une chaîne qui peut contenir des données superflues à la fin ») et renvoie l’endroit où il s’est arrêté. En partant du premier `{` ou `[`, il saute le texte avant l’objet et ignore celui d’après. Si une accolade dans le texte ne se décode pas, il essaie la suivante.
4.  **Le balayage des accolades** parcourt le texte en suivant les chaînes et les échappements. Des accolades restées ouvertes signifient que la réponse a été coupée, même si `finish_reason` ne l’a pas signalé ; cela lève une exception. Les virgules placées juste avant `}` ou `]` hors des chaînes sont supprimées.
5.  **`ast.literal_eval`** lit la sortie à la Python, avec apostrophes simples, `True` et `None`. Il n’évalue que des littéraux et n’exécute jamais de code. Le résultat doit ensuite se sérialiser en JSON strict.
6.  **`NaN` et `Infinity`** lèvent une exception, via `parse_constant`. Le module `json` de Python les accepte par défaut ; la RFC 8259 dit qu’ils « are not permitted » (traduction : « ne sont pas autorisés »), et `JSON.parse` en JavaScript les rejette.

Nous l’avons exécutée sur 17 chaînes de test : JSON propre, JSON entre balises, clés et valeurs arabes entre balises, texte avant et après, un espace réservé `{name}` dans le texte avant l’objet, un bloc `<think>`, des virgules finales dans des objets et des tableaux, des virgules et des accolades à l’intérieur de chaînes, des guillemets échappés, un chemin Windows terminé par une barre oblique inverse, des littéraux Python, `NaN`, une réponse vide, une réponse coupée avec et sans `finish_reason: "length"`, et deux objets à la suite. Tous se sont comportés comme l’indique le tableau ci-dessus. Un test a révélé un vrai bug : une première version basculait son indicateur d’échappement avant de chercher le guillemet fermant, si bien que `"he said \"hi,]\""` perdait sa virgule. Testez votre propre code de réparation sur des guillemets échappés.

Deux limites à connaître. Face à deux objets à la suite, la fonction renvoie le premier ; si vous voulez plusieurs éléments, demandez un tableau JSON. Et une sortie Python entre apostrophes simples qui contient un guillemet double à l’intérieur d’une chaîne peut être mal lue par le balayage des accolades, puis rejetée. Rejeter est l’échec sûr.

## Comment relancer quand la réparation échoue ?

La réparation s’occupe du format. La validation s’occupe du contenu : bons champs, bons types, valeurs plausibles. Cette boucle valide avec le paquet `jsonschema` et choisit la relance selon la cause :

```python
import json, os
from jsonschema import Draft202012Validator
from openai import OpenAI
from llm_json import parse_llm_json, Truncated, NotJSON

client = OpenAI(base_url=os.environ.get("BASE_URL", "https://inference.broadnet.ai/v1"),
                api_key=os.environ["BROADNET_API_KEY"])
SCHEMA = {"type": "object", "additionalProperties": False,
          "required": ["name", "city", "amount"],
          "properties": {"name": {"type": "string", "minLength": 1},
                         "city": {"type": ["string", "null"]},
                         "amount": {"type": "number", "minimum": 0}}}
validator = Draft202012Validator(SCHEMA)

def extract(text, model="broadnet/qwen3.8-27b", max_tokens=1500, attempts=3, log=print):
    messages = [{"role": "system", "content": "Extract name, city and amount. Reply with one JSON object only, no code fence. "
                                              "Schema: " + json.dumps(SCHEMA)},
                {"role": "user", "content": text}]
    for attempt in range(1, attempts + 1):
        r = client.chat.completions.create(model=model, messages=messages, max_tokens=max_tokens,
                                           reasoning_effort="low", temperature=0)
        c = r.choices[0]
        try:
            value, repairs = parse_llm_json(c.message.content, c.finish_reason)
            errors = [f"{'/'.join(map(str, e.path)) or '(root)'}: {e.message}" for e in validator.iter_errors(value)]
            if not errors:
                log({"attempt": attempt, "repairs": repairs, "ok": True})
                return value
            problem = "The JSON does not match the schema: " + "; ".join(errors)
        except Truncated:
            log({"attempt": attempt, "ok": False, "why": "truncated"})
            max_tokens *= 2                 # same prompt, more room; a re-ask would be cut off too
            continue
        except NotJSON as e:
            problem = f"That reply was not valid JSON ({e})."
        log({"attempt": attempt, "ok": False, "why": problem})
        messages += [{"role": "assistant", "content": c.message.content or ""},
                     {"role": "user", "content": problem + " Return the corrected JSON object only."}]
    raise RuntimeError(f"no valid JSON after {attempts} attempts")
```

Les règles de cette boucle :

-   **Tronqué : renvoyer les mêmes messages avec une limite doublée.** Ajouter un message « merci de corriger » rallongerait le prompt sans raccourcir la sortie.
-   **Pas du JSON, ou mauvaise forme : renvoyer l’erreur exacte.** « amount: ‘1200’ is not of type ‘number’ » donne au modèle quelque chose de précis à corriger. Une simple relance répète souvent l’erreur.
-   **Plafonner à trois tentatives.** Chaque relance renvoie toute la conversation en [tokens d’entrée](https://broadrouter.com/fr/glossary/input-and-output-tokens/). Après trois, journalisez l’entrée et orientez-la ailleurs.
-   **Journaliser la liste des réparations.** Une hausse du nombre de « removed code fence » après une modification du prompt vous dit que le prompt s’est dégradé, même si rien n’a échoué.

Nous avons exécuté cette boucle contre un serveur factice local qui rejouait des réponses scriptées. Une réponse entre balises, avec une virgule finale et `"amount": "1200"` sous forme de chaîne, a été réparée, a échoué à la validation, puis a été corrigée au deuxième appel une fois l’erreur renvoyée. Une réponse coupée avec `finish_reason: "length"` a été renvoyée avec `max_tokens` porté de 1 500 à 3 000 et a réussi. Le serveur factice enregistrait chaque requête, ce qui a confirmé le nombre de messages et la limite envoyés par la boucle. Un vrai modèle peut échouer autrement : exécutez-la sur 100 de vos propres entrées avant de vous fier aux chiffres.

## La sortie structurée rend-elle tout cela inutile ?

Elle en supprime l’essentiel. Un serveur qui contraint le décodage à votre schéma ne peut émettre ni balise de code, ni virgule finale, ni champ manquant. vLLM, un serveur courant pour les modèles ouverts, le fait avec les backends xgrammar ou guidance. Deux échecs subsistent même alors : la troncature à `max_tokens` et les refus. OpenAI note que la sortie du mode JSON est valide « except for in some edge cases » (traduction : « sauf dans certains cas limites ») et que votre application « must detect and handle » (traduction : « doit détecter et gérer ») une sortie qui n’est pas un objet complet. Gardez donc la vérification de `finish_reason` et le validateur, même avec `json_schema`.

Ce que chaque approche évite :

| Approche | Balises et texte | Erreurs de syntaxe | Mauvaise forme | Troncature |
| --- | --- | --- | --- | --- |
| Prompt seul (« réponds en JSON ») | Moins souvent | Moins souvent | Moins souvent | Non |
| Mode JSON (`json_object`) | Oui | Oui | Non | Non |
| Sortie structurée (`json_schema`, imposée) | Oui | Oui | Oui | Non |

Avec le mode JSON, OpenAI précise aussi que vous « must always instruct the model to produce JSON » (traduction : « devez toujours demander au modèle de produire du JSON ») dans un message ; sinon, il peut émettre des espaces jusqu’à atteindre la limite de tokens. Les autres serveurs compatibles OpenAI varient : testez le mode sur le modèle que vous livrez. Le test figure dans [l’article sur la sortie structurée](https://broadrouter.com/fr/blog/structured-output-json-schema/).

Pour vérifier une réponse à la main, collez-la dans le [validateur de sortie JSON de LLM](https://broadrouter.com/tools/llm-json-output-validator/), ou construisez un schéma strict à partir d’un objet d’exemple avec le [générateur de JSON Schema](https://broadrouter.com/tools/json-schema-generator/).

## La place de BroadNet Inference

BroadRouter est le site de BroadNet. La référence de l’API de BroadNet 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/) seulement, sans nommer le paramètre de requête : testez donc `json_schema` sur le modèle avant de vous y fier. Sur [DeepSeek V4.1 Flash](https://broadrouter.com/fr/models/deepseek-v4.1-flash/) et [Gemma 4 VL 26B](https://broadrouter.com/fr/models/gemma-4-vl-26b/), demandez le JSON dans le prompt et appliquez la fonction de réparation et le validateur ci-dessus. Trois des quatre modèles raisonnent avant de répondre : prévoyez-le dans `max_tokens`. Pour l’extraction en masse, [l’article sur le traitement par lots](https://broadrouter.com/fr/blog/llm-batch-processing-without-batch-api/) montre comment journaliser `finish_reason` élément par élément. Les prompts et les réponses ne sont pas conservés après chaque requête.

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

[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.

[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.

[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.

[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.

[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.

[API batch (traitement par lots)](https://broadrouter.com/fr/glossary/batch-api/)

Une API batch est un endpoint LLM asynchrone qui accepte de nombreuses requêtes d’un coup, généralement sous forme de fichier, les traite dans une fenêtre définie plutôt qu’immédiatement et renvoie les résultats ensemble. Des fournisseurs comme OpenAI et Anthropic facturent les requêtes batch avec une remise par rapport à leurs API standard.

[Fenêtre de contexte (context window)](https://broadrouter.com/fr/glossary/context-window/)

La fenêtre de contexte est le nombre maximal de tokens qu’un modèle de langage peut traiter dans une seule requête. Elle couvre le prompt, l’historique de conversation, les définitions d’outils, les images et la sortie générée, tokens de raisonnement compris. Ce qui ne tient pas doit être coupé, résumé ou réparti sur plusieurs requêtes.

[Licence de modèle (model license)](https://broadrouter.com/fr/glossary/model-license/)

Une licence de modèle désigne les conditions juridiques selon lesquelles les poids, le code et les sorties d’un modèle peuvent être utilisés, modifiés et partagés. Les modèles open-weight utilisent des licences logicielles standard comme Apache 2.0 ou MIT, ou des licences propres pouvant ajouter des conditions, par exemple pour les grands services commerciaux.

## Questions fréquentes

### Pourquoi mon LLM renvoie-t-il le JSON dans un bloc de code markdown ?

Les modèles de chat mettent généralement le code en forme pour des humains, et une balise de code est la façon dont les interfaces de chat l’affichent. Demandez « du JSON uniquement, sans balise de code », mais retirez quand même les balises dans votre code : la consigne réduit la fréquence, elle ne la supprime pas.

### Comment corriger un JSONDecodeError sur une sortie de LLM ?

Regardez d’abord finish\_reason. S’il vaut "length", la réponse a été coupée : augmentez max\_tokens et renvoyez la requête. Sinon, retirez les balises de code et décodez la première valeur JSON avec raw\_decode, qui ignore le texte qui suit. Corrigez les virgules finales, puis validez. Si cela échoue encore, redemandez en joignant l’erreur.

### Faut-il utiliser une bibliothèque de réparation de JSON ?

Pour les logs et le débogage, oui. Pour des données sur lesquelles vous agissez, prudence. Des bibliothèques comme json\_repair complètent les valeurs manquantes par défaut : une ville tronquée "Jed" revient sous la forme d’un "Jed" valide. Rejetez la sortie tronquée et renvoyez plutôt la requête.

### Pourquoi la sortie JSON de mon LLM est-elle coupée ?

La réponse a atteint max\_tokens. Sur les modèles de raisonnement comme DeepSeek V4.1 Flash, GLM 5.3 et Qwen3.8 27B, le raisonnement compte dans cette limite : une longue réflexion peut laisser trop peu de place. Augmentez la limite, réglez reasoning\_effort sur low ou demandez moins de sortie par appel.

### Le mode JSON garantit-il un JSON valide ?

Presque. Selon OpenAI, la sortie du mode JSON est du JSON valide « except for in some edge cases » (traduction : « sauf dans certains cas limites »), par exemple quand la limite de tokens est atteinte, et le mode n’impose pas votre schéma. La sortie structurée avec json\_schema ajoute le respect du schéma là où le fournisseur l’impose. Validez dans tous les cas.

### Quels modèles BroadNet prennent en charge la sortie structurée ?

La référence de l’API de BroadNet indique la sortie structurée pour GLM 5.3 et Qwen3.8 27B, vérifié le 15 novembre 2026. Elle ne l’indique pas pour DeepSeek V4.1 Flash ni pour Gemma 4 VL 26B : sur ces modèles, demandez le JSON dans le prompt, avec réparation et validation.

## À lire ensuite

-   [Mode JSON ou json\_schema : une sortie structurée qui tient](https://broadrouter.com/fr/blog/structured-output-json-schema/)
-   [Appel d’outils et modèles ouverts : schémas, parallélisme, relances](https://broadrouter.com/fr/blog/tool-calling-open-models/)
-   [Régler max\_tokens pour les modèles de raisonnement : une méthode](https://broadrouter.com/fr/blog/reasoning-model-max-tokens-budget/)
-   [Classification de texte arabe par LLM : sentiment, intention, tri](https://broadrouter.com/fr/blog/arabic-text-classification-llm/)
-   [Traitement par lots LLM sans Batch API : un exécuteur reprenable](https://broadrouter.com/fr/blog/llm-batch-processing-without-batch-api/)
-   [Traduire les chaînes d’app en arabe par LLM : variables et pluriels](https://broadrouter.com/fr/blog/translate-app-strings-to-arabic-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 : Pourquoi un modèle de raisonnement renvoie une réponse vide](https://broadrouter.com/fr/guides/reasoning-tokens-empty-response/)
-   [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/)

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-fix-invalid-json-from-llm&utm_content=page-cta) ·

**Sources**

-   [Référence de l’API de BroadNet Inference : outils et sortie structurée indiqués pour GLM 5.3 et Qwen3.8 27B seulement ; DeepSeek V4.1 Flash, GLM 5.3 et Qwen3.8 27B raisonnent, et le raisonnement compte dans max\_tokens (vérifié le 2026-11-16) (en anglais)](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=fr-blog-fix-invalid-json-from-llm&utm_content=sources)
-   [Guide des Structured Outputs d’OpenAI : mode JSON ou respect du schéma, demander explicitement du JSON, espaces jusqu’à la limite de tokens, sortie incomplète, refus (vérifié le 2026-11-15)](https://developers.openai.com/api/docs/guides/structured-outputs)
-   [IETF RFC 8259, The JSON Data Interchange Format : grammaire des objets, chaînes entre guillemets doubles, Infinity et NaN interdits (vérifié le 2026-11-15)](https://www.rfc-editor.org/rfc/rfc8259)
-   [Documentation Python, module json : JSONDecoder.raw\_decode, NaN et Infinity acceptés par défaut, parse\_constant (vérifié le 2026-11-15)](https://docs.python.org/3/library/json.html)
-   [json\_repair sur GitHub (MIT) : répare le JSON mal formé et complète les valeurs manquantes par défaut (version 0.64.9 testée ; vérifié le 2026-11-15)](https://github.com/mangiucugna/json_repair)
-   [Documentation vLLM, structured outputs : json\_schema, regex, choice et grammaire avec les backends xgrammar ou guidance (vérifié le 2026-11-15)](https://docs.vllm.ai/en/latest/features/structured_outputs.html)
