Chame o Qwen3.7 Plus com o SDK da OpenAI via modo compatível do DashScope

O Qwen3.7 Plus é barato o suficiente para ser testado a sério: em 23 de julho de 2026, a Qwen Cloud lista o qwen3.7-plus por $0.40 por 1M de tokens de entrada e $1.60 por 1M de tokens de saída até 256K tokens de entrada; depois, $1.20 para entrada e $4.80 para saída de 256K a 1M (preços da Qwen Cloud). Esse é o principal motivo pelo qual vale fazer este porte antes de reescrever qualquer coisa.

A parte útil é o formato da API. A Qwen Cloud documenta um endpoint de Chat Completions compatível com OpenAI em:

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

A própria página de migração diz que o código existente com o SDK da OpenAI pode migrar alterando base_url, api_key e model, e seus exemplos usam model="qwen3.7-plus" (compatibilidade da Qwen Cloud com OpenAI). Isso significa que a maioria dos apps de chat, scripts de avaliação, pequenos agentes e ferramentas internas pode ser portada em minutos. As partes que exigem cuidado são parâmetros de thinking, campos da OpenAI ignorados, preços de contexto longo e comportamento de cache.

1. Configure o cliente

Instale o SDK Python oficial da OpenAI:

python -m pip install --upgrade openai

Defina sua chave do DashScope:

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

Em seguida, faça a menor chamada possível para Chat Completions:

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

Execute:

python qwen_chat.py

O mesmo padrão funciona em Node. A página de migração rápida da Qwen Cloud também mostra baseURL: "https://dashscope-intl.aliyuncs.com/compatible-mode/v1" com model: "qwen3.7-plus" para o SDK JavaScript (compatibilidade da Qwen Cloud com OpenAI).

Se você mantém código que alterna entre provedores, deixe as configurações do provedor fora do ponto da chamada:

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

O próprio SDK da OpenAI oferece suporte a base_url, timeouts customizados, tentativas e acesso à resposta bruta; o README documenta retries automáticos para erros de conexão, 408, 409, 429 e erros de nível 500, além das opções max_retries e timeout (openai-python).

2. Porte os parâmetros, não apenas a URL

O caminho feliz é simples. As arestas aparecem nas diferenças de parâmetros.

A Qwen Cloud diz que a API de Chat Completions é em grande parte compatível com a Chat API da OpenAI, mas parâmetros específicos da Qwen precisam ser passados por extra_body no SDK Python (compatibilidade da Qwen Cloud com OpenAI). Isso importa para thinking, busca e alguns controles de amostragem.

Exemplo com thinking habilitado:

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)

O guia de thinking da Qwen diz que enable_thinking ativa o raciocínio para modelos híbridos, thinking_budget limita os tokens de thinking, e tokens de thinking são cobrados como tokens de saída (thinking da Qwen Cloud). Esse último ponto é o que os desenvolvedores deixam passar. Um modelo que pensa por 2.000 tokens antes de escrever uma resposta de 300 tokens não é uma chamada com saída de 300 tokens.

Também verifique campos da OpenAI sem suporte antes de portar código de produção. A Qwen Cloud diz que campos incluindo reasoning_effort, max_completion_tokens, metadata, store, verbosity, prompt_cache_key e vários outros são ignorados silenciosamente no modo compatível de Chat Completions (compatibilidade da Qwen Cloud com OpenAI). Se seu app OpenAI depende de algum desses campos para controle de custo ou comportamento do produto, substitua-o explicitamente.

3. Calcule o preço do contexto longo antes de enviá-lo

A mudança de faixa de preço do qwen3.7-plus é simples, mas tem impacto.

Tokens de entrada em uma solicitação	Preço de entrada / 1M	Preço de saída / 1M
≤ 256K	$0.40	$1.60
256K a 1M	$1.20	$4.80

Fonte: preços da Qwen Cloud.

A página do marketplace de modelos para o snapshot de 26 de maio lista qwen3.7-plus-2026-05-26 como um modelo de entrada de texto, imagem e vídeo com saída de texto, e o identifica como um snapshot de 26 de maio de 2026 (página do modelo na Qwen Cloud). O changelog da Qwen Cloud lista separadamente qwen3.7-plus e qwen3.7-plus-2026-05-26 em 1º de junho de 2026, descrevendo a série Plus como tendo capacidades visão-linguagem aprimoradas, mantendo fluxos de trabalho de codificação, uso de ferramentas e produtividade (lançamentos de modelos da Qwen Cloud).

Para código de produto, adicione um estimador de pré-validação. Você não precisa de uma tokenização perfeita para evitar que chamadas acidentais de 900K tokens caiam na faixa cara.

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

Essa segunda chamada não é apenas “um pouco mais de contexto”. Ela cruza o limite de uma faixa.

4. Use cache quando prefixos se repetirem

Cache de contexto é onde o Qwen pode ficar materialmente mais barato para prompts longos repetidos. A Qwen Cloud documenta três modos de cache: explícito, implícito e cache de sessão (cache de contexto da Qwen Cloud).

As regras de cobrança são concretas:

Modo de cache	Custo de criação	Custo de hit	Mínimo de tokens em cache
Cache explícito	125% da entrada padrão	10% da entrada padrão	1.024
Cache implícito	100% da entrada padrão	20% da entrada padrão	256
Cache de sessão	125% da entrada padrão	10% da entrada padrão	1.024

Para qwen3.7-plus na faixa ≤256K, isso corresponde a $0.08 por 1M de tokens de hit de cache implícito, $0.50 por 1M de tokens de criação de cache explícito e $0.04 por 1M de tokens de leitura de cache explícito na página do modelo (página do modelo na Qwen Cloud).

Use cache para prefixos estáveis: documentos de política, prompts de sistema longos, manuais de ferramentas, schemas ou resumos de repositórios. Não espere que ele salve prompts em que cada solicitação começa de forma diferente. A Qwen Cloud também afirma que descontos de Batch e cache não podem ser combinados na mesma solicitação (preços da Qwen Cloud).

5. Checklist de produção e uma opção de gateway

Antes de trocar o tráfego, teste estes casos:

1. Chat básico sem streaming.
2. Chat com streaming.
3. Modo thinking com extra_body.
4. Tool calling se seu app usa functions.
5. Saída JSON, lembrando que o modo compatível da Qwen oferece suporte a json_object, não ao json_schema da OpenAI.
6. Prompts longos perto de 256K tokens de entrada.
7. Chamadas com muitos hits de cache e prefixo repetido.
8. Comportamento de retries e timeout.

Para roteamento de fallback entre famílias de modelos, onehop é o caminho fácil. Altere uma base URL do SDK da OpenAI para https://api.onehop.ai/v1 e use um gateway para GPT, Claude, Gemini e outros modelos. A OneHop documenta endpoints compatíveis com OpenAI em https://api.onehop.ai/v1, compatíveis com Anthropic em https://api.onehop.ai/anthropic e compatíveis com Vertex/Gemini em https://api.onehop.ai/vertex-ai (docs da onehop). Ela também é posicionada como mais barata que os provedores primários, e novas contas ganham US$ 10 grátis sem precisar de cartão.

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)

Isso não substitui o trabalho específico para Qwen acima. Dá a você uma rota mais limpa quando seu app precisa de Claude para um fluxo, GPT para outro e Gemini para testes multimodais sem configurar três sistemas de cobrança e três configurações de SDK. Comece aqui para chamar Claude e outros modelos na onehop, ou cadastre-se para ganhar US$ 10 em crédito grátis.

6. O porte prático

O porte são três linhas até deixar de ser: base_url, api_key, model. Depois disso, o trabalho real é remover parâmetros da OpenAI ignorados, mover controles da Qwen para extra_body e colocar proteções rígidas em torno de contexto longo.

Use qwen3.7-plus quando quiser um modelo de custo equilibrado com contexto longo e suporte a entrada multimodal. Mantenha thinking desligado para extração e classificação simples. Ligue-o para revisão de código, orquestração de ferramentas ou raciocínio em várias etapas, com um thinking_budget para que os custos não saiam do controle. Faça cache de prefixos estáveis. Fique de olho no limite da faixa de 256K.

Para equipes que também precisam de Claude, GPT ou Gemini no mesmo produto, mantenha um caminho de gateway pronto: chame Claude e outros modelos na onehop, depois cadastre-se para ganhar US$ 10 em crédito grátis quando quiser rodar smoke tests reais sem adicionar um cartão.