Llama a Qwen3.7 Plus con el SDK de OpenAI mediante el modo compatible de DashScope

Qwen3.7 Plus es lo bastante barato como para probarlo en serio: a 23 de julio de 2026, Qwen Cloud lista qwen3.7-plus a $0.40 por 1M de tokens de entrada y $1.60 por 1M de tokens de salida hasta 256K tokens de entrada; después, $1.20 de entrada y $4.80 de salida de 256K a 1M (precios de Qwen Cloud). Esa es la razón principal por la que merece la pena hacer esta migración antes de reescribir nada.

La parte útil es la forma de la API. Qwen Cloud documenta un endpoint de Chat Completions compatible con OpenAI en:

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

Su propia página de migración dice que el código existente del SDK de OpenAI puede cambiarse modificando base_url, api_key y model, y sus ejemplos usan model="qwen3.7-plus" (compatibilidad de Qwen Cloud con OpenAI). Eso significa que la mayoría de apps de chat, scripts de evaluación, agentes pequeños y herramientas internas pueden migrarse en minutos. Las partes que requieren cuidado son los parámetros de thinking, los campos de OpenAI ignorados, los precios de contexto largo y el comportamiento de la caché.

1. Configura el cliente

Instala el SDK oficial de OpenAI para Python:

python -m pip install --upgrade openai

Configura tu clave de DashScope:

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

Luego haz la llamada de Chat Completions más pequeña posible:

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

Ejecútalo:

python qwen_chat.py

El mismo patrón funciona en Node. La página de migración rápida de Qwen Cloud muestra baseURL: "https://dashscope-intl.aliyuncs.com/compatible-mode/v1" con model: "qwen3.7-plus" también para el SDK de JavaScript (compatibilidad de Qwen Cloud con OpenAI).

Si mantienes código que cambia entre proveedores, deja la configuración del proveedor fuera del punto de llamada:

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

El propio SDK de OpenAI admite base_url, timeouts personalizados, reintentos y acceso a la respuesta sin procesar; su README documenta reintentos automáticos para errores de conexión, 408, 409, 429 y errores de nivel 500, además de las opciones max_retries y timeout (openai-python).

2. Migra los parámetros, no solo la URL

El caso ideal es sencillo. Las aristas están en las diferencias de parámetros.

Qwen Cloud dice que la API de Chat Completions es ampliamente compatible con la Chat API de OpenAI, pero los parámetros específicos de Qwen deben pasarse mediante extra_body en el SDK de Python (compatibilidad de Qwen Cloud con OpenAI). Eso importa para thinking, búsqueda y algunos controles de muestreo.

Ejemplo con thinking activado:

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 guía de thinking de Qwen dice que enable_thinking activa el razonamiento en modelos híbridos, thinking_budget limita los tokens de thinking y los tokens de thinking se facturan como tokens de salida (thinking de Qwen Cloud). Ese último punto es el que se les escapa a muchos desarrolladores. Un modelo que piensa durante 2,000 tokens antes de escribir una respuesta de 300 tokens no es una llamada de salida de 300 tokens.

Comprueba también los campos de OpenAI no compatibles antes de migrar código de producción. Qwen Cloud dice que campos como reasoning_effort, max_completion_tokens, metadata, store, verbosity, prompt_cache_key y varios más se ignoran silenciosamente en el modo compatible de Chat Completions (compatibilidad de Qwen Cloud con OpenAI). Si tu app de OpenAI depende de uno de esos campos para controlar costes o comportamiento de producto, reemplázalo explícitamente.

3. Calcula el precio del contexto largo antes de enviarlo

El salto de precio de qwen3.7-plus es sencillo, pero tiene consecuencias.

Tokens de entrada en una solicitud	Precio de entrada / 1M	Precio de salida / 1M
≤ 256K	$0.40	$1.60
256K a 1M	$1.20	$4.80

Fuente: precios de Qwen Cloud.

La página del marketplace de modelos para la snapshot del 26 de mayo lista qwen3.7-plus-2026-05-26 como un modelo con entrada de texto, imagen y vídeo, salida de texto, y lo identifica como una snapshot del 26 de mayo de 2026 (página del modelo en Qwen Cloud). El changelog de Qwen Cloud lista por separado qwen3.7-plus y qwen3.7-plus-2026-05-26 bajo el 1 de junio de 2026, y describe la serie Plus como una incorporación de capacidades visión-lenguaje mejoradas sin perder los flujos de trabajo de coding, uso de herramientas y productividad (lanzamientos de modelos de Qwen Cloud).

Para código de producto, añade un estimador previo. No necesitas una tokenización perfecta para evitar que llamadas accidentales de 900K tokens caigan en el tramo caro.

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

Esa segunda llamada no es simplemente “un poco más de contexto”. Cruza un límite de tramo.

4. Usa caché cuando los prefijos se repitan

La caché de contexto es donde Qwen puede abaratarse de forma material para prompts largos repetidos. Qwen Cloud documenta tres modos de caché: explícita, implícita y de sesión (caché de contexto de Qwen Cloud).

Las reglas de facturación son concretas:

Modo de caché	Coste de creación	Coste de acierto	Tokens mínimos en caché
Caché explícita	125% de la entrada estándar	10% de la entrada estándar	1,024
Caché implícita	100% de la entrada estándar	20% de la entrada estándar	256
Caché de sesión	125% de la entrada estándar	10% de la entrada estándar	1,024

Para qwen3.7-plus en el tramo ≤256K, eso equivale a $0.08 por 1M de tokens con acierto de caché implícita, $0.50 por 1M de tokens de creación de caché explícita y $0.04 por 1M de tokens de lectura de caché explícita en la página del modelo (página del modelo en Qwen Cloud).

Usa caché para prefijos estables: documentos de políticas, prompts de sistema largos, manuales de herramientas, esquemas o resúmenes de repos. No esperes que rescate prompts en los que cada solicitud empieza de forma distinta. Qwen Cloud también indica que los descuentos de Batch y caché no se pueden combinar en la misma solicitud (precios de Qwen Cloud).

5. Checklist de producción y una opción de gateway

Antes de cambiar el tráfico, prueba estos casos:

1. Chat básico sin streaming.
2. Chat con streaming.
3. Modo thinking con extra_body.
4. Tool calling si tu app usa funciones.
5. Salida JSON, recordando que el modo compatible de Qwen admite json_object, no json_schema de OpenAI.
6. Prompts largos cerca de 256K tokens de entrada.
7. Llamadas con prefijos repetidos y mucho uso de caché.
8. Comportamiento de reintentos y timeouts.

Para enrutamiento con fallback entre familias de modelos, onehop es el camino sencillo. Cambia una sola URL base del SDK de OpenAI a https://api.onehop.ai/v1 y usa un único gateway para GPT, Claude, Gemini y otros modelos. OneHop documenta endpoints compatibles con OpenAI https://api.onehop.ai/v1, compatibles con Anthropic https://api.onehop.ai/anthropic y compatibles con Vertex/Gemini https://api.onehop.ai/vertex-ai (documentación de onehop). También se posiciona como más barato que los proveedores directos, y las cuentas nuevas reciben $10 gratis sin tarjeta.

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)

Eso no sustituye el trabajo específico de Qwen descrito arriba. Te da una ruta más limpia cuando tu app necesita Claude para un flujo, GPT para otro y Gemini para pruebas multimodales sin cablear tres sistemas de facturación y tres configuraciones de SDK. Empieza aquí para llamar a Claude y otros modelos en onehop, o regístrate para obtener $10 de crédito gratis.

6. La migración práctica

La migración son tres líneas hasta que deja de serlo: base_url, api_key, model. Después, el trabajo real es eliminar parámetros de OpenAI ignorados, mover controles de Qwen a extra_body y poner límites estrictos alrededor del contexto largo.

Usa qwen3.7-plus cuando quieras un modelo de coste equilibrado con contexto largo y soporte de entrada multimodal. Mantén thinking desactivado para extracción y clasificación simples. Actívalo para revisión de código, orquestación de herramientas o razonamiento de varios pasos, con un thinking_budget para que los costes no se desvíen. Cachea prefijos estables. Vigila el límite del tramo de 256K.

Para equipos que también necesitan Claude, GPT o Gemini en el mismo producto, mantén preparada una ruta de gateway: llama a Claude y otros modelos en onehop, y luego regístrate para obtener $10 de crédito gratis cuando quieras ejecutar pruebas de humo reales sin añadir una tarjeta.