Chiamare Qwen3.7 Plus con l’OpenAI SDK tramite la modalità compatibile DashScope

Qwen3.7 Plus è abbastanza economico da poter essere testato seriamente: al 23 luglio 2026, Qwen Cloud indica qwen3.7-plus a $0.40 per 1M di token di input e $1.60 per 1M di token di output fino a 256K token di input, poi $1.20 input e $4.80 output da 256K a 1M (prezzi Qwen Cloud). Questo è il motivo principale per cui vale la pena fare questo porting prima di riscrivere qualsiasi cosa.

La parte utile è la forma dell’API. Qwen Cloud documenta un endpoint Chat Completions compatibile con OpenAI a:

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

La sua pagina di migrazione dice che il codice esistente basato su OpenAI SDK può passare modificando base_url, api_key e model, e i suoi esempi usano model="qwen3.7-plus" (compatibilità OpenAI di Qwen Cloud). Questo significa che la maggior parte delle app chat, degli script di eval, dei piccoli agenti e degli strumenti interni può essere migrata in pochi minuti. Le parti che richiedono attenzione sono i parametri di thinking, i campi OpenAI ignorati, i prezzi del long context e il comportamento della cache.

1. Configurare il client

Installa l’SDK Python ufficiale di OpenAI:

python -m pip install --upgrade openai

Imposta la tua chiave DashScope:

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

Poi esegui la chiamata Chat Completions più piccola possibile:

# 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)

Eseguilo:

python qwen_chat.py

Lo stesso pattern funziona in Node. La pagina di migrazione rapida di Qwen Cloud mostra baseURL: "https://dashscope-intl.aliyuncs.com/compatible-mode/v1" con model: "qwen3.7-plus" anche per l’SDK JavaScript (compatibilità OpenAI di Qwen Cloud).

Se mantieni codice che passa da un provider all’altro, tieni le impostazioni del provider fuori dal punto di chiamata:

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"],
    )

L’OpenAI SDK stesso supporta base_url, timeout personalizzati, retry e accesso alla risposta raw; il suo README documenta retry automatici per errori di connessione, 408, 409, 429 ed errori di livello 500, oltre alle opzioni max_retries e timeout (openai-python).

2. Migrare i parametri, non solo l’URL

Il percorso felice è semplice. Gli spigoli sono nelle differenze tra parametri.

Qwen Cloud afferma che l’API Chat Completions è in gran parte compatibile con la Chat API di OpenAI, ma i parametri specifici di Qwen devono essere passati tramite extra_body nell’SDK Python (compatibilità OpenAI di Qwen Cloud). Questo è importante per thinking, search e alcuni controlli di sampling.

Esempio con thinking abilitato:

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)

La guida al thinking di Qwen dice che enable_thinking attiva il ragionamento per i modelli ibridi, thinking_budget limita i token di thinking, e i token di thinking vengono fatturati come token di output (thinking di Qwen Cloud). Quest’ultimo punto è quello che gli sviluppatori si perdono. Un modello che pensa per 2.000 token prima di scrivere una risposta da 300 token non è una chiamata con output da 300 token.

Controlla anche i campi OpenAI non supportati prima di migrare codice di produzione. Qwen Cloud dice che campi tra cui reasoning_effort, max_completion_tokens, metadata, store, verbosity, prompt_cache_key e diversi altri vengono ignorati silenziosamente nella modalità compatibile Chat Completions (compatibilità OpenAI di Qwen Cloud). Se la tua app OpenAI dipende da uno di questi campi per il controllo dei costi o per il comportamento del prodotto, sostituiscilo esplicitamente.

3. Stimare il costo del long context prima di inviarlo

Lo scaglione di prezzo di qwen3.7-plus è semplice, ma ha conseguenze concrete.

Token di input in una richiesta	Prezzo input / 1M	Prezzo output / 1M
≤ 256K	$0.40	$1.60
Da 256K a 1M	$1.20	$4.80

Fonte: prezzi Qwen Cloud.

La pagina del marketplace dei modelli per lo snapshot del 26 maggio elenca qwen3.7-plus-2026-05-26 come modello con input testuale, immagini e video e output testuale, e lo identifica come snapshot del 26 maggio 2026 (pagina modello Qwen Cloud). Il changelog di Qwen Cloud elenca separatamente qwen3.7-plus e qwen3.7-plus-2026-05-26 sotto il 1 giugno 2026, descrivendo la serie Plus come dotata di capacità vision-language aggiornate pur mantenendo coding, uso di tool e workflow di produttività (release dei modelli Qwen Cloud).

Per il codice di prodotto, aggiungi uno stimatore preflight. Non serve una tokenizzazione perfetta per evitare che chiamate accidentali da 900K token finiscano nello scaglione costoso.

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

Quella seconda chiamata non è solo “un po’ più di contesto”. Supera il confine di uno scaglione.

4. Usare la cache quando i prefissi si ripetono

Il context caching è dove Qwen può diventare materialmente più economico per prompt lunghi ripetuti. Qwen Cloud documenta tre modalità di cache: esplicita, implicita e session cache (context cache di Qwen Cloud).

Le regole di fatturazione sono concrete:

Modalità cache	Costo di creazione	Costo hit	Token minimi in cache
Cache esplicita	125% dell’input standard	10% dell’input standard	1,024
Cache implicita	100% dell’input standard	20% dell’input standard	256
Session cache	125% dell’input standard	10% dell’input standard	1,024

Per qwen3.7-plus nello scaglione ≤256K, questo corrisponde a $0.08 per 1M di token con hit di cache implicita, $0.50 per 1M di token di creazione cache esplicita e $0.04 per 1M di token di lettura da cache esplicita sulla pagina del modello (pagina modello Qwen Cloud).

Usa la cache per prefissi stabili: documenti di policy, lunghi system prompt, manuali di tool, schemi o riassunti di repo. Non aspettarti che salvi prompt in cui ogni richiesta inizia in modo diverso. Qwen Cloud afferma inoltre che gli sconti Batch e cache non possono essere combinati sulla stessa richiesta (prezzi Qwen Cloud).

5. Checklist per la produzione e un’opzione gateway

Prima di spostare traffico, testa questi casi:

1. Chat base non in streaming.
2. Chat in streaming.
3. Modalità thinking con extra_body.
4. Tool calling se la tua app usa funzioni.
5. Output JSON, ricordando che la modalità compatibile Qwen supporta json_object, non json_schema di OpenAI.
6. Prompt lunghi vicini a 256K token di input.
7. Chiamate con prefisso ripetuto e forte uso della cache.
8. Comportamento di retry e timeout.

Per il fallback routing tra famiglie di modelli, onehop è la strada più semplice. Cambia un solo base URL dell’OpenAI SDK in https://api.onehop.ai/v1 e usa un gateway unico per GPT, Claude, Gemini e altri modelli. OneHop documenta gli endpoint compatibili OpenAI https://api.onehop.ai/v1, compatibili Anthropic https://api.onehop.ai/anthropic e compatibili Vertex/Gemini https://api.onehop.ai/vertex-ai (documentazione onehop). È anche posizionato come più economico rispetto ai provider first-party, e i nuovi account ricevono $10 gratis senza carta richiesta.

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)

Questo non sostituisce il lavoro specifico per Qwen descritto sopra. Ti offre una rotta più pulita quando la tua app ha bisogno di Claude per un workflow, GPT per un altro e Gemini per test multimodali, senza collegare tre sistemi di fatturazione e tre configurazioni SDK. Inizia da qui per chiamare Claude e altri modelli su onehop, oppure registrati per $10 di credito gratuito.

6. Il porting pratico

Il porting è di tre righe finché non lo è più: base_url, api_key, model. Dopo, il vero lavoro è rimuovere i parametri OpenAI ignorati, spostare i controlli Qwen in extra_body e mettere guardrail rigidi intorno al long context.

Usa qwen3.7-plus quando vuoi un modello di costo bilanciato con long context e supporto a input multimodali. Tieni il thinking disattivato per estrazione e classificazione semplici. Attivalo per code review, orchestrazione di tool o ragionamento multi-step, con un thinking_budget in modo che i costi non vadano fuori controllo. Metti in cache i prefissi stabili. Tieni d’occhio il confine dello scaglione a 256K.

Per i team che hanno bisogno anche di Claude, GPT o Gemini nello stesso prodotto, tieni pronto un percorso gateway: chiama Claude e altri modelli su onehop, poi registrati per $10 di credito gratuito quando vuoi eseguire veri smoke test senza aggiungere una carta.