Qwen3.7 Plus mit dem OpenAI SDK über den DashScope-kompatiblen Modus aufrufen

Qwen3.7 Plus ist günstig genug, um ernsthaft getestet zu werden: Stand 23. Juli 2026 listet Qwen Cloud qwen3.7-plus mit $0.40 pro 1 Mio. Input-Token und $1.60 pro 1 Mio. Output-Token bis zu 256K Input-Token, danach mit $1.20 Input und $4.80 Output von 256K bis 1M (Qwen-Cloud-Preise). Das ist der Hauptgrund, warum sich diese Portierung lohnt, bevor du irgendetwas neu schreibst.

Der nützliche Teil ist die API-Form. Qwen Cloud dokumentiert einen OpenAI-kompatiblen Chat-Completions-Endpunkt unter:

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

Die eigene Migrationsseite sagt, dass bestehender OpenAI-SDK-Code durch Ändern von base_url, api_key und model umgestellt werden kann; die Beispiele verwenden model="qwen3.7-plus" (OpenAI-Kompatibilität von Qwen Cloud). Das heißt: Die meisten Chat-Apps, Eval-Skripte, kleinen Agents und internen Tools lassen sich in Minuten portieren. Sorgfalt erfordern vor allem Thinking-Parameter, ignorierte OpenAI-Felder, Long-Context-Preise und Cache-Verhalten.

1. Den Client einrichten

Installiere das offizielle OpenAI Python SDK:

python -m pip install --upgrade openai

Setze deinen DashScope-Key:

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

Dann führe den kleinstmöglichen Chat-Completions-Aufruf aus:

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

Ausführen:

python qwen_chat.py

Dasselbe Muster funktioniert in Node. Die Quick-Migration-Seite von Qwen Cloud zeigt auch für das JavaScript SDK baseURL: "https://dashscope-intl.aliyuncs.com/compatible-mode/v1" mit model: "qwen3.7-plus" (OpenAI-Kompatibilität von Qwen Cloud).

Wenn du Code pflegst, der zwischen Providern wechselt, halte die Provider-Einstellungen außerhalb der Aufrufstelle:

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

Das OpenAI SDK selbst unterstützt base_url, benutzerdefinierte Timeouts, Retries und Zugriff auf Raw Responses; das README dokumentiert automatische Retries bei Verbindungsfehlern, 408, 409, 429 und 500er-Fehlern sowie die Optionen max_retries und timeout (openai-python).

2. Portiere die Parameter, nicht nur die URL

Der Happy Path ist einfach. Die rauen Kanten liegen in den Parameterunterschieden.

Qwen Cloud sagt, dass die Chat Completions API weitgehend mit OpenAIs Chat API kompatibel ist, Qwen-spezifische Parameter im Python SDK aber über extra_body übergeben werden müssen (OpenAI-Kompatibilität von Qwen Cloud). Das ist relevant für Thinking, Search und einige Sampling-Steuerungen.

Beispiel mit aktiviertem Thinking:

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)

Qwens Thinking-Leitfaden sagt, dass enable_thinking Reasoning für Hybridmodelle aktiviert, thinking_budget die Thinking-Token begrenzt und Thinking-Token als Output-Token abgerechnet werden (Qwen Cloud Thinking). Der letzte Punkt wird von Entwicklern oft übersehen. Ein Modell, das 2.000 Token lang nachdenkt, bevor es eine Antwort mit 300 Token schreibt, ist kein Output-Aufruf mit 300 Token.

Prüfe außerdem nicht unterstützte OpenAI-Felder, bevor du Produktionscode portierst. Qwen Cloud sagt, dass Felder wie reasoning_effort, max_completion_tokens, metadata, store, verbosity, prompt_cache_key und mehrere andere im kompatiblen Chat-Completions-Modus stillschweigend ignoriert werden (OpenAI-Kompatibilität von Qwen Cloud). Wenn deine OpenAI-App für Kostenkontrolle oder Produktverhalten von einem dieser Felder abhängt, ersetze es explizit.

3. Kalkuliere den Long Context, bevor du ihn sendest

Die Preisstaffel von qwen3.7-plus ist einfach, hat es aber in sich.

Input-Token in einer Anfrage	Input-Preis / 1M	Output-Preis / 1M
≤ 256K	$0.40	$1.60
256K bis 1M	$1.20	$4.80

Quelle: Qwen-Cloud-Preise.

Die Model-Marketplace-Seite für den Snapshot vom 26. Mai listet qwen3.7-plus-2026-05-26 als Modell mit Text-, Bild- und Video-Input sowie Text-Output und identifiziert ihn als Snapshot vom 26. Mai 2026 (Qwen-Cloud-Modellseite). Das Qwen-Cloud-Changelog listet qwen3.7-plus und qwen3.7-plus-2026-05-26 separat unter dem 1. Juni 2026 und beschreibt die Plus-Serie als Erweiterung um verbesserte Vision-Language-Fähigkeiten bei gleichzeitiger Beibehaltung von Coding-, Tool-Use- und Produktivitäts-Workflows (Qwen-Cloud-Modell-Releases).

Für Produktcode solltest du einen Preflight-Schätzer hinzufügen. Du brauchst keine perfekte Tokenisierung, um zu verhindern, dass versehentliche 900K-Token-Aufrufe in der teuren Stufe landen.

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

Dieser zweite Aufruf ist nicht einfach nur „etwas mehr Kontext“. Er überschreitet eine Preisstufengrenze.

4. Nutze Cache, wenn sich Präfixe wiederholen

Context Caching ist der Punkt, an dem Qwen bei wiederholten langen Prompts deutlich günstiger werden kann. Qwen Cloud dokumentiert drei Cache-Modi: explizit, implizit und Session Cache (Qwen Cloud Context Cache).

Die Abrechnungsregeln sind konkret:

Cache-Modus	Erstellungskosten	Hit-Kosten	Mindestanzahl gecachter Token
Expliziter Cache	125% des Standard-Inputs	10% des Standard-Inputs	1,024
Impliziter Cache	100% des Standard-Inputs	20% des Standard-Inputs	256
Session Cache	125% des Standard-Inputs	10% des Standard-Inputs	1,024

Für qwen3.7-plus in der ≤256K-Stufe entspricht das laut Modellseite $0.08 pro 1M impliziter Cache-Hit-Token, $0.50 pro 1M expliziter Cache-Erstellungstoken und $0.04 pro 1M expliziter Cache-Lesetoken (Qwen-Cloud-Modellseite).

Nutze Cache für stabile Präfixe: Policy-Dokumente, lange System-Prompts, Tool-Handbücher, Schemas oder Repo-Zusammenfassungen. Erwarte nicht, dass er Prompts rettet, bei denen jede Anfrage anders beginnt. Qwen Cloud gibt außerdem an, dass Batch- und Cache-Rabatte nicht in derselben Anfrage kombiniert werden können (Qwen-Cloud-Preise).

5. Produktions-Checkliste und eine Gateway-Option

Bevor du Traffic umschaltest, teste diese Fälle:

1. Einfacher nicht-streamender Chat.
2. Streaming-Chat.
3. Thinking-Modus mit extra_body.
4. Tool Calling, falls deine App Functions verwendet.
5. JSON-Output; denk daran, dass der Qwen-kompatible Modus json_object unterstützt, nicht OpenAIs json_schema.
6. Lange Prompts nahe 256K Input-Token.
7. Cache-intensive Aufrufe mit wiederholtem Präfix.
8. Retry- und Timeout-Verhalten.

Für Fallback-Routing über Modellfamilien hinweg ist onehop der einfache Weg. Ändere eine OpenAI-SDK-Base-URL zu https://api.onehop.ai/v1 und nutze ein Gateway für GPT, Claude, Gemini und andere Modelle. OneHop dokumentiert OpenAI-kompatible https://api.onehop.ai/v1-, Anthropic-kompatible https://api.onehop.ai/anthropic- und Vertex/Gemini-kompatible https://api.onehop.ai/vertex-ai-Endpunkte (onehop-Dokumentation). Außerdem wird es als günstiger als First-Party-Angebote positioniert, und neue Accounts erhalten $10 gratis ohne erforderliche Karte.

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)

Das ersetzt nicht die Qwen-spezifische Arbeit oben. Es gibt dir eine sauberere Route, wenn deine App Claude für einen Workflow, GPT für einen anderen und Gemini für multimodale Tests benötigt, ohne drei Abrechnungssysteme und drei SDK-Konfigurationen zu verdrahten. Starte hier, um Claude und andere Modelle über onehop aufzurufen, oder registriere dich für $10 Gratisguthaben.

6. Die praktische Portierung

Die Portierung besteht aus drei Zeilen, bis sie es nicht mehr tut: base_url, api_key, model. Danach liegt die eigentliche Arbeit darin, ignorierte OpenAI-Parameter zu entfernen, Qwen-Steuerungen nach extra_body zu verschieben und harte Schutzmechanismen um Long Context zu setzen.

Verwende qwen3.7-plus, wenn du ein ausgewogenes Kostenmodell mit Long Context und Unterstützung für multimodalen Input willst. Lass Thinking für einfache Extraktion und Klassifikation ausgeschaltet. Aktiviere es für Code-Review, Tool-Orchestrierung oder mehrstufiges Reasoning, mit einem thinking_budget, damit Kosten nicht aus dem Ruder laufen. Cache stabile Präfixe. Behalte die 256K-Stufengrenze im Blick.

Für Teams, die im selben Produkt auch Claude, GPT oder Gemini benötigen, halte einen Gateway-Pfad bereit: Claude und andere Modelle über onehop aufrufen, und dann für $10 Gratisguthaben registrieren, wenn du echte Smoke Tests ausführen willst, ohne eine Karte hinzuzufügen.