---
title: "max_tokens et modèles de raisonnement : quel budget ?"
description: "Pourquoi un modèle de raisonnement renvoie une réponse vide avec un max_tokens bas, et comment fixer le budget : percentiles, fenêtre de contexte, relance."
url: https://broadrouter.com/fr/blog/reasoning-model-max-tokens-budget/
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/reasoning-model-max-tokens-budget/) (mis à jour le 2026-11-15).

# Régler max\_tokens pour les modèles de raisonnement : une méthode

Par l’équipe BroadNet Inference · 6 min de lecture · Publié 2026-11-15

Sur un modèle de raisonnement, max\_tokens plafonne la réflexion et la réponse ensemble : une limite serrée peut donc couper la réponse avant tout texte visible. Mesurez le total des tokens de complétion par type de tâche, réglez max\_tokens à environ le 95e percentile plus 20 %, gardez prompt plus max\_tokens dans la fenêtre de contexte, et relancez les réponses coupées avec un budget doublé jusqu’à un plafond strict.

## À retenir

-   max\_tokens est un plafond, pas un montant facturé. Vous payez les tokens générés : un plafond généreux ne coûte rien sur les réponses qui se terminent avant.
-   C’est un plafond serré qui coûte de l’argent : une réponse coupée facture sa réflexion, ne renvoie aucune réponse et doit être renvoyée.
-   Budgétez par type de tâche à partir de vos propres logs : le 95e percentile des tokens de complétion plus une marge de 20 % est un bon point de départ.
-   Les tokens du prompt plus max\_tokens doivent tenir dans la fenêtre de contexte : 262 144 tokens sur Qwen3.8 27B, 1 048 576 sur GLM 5.3 et DeepSeek V4.1 Flash.
-   Traitez finish\_reason « length » comme un signal : relancez avec un budget doublé ou un reasoning\_effort plus bas, avec un plafond strict.

**Sur cette page**

1.  Pourquoi le budget s’épuise-t-il avant la réponse ?
2.  Un max\_tokens plus grand coûte-t-il plus cher ?
3.  Comment mesurer ce dont une tâche a besoin ?
4.  Comment la fenêtre de contexte limite-t-elle le budget ?
5.  Que faire quand une réponse est quand même coupée ?
6.  Qu’est-ce que le streaming change ?
7.  Quel nom de paramètre envoyer ?
8.  La place de BroadNet Inference

Un modèle de raisonnement réfléchit avant de répondre, et sur la plupart des API compatibles OpenAI, les deux puisent dans un seul budget : `max_tokens`. Réglez-le comme pour un modèle sans raisonnement, quelques centaines de tokens pour une réponse courte, et certaines réponses reviennent vides avec `finish_reason: "length"`. La correction rapide se trouve dans [pourquoi un modèle de raisonnement renvoie une réponse vide](https://broadrouter.com/fr/guides/reasoning-tokens-empty-response/). Cet article présente la méthode derrière un budget fiable : mesurer, dimensionner à partir des percentiles, respecter la fenêtre de contexte, et gérer les réponses qui restent coupées.

Pour ce que coûte le raisonnement et comment le réduire, voir [tokens de raisonnement : pourquoi vous payez plus de sortie que vous n’en voyez](https://broadrouter.com/fr/blog/reasoning-tokens-cost/).

## Pourquoi le budget s’épuise-t-il avant la réponse ?

Le modèle génère dans l’ordre : d’abord son raisonnement, puis la réponse visible. Chaque token des deux compte dans `max_tokens`. La documentation de BroadNet le dit pour DeepSeek V4.1 Flash, GLM 5.3 et Qwen3.8 27B : « the reasoning counts toward max\_tokens » (traduction : « le raisonnement compte dans max\_tokens »), et avec une limite basse « the answer comes back empty » (traduction : « la réponse revient vide »). La référence Chat Completions d’OpenAI définit `max_completion_tokens` de la même façon, comme une borne supérieure « including visible output tokens and reasoning tokens » (traduction : « incluant les tokens de sortie visibles et les tokens de raisonnement »).

La question à se poser n’est donc pas « quelle est la longueur de ma réponse ? », mais « quelle est la longueur du raisonnement et de la réponse ensemble, sur cette tâche, à cet effort ? ». Cela varie plus qu’on ne le pense. Le guide d’OpenAI indique que ses modèles peuvent générer « anywhere from a few hundred to tens of thousands of reasoning tokens » (traduction : « de quelques centaines à des dizaines de milliers de tokens de raisonnement »), selon le problème.

## Un max\_tokens plus grand coûte-t-il plus cher ?

Non. C’est la raison la plus fréquente des budgets trop serrés. [`max_tokens`](https://broadrouter.com/fr/glossary/max-tokens/) est un plafond. Vous êtes facturé pour les tokens réellement générés. Une réponse qui a besoin de 1 800 tokens coûte la même chose avec un plafond de 4 000 ou de 40 000.

Ce que coûte un plafond serré :

| Plafond par rapport au besoin | Ce que vous payez | Ce que vous obtenez |
| --- | --- | --- |
| Plafond au-dessus du besoin | Les tokens générés | La réponse |
| Plafond en dessous du besoin | Le plafond entier, uniquement du raisonnement | Rien d’exploitable, plus une relance |

Prenons une illustration. Supposons qu’un quart de vos appels ait besoin de plus de 1 000 tokens. Avec `max_tokens=1000`, chacun de ces appels facture 1 000 tokens de sortie de réflexion, ne renvoie rien et doit être relancé. Cela ajoute en moyenne 250 tokens de sortie gaspillés par appel sur l’ensemble des appels, avant même les relances, plus la latence d’une deuxième requête. Avec un plafond à 4 000, rien n’est gaspillé. Sur [Qwen3.8 27B](https://broadrouter.com/fr/models/qwen3.8-27b/), la sortie coûte $2.17 par million de tokens : le gaspillage s’accumule vite à grande échelle.

Le vrai risque d’un plafond élevé est une réponse qui s’emballe : un modèle qui boucle ou réfléchit trop et génère bien plus que nécessaire. Un plafond strict limite ce risque. Choisissez-le à partir des données, comme ci-dessous.

## Comment mesurer ce dont une tâche a besoin ?

Faites tourner des prompts réels pour un type de tâche avec un plafond généreux, et enregistrez les tokens de complétion et la part de raisonnement. Quand le modèle la fournit, `usage.completion_tokens_details.reasoning_tokens` donne la part de raisonnement ; la documentation de BroadNet liste ce champ.

```python
import os
from openai import OpenAI

client = OpenAI(base_url="https://inference.broadnet.ai/v1", api_key=os.environ["BROADNET_API_KEY"])
MODEL = "broadnet/qwen3.8-27b"

def measure(prompts, ceiling=16_000, **kw):
    """Run real prompts with a generous ceiling and return per-call token counts."""
    rows = []
    for p in prompts:
        r = client.chat.completions.create(model=MODEL, max_tokens=ceiling,
                                           messages=[{"role": "user", "content": p}], **kw)
        u, d = r.usage, r.usage.completion_tokens_details
        reasoning = (d.reasoning_tokens or 0) if d else 0
        rows.append({"reasoning": reasoning, "answer": u.completion_tokens - reasoning,
                     "finish": r.choices[0].finish_reason})
    return rows

def pct(values, q):
    values = sorted(values)
    return values[min(len(values) - 1, int(q * len(values)))]

def recommend(rows, margin=1.2):
    total = [r["reasoning"] + r["answer"] for r in rows]
    return {"p50": pct(total, 0.5), "p95": pct(total, 0.95), "max": max(total),
            "max_tokens": int(pct(total, 0.95) * margin),
            "cut_off": sum(r["finish"] == "length" for r in rows)}

# print(recommend(measure(my_prompts)))                       # default effort
# print(recommend(measure(my_prompts, reasoning_effort="low")))
```

Règles pour obtenir un chiffre fiable :

1.  **Un type de tâche par série.** Classification, extraction, revue de code et planification ont des distributions très différentes. Un `max_tokens` global soit gaspille de l’argent en relances, soit laisse passer les réponses qui s’emballent.
2.  **50 prompts réels ou plus.** Le 95e percentile de dix échantillons n’est que le plus grand d’entre eux.
3.  **Mesurez à chaque niveau d’effort utilisé.** `reasoning_effort="low"` modifie la distribution. BroadNet documente `low` ; testez les autres valeurs avant de vous y fier.
4.  **Si `cut_off` n’est pas nul, relevez le plafond et recommencez.** Un échantillon coupé cache sa vraie longueur.
5.  **Recommencez quand le modèle ou le prompt change.** Une nouvelle version du modèle peut réfléchir plus ou moins.

Réglez ensuite `max_tokens` par tâche à partir de `recommend()`. Le 95e percentile plus 20 % laisse la plupart des appels bien en dessous du plafond et n’envoie que les rares cas longs vers le chemin de relance ci-dessous. L’[outil gratuit de budget de tokens de raisonnement](https://broadrouter.com/tools/reasoning-token-budget/) fait ce calcul dans votre navigateur une fois que vous avez vos chiffres.

## Comment la fenêtre de contexte limite-t-elle le budget ?

La fenêtre de contexte contient le prompt et la réponse ensemble. Le flux de prix de BroadNet définit `context_length` comme « the most tokens one request can hold, prompt and answer together » (traduction : « le nombre maximal de tokens qu’une requête peut contenir, prompt et réponse ensemble »). Donc :

**max\_tokens ≤ longueur du contexte − tokens du prompt**

| Modèle | Contexte | Place pour max\_tokens avec un prompt de 200 000 tokens |
| --- | --- | --- |
| [GLM 5.3](https://broadrouter.com/fr/models/glm-5.3/) | 1 048 576 | 848 576 |
| [DeepSeek V4.1 Flash](https://broadrouter.com/fr/models/deepseek-v4.1-flash/) | 1 048 576 | 848 576 |
| Qwen3.8 27B | 262 144 | 62 144 |

Cela compte pour le travail en contexte long. Un agent dont l’historique a atteint 250 000 tokens sur Qwen3.8 27B n’a plus qu’environ 12 000 tokens pour réfléchir et répondre. Les tâches en contexte long demandent aussi souvent plus de raisonnement : vérifiez donc la place restante au moment de l’appel, pas une seule fois au démarrage. [Fenêtre de contexte](https://broadrouter.com/fr/glossary/context-window/) et le [calculateur de fenêtre de contexte](https://broadrouter.com/tools/context-window-calculator/) vous aident à vérifier que tout tient.

## Que faire quand une réponse est quand même coupée ?

Vérifiez `finish_reason` à chaque appel. S’il vaut `length`, la réponse manque ou est incomplète, même si `content` contient du texte. Ne l’analysez pas comme si elle était complète ; un objet JSON tronqué est une source fréquente d’erreurs en aval ([sortie structurée](https://broadrouter.com/fr/blog/structured-output-json-schema/)).

Relancez avec un budget doublé, dans la place que laisse le contexte, jusqu’à un plafond strict :

```python
import json, urllib.request

FEED = json.load(urllib.request.urlopen("https://inference.broadnet.ai/pricing.json"))
CONTEXT = {m["id"]: m.get("context_length") for m in FEED["models"]}

def ask(model, messages, budget=4_000, hard_cap=32_000, **kw):
    """Retry a cut-off reply with a doubled budget, never past the cap or the context window."""
    while True:
        r = client.chat.completions.create(model=model, messages=messages,
                                           max_tokens=budget, **kw)
        if r.choices[0].finish_reason != "length":
            return r
        room = CONTEXT[model] - r.usage.prompt_tokens        # context holds prompt + answer
        nxt = min(budget * 2, hard_cap, room)
        if nxt <= budget:
            raise RuntimeError(f"still cut off at max_tokens={budget}")
        print(f"cut off at {budget}, retrying with {nxt}")
        budget = nxt
```

Deux alternatives au doublement, selon la tâche :

-   **Relancer avec `reasoning_effort="low"`** et le même budget. Sur les tâches simples, le modèle réfléchit souvent trop, et moins d’effort règle le problème sans relever le plafond.
-   **Découper la tâche.** Si une réponse atteint sans cesse un plafond élevé, la requête en demande généralement trop à la fois.

Journalisez chaque coupure avec le type de tâche. Un taux en hausse signifie que le prompt, le modèle ou les données d’entrée ont changé, et que le budget doit être remesuré. Les relances sont de nouvelles inférences et sont facturées à nouveau : limitez donc le nombre de tentatives, comme dans [agents de longue durée : timeouts et relances](https://broadrouter.com/fr/blog/long-running-agents-timeouts-retries/).

## Qu’est-ce que le streaming change ?

Avec `stream=True`, le raisonnement a lieu avant le premier token visible : un modèle de raisonnement peut donc sembler bloqué au début. Dans une interface de chat, affichez un état « réflexion en cours » jusqu’à l’arrivée du contenu, et dimensionnez les timeouts du client pour le temps de réflexion, pas seulement pour la réponse.

Certains serveurs diffusent aussi le texte du raisonnement lui-même, dans un champ séparé. Son nom n’est pas standard : l’API de DeepSeek utilise `reasoning_content`, et vLLM a renommé son champ de `reasoning_content` en `reasoning`, en prévenant que l’ancien code client « could silently read an empty » (traduction : « pourrait lire silencieusement un champ vide »). La documentation de BroadNet ne documente aucun champ de texte de raisonnement : ne construisez donc pas de fonctionnalité dessus sans vérifier la réponse brute pour votre modèle. Si vous le lisez, faites-le de manière défensive :

```python
for chunk in stream:
    if chunk.choices:
        delta = chunk.choices[0].delta
        thinking = getattr(delta, "reasoning", None) or getattr(delta, "reasoning_content", None)
        # log or display `thinking` only if your provider actually sends it
        if delta.content:
            print(delta.content, end="")
    elif chunk.usage:                                  # last chunk, with include_usage
        print("\nreasoning tokens:", getattr(chunk.usage.completion_tokens_details, "reasoning_tokens", None))
```

L’usage dans le dernier chunk nécessite `stream_options={"include_usage": True}`, que BroadNet documente. Plus de détails sur les flux dans [le guide du streaming](https://broadrouter.com/fr/guides/streaming-chat-completions/) et [SSE expliqué](https://broadrouter.com/fr/blog/llm-streaming-sse-explained/).

## Quel nom de paramètre envoyer ?

| API | Paramètre | Inclut le raisonnement |
| --- | --- | --- |
| OpenAI Chat Completions | `max_completion_tokens` (`max_tokens` obsolète) | Oui |
| OpenAI Responses | `max_output_tokens` | Oui |
| BroadNet Inference (Chat Completions) | `max_tokens`, comme documenté | Oui |
| Serveurs vLLM | `max_tokens`, plus `thinking_token_budget` en option | Oui |

Quand vous déplacez du code d’un fournisseur à l’autre, envoyez le nom que le fournisseur documente, et confirmez avec un appel de test que la limite s’applique. Une limite ignorée en silence semble fonctionner jusqu’à l’arrivée d’une réponse qui s’emballe. La [checklist de migration](https://broadrouter.com/fr/blog/openai-compatible-api-migration-checklist/) couvre les autres paramètres qui changent.

## La place de BroadNet Inference

Les trois modèles de raisonnement de BroadNet indiquent les tokens de raisonnement dans `usage` quand le modèle les fournit : la mesure ci-dessus fonctionne donc telle quelle. DeepSeek V4.1 Flash et GLM 5.3 offrent le plus de place, avec 1 048 576 tokens de contexte. Qwen3.8 27B en a 262 144. Si une tâche n’a pas besoin de raisonnement, [Gemma 4 VL 26B](https://broadrouter.com/fr/models/gemma-4-vl-26b/) n’est pas listé comme modèle de raisonnement et évite complètement la question du budget. Sur un [forfait DeepSeek V4.1 Flash](https://broadrouter.com/fr/guides/unlimited-llm-api-sessions/) à prix fixe, les tokens de réflexion ne sont pas facturés au token, mais les réponses coupées coûtent quand même du temps : la même méthode de budget s’applique. BroadNet ne documente pas de plafond de raisonnement séparé ; si vous en avez besoin, utilisez un fournisseur ou un serveur auto-hébergé qui le propose.

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.

[Tokens de raisonnement (reasoning tokens)](https://broadrouter.com/fr/glossary/reasoning-tokens/)

Les tokens de raisonnement sont les tokens qu’un modèle de raisonnement génère pour résoudre un problème avant d’écrire sa réponse visible. Ils sont généralement facturés comme des tokens de sortie, comptent dans la limite de sortie et dans la fenêtre de contexte, et peuvent être masqués ou résumés par l’API.

[Tokens d’entrée et de sortie](https://broadrouter.com/fr/glossary/input-and-output-tokens/)

Les tokens d’entrée sont les tokens qu’un modèle de langage lit dans une requête, dont le prompt système, l’historique de conversation, les définitions d’outils et les images. Les tokens de sortie sont ceux qu’il génère en réponse, raisonnement compris. Les API LLM les facturent généralement séparément, et la sortie coûte en général plus cher.

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

[max\_tokens](https://broadrouter.com/fr/glossary/max-tokens/)

max\_tokens est un paramètre des API LLM qui fixe le nombre maximal de tokens qu’un modèle peut générer dans une réponse. Quand la génération atteint la limite, elle s’arrête et la réponse est marquée comme coupée, par exemple avec finish\_reason égal à « length ».

[Streaming](https://broadrouter.com/fr/glossary/streaming/)

Le streaming est une manière de renvoyer la réponse d’un modèle de langage par petits chunks pendant sa génération, plutôt qu’en un seul bloc à la fin. Les API compatibles OpenAI streament via des server-sent events quand la requête règle stream sur true.

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

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

## Questions fréquentes

### Pourquoi mon modèle de raisonnement renvoie-t-il une réponse vide ?

Le modèle a consommé tout le budget max\_tokens en raisonnement caché avant d’écrire la réponse. finish\_reason vaut alors « length ». Augmentez max\_tokens, baissez reasoning\_effort, ou les deux. Un guide court avec la correction rapide est lié depuis cet article.

### Quel max\_tokens choisir pour un modèle de raisonnement ?

Mesurez d’abord. Faites tourner 50 prompts réels ou plus avec un plafond généreux, prenez le 95e percentile de completion\_tokens pour cette tâche et ajoutez environ 20 %. La documentation de BroadNet donne 1 000 tokens ou plus comme minimum ; OpenAI conseille de réserver 25 000 tokens pour débuter sur ses modèles.

### Un max\_tokens plus élevé coûte-t-il plus cher ?

Pas en soi. Vous êtes facturé pour les tokens générés par le modèle, pas pour le plafond. Un plafond plus haut ne coûte davantage que lorsqu’une réponse aurait sinon été coupée, et dans ce cas la réponse coupée vous aurait de toute façon coûté une relance.

### max\_completion\_tokens est-il identique à max\_tokens ?

Chez OpenAI, max\_completion\_tokens remplace max\_tokens, désormais obsolète, et inclut explicitement les tokens de raisonnement. Beaucoup de fournisseurs compatibles OpenAI documentent plutôt max\_tokens. La documentation de BroadNet utilise max\_tokens et précise que le raisonnement y est compté.

### Puis-je plafonner le raisonnement séparément de la réponse ?

Seulement si le serveur le permet. vLLM propose un paramètre thinking\_token\_budget, et certains fournisseurs ont le leur. BroadNet documente reasoning\_effort à low, pas de plafond de raisonnement séparé : budgétez donc les deux ensemble.

## À lire ensuite

-   [Tokens de raisonnement : pourquoi vous payez plus de sortie que prévu](https://broadrouter.com/fr/blog/reasoning-tokens-cost/)
-   [Le streaming LLM expliqué : chunks SSE, deltas, usage et annulation](https://broadrouter.com/fr/blog/llm-streaming-sse-explained/)
-   [Mode JSON ou json\_schema : une sortie structurée qui tient](https://broadrouter.com/fr/blog/structured-output-json-schema/)
-   [Agents de longue durée : timeouts, retries et checkpoints qui tiennent](https://broadrouter.com/fr/blog/long-running-agents-timeouts-retries/)
-   [Passer à une API compatible OpenAI : la checklist de migration](https://broadrouter.com/fr/blog/openai-compatible-api-migration-checklist/)
-   [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 : Streamer des chat completions et gérer les connexions coupées](https://broadrouter.com/fr/guides/streaming-chat-completions/)
-   [Guide : Utiliser le SDK Python d’OpenAI avec BroadNet Inference](https://broadrouter.com/fr/guides/openai-python-sdk/)

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-reasoning-model-max-tokens-budget&utm_content=page-cta) ·

**Sources**

-   [Référence de l’API BroadNet Inference : le raisonnement compte dans max\_tokens, 1 000 tokens ou plus, reasoning\_effort low, champs usage (vérifiée le 2026-11-15) (en anglais)](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=fr-blog-reasoning-model-max-tokens-budget&utm_content=sources)
-   [Référence des champs de pricing.json de BroadNet : context\_length contient le prompt et la réponse ensemble (vérifiée le 2026-11-15) (en anglais)](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=fr-blog-reasoning-model-max-tokens-budget&utm_content=sources#pricing-json)
-   [Guide du raisonnement d’OpenAI : réponses incomplètes, réserver au moins 25 000 tokens pour commencer (vérifié le 2026-11-15)](https://developers.openai.com/api/docs/guides/reasoning)
-   [Référence Chat Completions d’OpenAI : max\_completion\_tokens inclut les tokens de raisonnement ; max\_tokens obsolète (vérifiée le 2026-11-15)](https://developers.openai.com/api/reference/resources/chat/subresources/completions/methods/create)
-   [Documentation de l’API DeepSeek, mode thinking : champ reasoning\_content, niveaux d’effort (vérifiée le 2026-11-15)](https://api-docs.deepseek.com/guides/thinking_mode)
-   [Documentation vLLM, sorties de raisonnement : champ reasoning (anciennement reasoning\_content), thinking\_token\_budget (vérifiée le 2026-11-15)](https://docs.vllm.ai/en/latest/features/reasoning_outputs.html)
