Appeler Qwen3.7 Plus avec le SDK OpenAI via le mode compatible DashScope

Qwen3.7 Plus est suffisamment économique pour être testé sérieusement : au 23 juillet 2026, Qwen Cloud affiche qwen3.7-plus à $0.40 par million de tokens d’entrée et $1.60 par million de tokens de sortie jusqu’à 256K tokens d’entrée, puis $1.20 en entrée et $4.80 en sortie de 256K à 1M (tarifs Qwen Cloud). C’est la principale raison pour laquelle ce portage vaut la peine avant de réécrire quoi que ce soit.

La partie utile, c’est la forme de l’API. Qwen Cloud documente un endpoint Chat Completions compatible OpenAI à l’adresse :

https://dashscope-intl.aliyuncs.com/compatible-mode/v1

Sa propre page de migration indique que le code existant utilisant le SDK OpenAI peut basculer en modifiant base_url, api_key et model, et ses exemples utilisent model="qwen3.7-plus" (compatibilité OpenAI de Qwen Cloud). Cela signifie que la plupart des applications de chat, scripts d’évaluation, petits agents et outils internes peuvent être portés en quelques minutes. Les points à traiter avec soin sont les paramètres de raisonnement, les champs OpenAI ignorés, la tarification du contexte long et le comportement du cache.

1. Configurer le client

Installez le SDK Python OpenAI officiel :

python -m pip install --upgrade openai

Définissez votre clé DashScope :

export DASHSCOPE_API_KEY="sk-your-dashscope-key"

Puis effectuez l’appel Chat Completions le plus minimal possible :

# qwen_chat.py
import os
from openai import OpenAI

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

completion = client.chat.completions.create(
    model="qwen3.7-plus",
    messages=[
        {"role": "system", "content": "You are a concise senior Python engineer."},
        {"role": "user", "content": "Write a Python function that chunks a list into size-n batches."},
    ],
    temperature=0.2,
)

print(completion.choices[0].message.content)
print(completion.usage)

Exécutez-le :

python qwen_chat.py

Le même schéma fonctionne en Node. La page de migration rapide de Qwen Cloud montre aussi baseURL: "https://dashscope-intl.aliyuncs.com/compatible-mode/v1" avec model: "qwen3.7-plus" pour le SDK JavaScript (compatibilité OpenAI de Qwen Cloud).

Si vous maintenez du code qui bascule entre plusieurs fournisseurs, gardez les paramètres fournisseur en dehors du site d’appel :

PROVIDERS = {
    "qwen": {
        "api_key_env": "DASHSCOPE_API_KEY",
        "base_url": "https://dashscope-intl.aliyuncs.com/compatible-mode/v1",
        "model": "qwen3.7-plus",
    }
}

def make_client(provider_name: str) -> tuple[OpenAI, str]:
    cfg = PROVIDERS[provider_name]
    return (
        OpenAI(
            api_key=os.environ[cfg["api_key_env"]],
            base_url=cfg["base_url"],
        ),
        cfg["model"],
    )

Le SDK OpenAI lui-même prend en charge base_url, les timeouts personnalisés, les retries et l’accès aux réponses brutes ; son README documente les retries automatiques pour les erreurs de connexion, 408, 409, 429 et les erreurs de niveau 500, ainsi que les options max_retries et timeout (openai-python).

2. Porter les paramètres, pas seulement l’URL

Le chemin nominal est simple. Les aspérités viennent des différences de paramètres.

Qwen Cloud indique que l’API Chat Completions est largement compatible avec l’API Chat d’OpenAI, mais que les paramètres propres à Qwen doivent être transmis via extra_body dans le SDK Python (compatibilité OpenAI de Qwen Cloud). C’est important pour le raisonnement, la recherche et certains contrôles d’échantillonnage.

Exemple avec le raisonnement activé :

import os
from openai import OpenAI

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

stream = client.chat.completions.create(
    model="qwen3.7-plus",
    messages=[
        {"role": "user", "content": "Find the bug in this retry loop and explain the fix."}
    ],
    extra_body={
        "enable_thinking": True,
        "thinking_budget": 500,
    },
    stream=True,
)

for chunk in stream:
    if not chunk.choices:
        continue

    delta = chunk.choices[0].delta

    if getattr(delta, "reasoning_content", None):
        print(delta.reasoning_content, end="", flush=True)

    if getattr(delta, "content", None):
        print(delta.content, end="", flush=True)

Le guide de raisonnement de Qwen indique que enable_thinking active le raisonnement pour les modèles hybrides, que thinking_budget plafonne les tokens de raisonnement, et que les tokens de raisonnement sont facturés comme des tokens de sortie (raisonnement Qwen Cloud). Ce dernier point est celui que les développeurs oublient. Un modèle qui raisonne pendant 2 000 tokens avant d’écrire une réponse de 300 tokens ne correspond pas à un appel avec 300 tokens de sortie.

Vérifiez également les champs OpenAI non pris en charge avant de porter du code de production. Qwen Cloud indique que des champs comme reasoning_effort, max_completion_tokens, metadata, store, verbosity, prompt_cache_key et plusieurs autres sont ignorés silencieusement en mode compatible Chat Completions (compatibilité OpenAI de Qwen Cloud). Si votre application OpenAI dépend de l’un de ces champs pour contrôler les coûts ou le comportement produit, remplacez-le explicitement.

3. Évaluez le coût du contexte long avant de l’envoyer

Le palier tarifaire de qwen3.7-plus est simple, mais il a des conséquences.

Tokens d’entrée dans une requête	Prix entrée / 1M	Prix sortie / 1M
≤ 256K	$0.40	$1.60
256K à 1M	$1.20	$4.80

Source : tarifs Qwen Cloud.

La page marketplace du modèle pour le snapshot du 26 mai répertorie qwen3.7-plus-2026-05-26 comme un modèle acceptant du texte, des images et de la vidéo en entrée, avec sortie texte, et l’identifie comme un snapshot du 26 mai 2026 (page modèle Qwen Cloud). Le changelog de Qwen Cloud liste séparément qwen3.7-plus et qwen3.7-plus-2026-05-26 sous le 1er juin 2026, en décrivant la série Plus comme ajoutant des capacités vision-langage améliorées tout en conservant les workflows de code, d’utilisation d’outils et de productivité (versions de modèles Qwen Cloud).

Pour du code produit, ajoutez un estimateur préalable. Vous n’avez pas besoin d’une tokenisation parfaite pour empêcher que des appels accidentels à 900K tokens atterrissent dans le palier coûteux.

def estimate_qwen37_plus_cost(input_tokens: int, output_tokens: int) -> float:
    if input_tokens <= 256_000:
        input_per_m = 0.40
        output_per_m = 1.60
    else:
        input_per_m = 1.20
        output_per_m = 4.80

    return (input_tokens / 1_000_000 * input_per_m) + (
        output_tokens / 1_000_000 * output_per_m
    )

print(estimate_qwen37_plus_cost(180_000, 4_000))  # 0.0784
print(estimate_qwen37_plus_cost(400_000, 4_000))  # 0.4992

Ce deuxième appel n’est pas juste « un peu plus de contexte ». Il franchit une limite de palier.

4. Utiliser le cache quand les préfixes se répètent

La mise en cache du contexte est l’endroit où Qwen peut devenir nettement moins cher pour les prompts longs répétés. Qwen Cloud documente trois modes de cache : explicite, implicite et cache de session (cache de contexte Qwen Cloud).

Les règles de facturation sont concrètes :

Mode de cache	Coût de création	Coût en cas de hit	Minimum de tokens mis en cache
Cache explicite	125% de l’entrée standard	10% de l’entrée standard	1 024
Cache implicite	100% de l’entrée standard	20% de l’entrée standard	256
Cache de session	125% de l’entrée standard	10% de l’entrée standard	1 024

Pour qwen3.7-plus au palier ≤256K, cela correspond à $0.08 par million de tokens en hit de cache implicite, $0.50 par million de tokens de création de cache explicite, et $0.04 par million de tokens lus depuis le cache explicite sur la page du modèle (page modèle Qwen Cloud).

Utilisez le cache pour les préfixes stables : documents de politique, longs prompts système, manuels d’outils, schémas ou résumés de repo. Ne vous attendez pas à ce qu’il sauve des prompts où chaque requête commence différemment. Qwen Cloud précise également que les remises Batch et cache ne peuvent pas être combinées sur la même requête (tarifs Qwen Cloud).

5. Checklist de production et option passerelle

Avant de basculer le trafic, testez ces cas :

1. Chat non-streaming basique.
2. Chat en streaming.
3. Mode raisonnement avec extra_body.
4. Appel d’outils si votre application utilise des fonctions.
5. Sortie JSON, en gardant à l’esprit que le mode compatible Qwen prend en charge json_object, pas le json_schema d’OpenAI.
6. Prompts longs proches de 256K tokens d’entrée.
7. Appels à préfixe répété exploitant fortement le cache.
8. Comportement des retries et des timeouts.

Pour le routage de secours entre familles de modèles, onehop est la voie la plus simple. Remplacez une seule URL de base du SDK OpenAI par https://api.onehop.ai/v1 et utilisez une seule passerelle pour GPT, Claude, Gemini et d’autres modèles. OneHop documente des endpoints compatibles OpenAI https://api.onehop.ai/v1, compatibles Anthropic https://api.onehop.ai/anthropic et compatibles Vertex/Gemini https://api.onehop.ai/vertex-ai (docs onehop). Il est également présenté comme moins cher que les fournisseurs directs, et les nouveaux comptes reçoivent 10 $ gratuits sans carte requise.

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["ONEHOP_API_KEY"],
    base_url="https://api.onehop.ai/v1",
)

response = client.chat.completions.create(
    model="openai/gpt-5.5",
    messages=[{"role": "user", "content": "Summarize this incident report in 5 bullets."}],
)

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

Cela ne remplace pas le travail spécifique à Qwen décrit ci-dessus. Cela vous donne une route plus propre quand votre application a besoin de Claude pour un workflow, de GPT pour un autre, et de Gemini pour des tests multimodaux, sans câbler trois systèmes de facturation et trois configurations de SDK. Commencez ici pour appeler Claude et d’autres modèles sur onehop, ou inscrivez-vous pour obtenir 10 $ de crédit gratuit.

6. Le portage pratique

Le portage tient en trois lignes jusqu’à ce que ce ne soit plus le cas : base_url, api_key, model. Ensuite, le vrai travail consiste à supprimer les paramètres OpenAI ignorés, à déplacer les contrôles Qwen dans extra_body, et à mettre des garde-fous stricts autour du contexte long.

Utilisez qwen3.7-plus lorsque vous voulez un modèle de coût équilibré avec contexte long et prise en charge d’entrées multimodales. Laissez le raisonnement désactivé pour les tâches simples d’extraction et de classification. Activez-le pour la revue de code, l’orchestration d’outils ou le raisonnement en plusieurs étapes, avec un thinking_budget afin que les coûts ne dérivent pas. Mettez en cache les préfixes stables. Surveillez la limite du palier 256K.

Pour les équipes qui ont aussi besoin de Claude, GPT ou Gemini dans le même produit, gardez un chemin passerelle prêt : appelez Claude et d’autres modèles sur onehop, puis inscrivez-vous pour obtenir 10 $ de crédit gratuit lorsque vous voulez lancer de vrais smoke tests sans ajouter de carte.