Comment utiliser l'API Qwen 3.7 ?

L'équipe Qwen d'Alibaba a lancé Qwen3.7-Max-Preview à la mi-mai 2026, et les développeurs ont immédiatement commencé à se poser la même question : comment l'appeler depuis mon propre code ? Le modèle est un système de raisonnement phare avec une fenêtre de contexte de 1M de jetons et des traces explicites de chaîne de pensée, idéal pour les backends d'agents, l'analyse de documents longs et la génération de code. Mais le terme « préversion » (preview) en dit long. L'accès est restreint, la surface de l'API est encore en cours de stabilisation, et les détails nécessaires pour écrire du code fonctionnel sont dispersés entre les notes de version et la documentation de la plateforme.

En bref

Qwen3.7-Max-Preview est le modèle de raisonnement phare d'Alibaba, lancé en préversion le 14 mai 2026, avec une fenêtre de contexte de 1M de jetons. Pendant la préversion, le moyen le plus fiable de l'utiliser est Qwen Chat (chat.qwen.ai) ; l'accès à l'API de production se fait via Alibaba Cloud Model Studio (DashScope) en utilisant un point de terminaison compatible OpenAI, où vous définissez une URL de base, transmettez votre clé comme un jeton Bearer et appelez /chat/completions. Étant donné que la version 3.7 est uniquement en préversion, confirmez l'ID exact du modèle et le point de terminaison dans la documentation officielle avant de déployer, et utilisez Apidog pour tester et simuler le point de terminaison pendant que la disponibilité se stabilise.

Comment accéder à Qwen 3.7 dès maintenant

Qwen déploie ses modèles sur plusieurs plateformes, et tous ne sont pas disponibles simultanément. Fin mai 2026, voici l'état actuel de l'accès.

Qwen Chat (chat.qwen.ai). Le moyen le plus rapide d'essayer Qwen3.7-Max-Preview. Connectez-vous avec un compte Qwen gratuit, choisissez qwen3.7-max-preview dans le sélecteur de modèle et activez le mode de réflexion (Thinking Mode) pour voir la trace de raisonnement. Il y a des limites de taux d'utilisation pendant la préversion, mais c'est gratuit et ne nécessite aucune configuration. C'est un produit de navigateur, pas une API, donc il est destiné à l'évaluation plutôt qu'à l'intégration.

Alibaba Cloud Model Studio (DashScope). C'est ici que les modèles Qwen deviennent une véritable API. Model Studio expose Qwen via un point de terminaison compatible OpenAI, de sorte que tout code qui communique déjà avec le SDK OpenAI peut appeler Qwen en échangeant une URL de base et une clé. Les versions antérieures comme qwen3.6-max-preview et la famille qwen-max sont déjà disponibles ici. La version 3.7 en préversion pourrait ne pas encore avoir d'entrée API publique au moment où vous lisez ceci ; Qwen a historiquement ouvert l'accès API quelques semaines après la préversion du chat.

Le modèle compatible OpenAI. Chaque modèle Qwen récent sur Model Studio suit la même structure. Vous dirigez le client OpenAI standard vers une URL de base DashScope, vous authentifiez avec un jeton Bearer et appelez la route de complétions de chat. Ce modèle est stable à travers les versions, donc le code ci-dessous continuera de fonctionner lorsque l'ID du modèle 3.7 sera disponible ; vous changerez principalement une seule chaîne de caractères.

Étant donné que l'identifiant du modèle et le point de terminaison peuvent changer pendant une préversion, considérez la documentation officielle de Qwen et la liste des modèles Model Studio comme la source de vérité. Pour une approche sans coût en attendant l'accès à l'API, notre guide sur la façon d'utiliser Qwen 3.7 gratuitement couvre en détail les canaux de préversion.

Méthodes d'accès en un coup d'œil

Une distinction à noter : les modèles Qwen open-weight atteignent Hugging Face, mais la version Max-Preview est propriétaire, ne vous attendez donc pas à des poids téléchargeables pour qwen3.7-max-preview.

Obtenir une clé API Qwen 3.7

L'accès à l'API se fait via un compte Alibaba Cloud. Les étapes sont simples.

1. Créez un compte Alibaba Cloud et ouvrez la console Model Studio (modelstudio.console.alibabacloud.com).
2. Activez Model Studio pour votre compte et votre région. Les clés sont spécifiques à la région, donc une clé pour le point de terminaison de Singapour ne fonctionnera pas pour Pékin.
3. Ouvrez la section des clés API de la console et générez une clé. Elle ressemble à sk- suivie d'une chaîne de caractères.
4. Copiez la clé une fois et stockez-la comme un mot de passe.

Choisissez votre région délibérément, car elle définit votre URL de base :

Ne codez jamais la clé en dur dans le code source que vous commettez. Placez-la plutôt dans une variable d'environnement :

# macOS / Linux
export DASHSCOPE_API_KEY="sk-your-key-here"

# Windows PowerShell
setx DASHSCOPE_API_KEY "sk-your-key-here"

Votre code lit DASHSCOPE_API_KEY à l'exécution. Cela maintient le secret hors de votre dépôt et vous permet de faire pivoter les clés sans toucher au code. Cette même habitude s'applique quel que soit le modèle que vous appelez ; vous verrez le même modèle dans notre guide de l'API Gemini 3.5.

Votre première requête : Python, curl et JavaScript

Le point de terminaison de Model Studio de Qwen est compatible OpenAI, vous avez donc deux options : le SDK OpenAI officiel pointé vers l'URL de base DashScope, ou un appel HTTP brut. Les deux sont présentés ci-dessous.

Une remarque avant le code. L'ID de modèle qwen3.7-max-preview est l'identifiant que Qwen Chat utilise pour le modèle de préversion. La chaîne exacte attendue par l'API peut différer pendant une fenêtre de préversion, et une version plus ancienne comme qwen3.6-max-preview pourrait être active lorsque vous essayez ceci. Confirmez l'ID de modèle actuel dans la liste des modèles Model Studio, puis insérez-le dans le champ model. La forme de la requête ne change pas.

Python avec le SDK OpenAI

Installez le SDK avec pip install openai, puis envoyez une requête :

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["DASHSCOPE_API_KEY"],
    # Use the base URL for your account's region
    base_url="https://dashscope-intl.aliyuncs.com/compatible-mode/v1",
)

response = client.chat.completions.create(
    # Confirm the live model ID in the Model Studio model list
    model="qwen3.7-max-preview",
    messages=[
        {"role": "system", "content": "You are a precise coding assistant."},
        {"role": "user", "content": "Write a Python function that reverses a linked list."},
    ],
)

print(response.choices[0].message.content)

C'est une requête complète. Le tableau messages suit le modèle de rôle standard : un message system définit le comportement, puis les tours de user. La réponse contient le texte généré dans choices[0].message.content.

curl

Pour une vérification rapide depuis le terminal, ou pour confirmer qu'une clé fonctionne avant d'écrire du code d'application :

curl 'https://dashscope-intl.aliyuncs.com/compatible-mode/v1/chat/completions' \
  --header "Authorization: Bearer $DASHSCOPE_API_KEY" \
  --header 'Content-Type: application/json' \
  --data '{
    "model": "qwen3.7-max-preview",
    "messages": [
      {"role": "user", "content": "Explain idempotency in REST APIs in two sentences."}
    ]
  }'

Si la clé et l'ID du modèle sont valides, vous recevez une réponse JSON avec la complétion. Sinon, le corps de l'erreur vous indique ce qu'il faut corriger ; plus de détails sur les erreurs ci-dessous.

JavaScript / Node.js

Le même SDK OpenAI fonctionne sous Node. Installez-le avec npm install openai :

import OpenAI from "openai";

const client = new OpenAI({
  apiKey: process.env.DASHSCOPE_API_KEY,
  baseURL: "https://dashscope-intl.aliyuncs.com/compatible-mode/v1",
});

const response = await client.chat.completions.create({
  model: "qwen3.7-max-preview",
  messages: [
    { role: "user", content: "List three trade-offs of GraphQL versus REST." },
  ],
});

console.log(response.choices[0].message.content);

Trois langages, une seule forme de requête ; c'est l'avantage d'une API compatible OpenAI.

Réponses en streaming

Pour toute interface utilisateur, vous ne voulez pas attendre la complétion complète avant d'afficher la sortie. Le streaming envoie les jetons au fur et à mesure qu'ils sont générés. Réglez stream sur true et itérez sur les fragments.

stream = client.chat.completions.create(
    model="qwen3.7-max-preview",
    messages=[
        {"role": "user", "content": "Summarize the CAP theorem."},
    ],
    stream=True,
)

for chunk in stream:
    delta = chunk.choices[0].delta.content
    if delta:
        print(delta, end="", flush=True)

En Node, la réponse streamée est un itérable asynchrone :

const stream = await client.chat.completions.create({
  model: "qwen3.7-max-preview",
  messages: [{ role: "user", content: "Summarize the CAP theorem." }],
  stream: true,
});

for await (const chunk of stream) {
  process.stdout.write(chunk.choices[0]?.delta?.content || "");
}

Le streaming est plus important avec un modèle de raisonnement qu'avec un simple modèle de chat. Qwen 3.7 peut passer un temps considérable sur sa chaîne de pensée avant la réponse finale, donc sans streaming, l'utilisateur fixe un écran vide. Avec le streaming, vous pouvez afficher la trace de la réflexion, un indicateur de frappe ou la réponse au fur et à mesure qu'elle se forme.

Le paramètre de raisonnement et de réflexion

Qwen3.7-Max-Preview est un modèle de raisonnement. Il peut produire une chaîne de pensée explicite à l'intérieur de blocs <think> avant de s'engager sur une réponse finale. Cette trace améliore ses scores sur les problèmes mathématiques et les problèmes complexes à plusieurs étapes, et elle aide au débogage : vous pouvez voir où la logique du modèle a déraillé.

Sur les modèles Qwen récents servis via DashScope, le comportement de réflexion est contrôlé par un drapeau enable_thinking. Confirmez le mécanisme exact et le nom du paramètre pour la version 3.7 en préversion par rapport à la référence API actuelle, car les contrôles de raisonnement ont changé entre les versions de Qwen. Conceptuellement, la requête ressemble à ceci :

response = client.chat.completions.create(
    model="qwen3.7-max-preview",
    messages=[
        {"role": "user", "content": "A train leaves at 2pm averaging 60mph. "
                                    "A second leaves at 3pm at 75mph on the same route. "
                                    "When does the second catch the first?"},
    ],
    # Reasoning controls vary by Qwen version; confirm the current
    # parameter in the Model Studio API reference before relying on it.
    extra_body={"enable_thinking": True},
)

print(response.choices[0].message.content)

Quelques notes pratiques :

• La réflexion coûte des jetons et du temps. La trace de raisonnement est du texte généré. Elle compte dans la sortie et ajoute de la latence. Pour de simples recherches ou du formatage, désactivez la réflexion.
• Activez-la pour les problèmes difficiles. Les mathématiques à plusieurs étapes, le code avec des cas limites délicats, la planification et l'analyse sont les domaines où la chaîne de pensée justifie son coût.
• Décidez si vous voulez afficher la trace. Certaines applications affichent le contenu <think> pour que les utilisateurs voient le travail du modèle ; d'autres le suppriment et n'affichent que la réponse finale. Les deux approches sont valides.

Si vous évaluez la qualité du raisonnement et le coût par rapport à d'autres modèles de pointe, notre comparaison de Qwen 3.7 vs GPT-5.5 vs Opus 4.7 met les compromis côte à côte. Les modèles de raisonnement peuvent consommer rapidement des jetons dans les boucles d'agents ; si c'est votre situation, les techniques présentées dans notre article sur la façon de réduire les coûts en jetons d'agent s'appliquent directement.

Gestion des erreurs et limites de débit

Une requête peut échouer pour des raisons prévisibles. Gérez-les afin que votre application se dégrade gracieusement.

Les modèles de préversion renvoient plus souvent des erreurs 403 et 404 que les modèles stables, car l'accès est restreint et les identifiants peuvent changer. Si vous obtenez l'une de ces erreurs, le problème est généralement lié à l'accès ou à la chaîne du modèle, et non à votre code.

Les limites de débit sur Model Studio sont définies par compte en requêtes par seconde ou par minute, et les chiffres exacts dépendent de votre niveau de compte et du modèle ; vérifiez la console plutôt que de supposer une valeur fixe. Le modèle est le même, quel que soit le cas : interceptez 429, attendez et réessayez avec des délais croissants.

import time
from openai import OpenAI, RateLimitError, APIStatusError

client = OpenAI(
    api_key=os.environ["DASHSCOPE_API_KEY"],
    base_url="https://dashscope-intl.aliyuncs.com/compatible-mode/v1",
)

def ask_qwen(prompt, max_retries=4):
    for attempt in range(max_retries):
        try:
            response = client.chat.completions.create(
                model="qwen3.7-max-preview",
                messages=[{"role": "user", "content": prompt}],
            )
            return response.choices[0].message.content
        except RateLimitError:
            wait = 2 ** attempt          # 1s, 2s, 4s, 8s
            print(f"Limite de débit atteinte. Nouvelle tentative dans {wait}s...")
            time.sleep(wait)
        except APIStatusError as e:
            # 400/401/403/404 are not worth retrying; surface them
            print(f"Erreur API {e.status_code}: {e.message}")
            raise
    raise RuntimeError("Échec après les tentatives")

Un backoff exponentiel sur les erreurs 429 et 5xx, échec rapide sur les erreurs 4xx. Cette distinction vous évite de surcharger l'API avec des erreurs qu'une nouvelle tentative ne résoudra pas.

Tester et simuler l'API Qwen avec Apidog

C'est là qu'une API de préversion devient difficile, et où de bons outils s'avèrent payants. Lorsque l'accès est restreint, l'ID du modèle change et les limites de débit sont strictes, vous ne voulez pas tester en exécutant toute votre application et en lisant les journaux. Vous voulez envoyer une requête, voir exactement ce qui revient, et la garder pour la réexécuter. Apidog est conçu pour ce cycle.

Simulez le point de terminaison pendant que vous développez. C'est le point majeur pour une préversion restreinte. Le serveur de simulation d'Apidog renvoie des réponses réalistes basées sur le schéma de l'API, sans clé et sans limite de débit. Ainsi, votre frontend ou votre agent peut se développer en utilisant un point de terminaison Qwen de substitution qui répond toujours instantanément, même lorsque l'accès réel à la préversion est limité, en panne ou pas encore ouvert pour votre compte. Lorsque l'API en direct est prête, changez l'URL de base du simulateur à DashScope et votre code reste inchangé. Pour en savoir plus sur les workflows axés sur le schéma, consultez notre présentation du mode "spec-first".

Le modèle se généralise à toute API de modèle. Le même cycle de test et de simulation dans Apidog fonctionne que vous appeliez Qwen, Gemini ou l'API ERNIE 5.1 ; un modèle de préversion rend l'étape de simulation plus précieuse, car le véritable point de terminaison est la partie la moins fiable de votre pile.

Conclusion

Appeler Qwen 3.7 est simple une fois que vous connaissez le chemin. La difficulté réside dans la restriction de la préversion, pas dans l'API.

Arrêtez de deviner ce que Qwen renvoie et commencez à le voir. Téléchargez Apidog pour concevoir le point de terminaison Qwen, envoyer de véritables requêtes de test, enregistrer des scénarios réutilisables et simuler l'API pendant que vous développez. C'est gratuit pour commencer, et cela transforme une préversion instable en quelque chose sur lequel vous pouvez développer en toute confiance.