Qwen API: Pricing, Base URL, Model IDs, and Self-Hosting (2026)

TL;DR

The Qwen API is the hosted interface to Alibaba's Qwen models, served by Alibaba Cloud Model Studio (formerly DashScope). It is OpenAI-compatible: point the OpenAI SDK at a Model Studio base URL, pass a key from DASHSCOPE_API_KEY, and set a model ID such as qwen3.8-max or qwen3.7-plus. Pricing is per million tokens, and every proprietary model starts with 1M free tokens for 90 days.

Current as of September 7, 2026. Rates were read from Alibaba Cloud Model Studio's Singapore pricing page, and the third-party rows were re-read on that date. Alibaba reprices and renames models quarterly; check the console before committing volume.

The Qwen API is Alibaba Cloud Model Studio, the platform formerly called DashScope. It has three surfaces: an OpenAI-compatible Chat Completions endpoint, an Anthropic-compatible Messages endpoint for Claude Code, and the DashScope native API. The flagship is qwen3.8-max at $2/$6 per million tokens with a 1M context. The price-performance tier is qwen3.7-plus at $0.40/$1.60. The cheap tier is qwen3.8-flash at $0.15/$0.47. Every proprietary model comes with 1M free tokens for 90 days.

Where to Get a Qwen API Key

Five steps, start to first call. The order matters: Model Studio has to be activated on the account before the API Key page will issue anything.

1. Create an Alibaba Cloud account at account.alibabacloud.com/register/intl_register.htm if you do not have one.
2. Open modelstudio.console.alibabacloud.com. A Terms of Service dialog appears on first visit; accepting it activates Model Studio. Until you accept, there is no key to create.
3. Pick your region from the selector in the console header. Keys are region-scoped: a Singapore key does not authenticate against the Beijing endpoint, and each region carries its own model catalog.
4. Go to the API Key page (?tab=playground#/api-key in the console) and click Create API key. The key looks like sk-ee166797fe40xxx, and the plaintext is shown once.
5. Export it as DASHSCOPE_API_KEY, which is the variable every Alibaba SDK and most third-party integrations read by default.

export DASHSCOPE_API_KEY="sk-..."   # macOS / Linux
# Windows PowerShell: $env:DASHSCOPE_API_KEY = "sk-..."
# Windows cmd:        set DASHSCOPE_API_KEY=sk-...

curl "https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/compatible-mode/v1/chat/completions" \
  -H "Authorization: Bearer $DASHSCOPE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model":"qwen3.7-plus","messages":[{"role":"user","content":"ping"}]}'

Replace {WorkspaceId} with the workspace ID from the console. Older tutorials use dashscope-intl.aliyuncs.com/compatible-mode/v1; Alibaba now recommends the workspace-specific domains and describes the old hostnames as legacy. Source: Model Studio OpenAI-compatibility and first-call docs, September 2026.

The legacy hostname is worth avoiding for a second reason. Qwen Code 0.13.0 through 0.15.10 fails against dashscope-intl.aliyuncs.com with API Error: Connection error. (cause: fetch failed) while the same URL works from curl. The cause is the custom undici dispatcher that DashScopeContentGenerator.buildClient() hands the OpenAI SDK with headersTimeout: 0 and bodyTimeout: 0; it fails silently against that host, and removing the dispatcher so the SDK uses Node's native fetch restores the connection (QwenLM/qwen-code#4035).

Two subscription products sit beside pay-as-you-go. The Coding Plan Pro is $50 per month for up to 6,000 requests per 5 hours, 45,000 per week, and 90,000 per month, with its own endpoints at coding-intl.dashscope.aliyuncs.com and support for Claude Code, Cline, Qwen Code, Cursor, and others. The Lite tier closed to new subscriptions in March 2026. A Token Plan endpoint at token-plan.ap-southeast-1.maas.aliyuncs.com serves prepaid token bundles; the key type must match the endpoint or the API returns a mismatch error.

Qwen API Pricing and Model IDs

Model Studio bills per million tokens, in USD on the Singapore region, with separate input and output rates. Three families matter: Max (flagship), Plus (balanced), and Flash (cheap), plus the Coder line and the hosted open-weight 27B. Several models tier the rate by input length; the table shows the first tier and the ceiling.

Source: Alibaba Cloud Model Studio model pricing page, Singapore region, read September 1, 2026. qwen3.7-plus showed a limited-time 20% discount on top of the list rate at that time. Context caching discounts repeated input on the models that list it (qwen3.8-max, qwen3.7-plus, qwen3.8-flash, qwen3-coder-plus, qwen3.8-27b). Batch inference is 50% off on qwen-max, qwen3.7-flash, and qwen-flash. Legacy aliases qwen-max ($1.60/$6.40), qwen-plus, and qwen-flash still resolve; new code should target a versioned ID.

Free Tier, Regions, and Rate Limits

The free tier is per model, not per account: each proprietary Qwen model carries 1M free tokens, valid 90 days from the later of Model Studio activation, model release, or application approval. A fresh Singapore account therefore starts with roughly 1M tokens on each of qwen3.8-max, qwen3.7-plus, qwen3.8-flash, the coder models, and the rest. The quota excludes the Batch API, context caching, and fine-tuning.

Rate limits are enforced at the Alibaba Cloud account level. Usage from every RAM user, workspace, and API key under the account is combined, so adding keys adds no headroom. Two limits apply at once, requests per minute and tokens per minute, and the service may also enforce per-second ceilings of RPM/60 and TPM/60. A burst that fits the minute budget can still 429 on the second budget.

Source: Model Studio rate-limiting doc, September 2026. Dated snapshot versions carry much lower quotas (60 RPM, 100,000 TPM on some). A temporary TPM increase can be requested from the console's Increase Rate Limits page; it takes effect immediately and lasts 30 days.

Region choice is a data-residency decision as much as a latency one. Singapore is the international default and the region where the 1M free quota and the USD price list apply. Beijing has roughly double the RPM ceilings but serves from mainland China. The US (Virginia) endpoint exists for teams that need requests to stay in the United States; verify the model you want is in its catalog before building on it.

Call the Qwen API: Python and curl

Because Model Studio speaks the OpenAI wire format, the call is the OpenAI SDK with two fields changed. Streaming, tool calling, and JSON mode work as they do against OpenAI.

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["DASHSCOPE_API_KEY"],
    base_url="https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/compatible-mode/v1",
)

resp = client.chat.completions.create(
    model="qwen3.7-plus",  # or qwen3.8-max, qwen3.8-flash, qwen3-coder-plus
    messages=[
        {"role": "system", "content": "You are a senior engineer."},
        {"role": "user", "content": "Find the race condition in this handler and fix it."},
    ],
)
print(resp.choices[0].message.content)

curl "https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/compatible-mode/v1/chat/completions" \
  -H "Authorization: Bearer $DASHSCOPE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "qwen3.8-max",
    "messages": [{"role": "user", "content": "Explain MoE routing in two sentences."}]
  }'

The same client works against a self-hosted vLLM or SGLang server. Only the base URL and the model name change; the key can be any non-empty string unless you started the server with --api-key.

from openai import OpenAI

client = OpenAI(api_key="local", base_url="http://localhost:8000/v1")

resp = client.chat.completions.create(
    model="Qwen/Qwen3.8-27B",
    messages=[{"role": "user", "content": "Write a retry decorator with exponential backoff."}],
)
print(resp.choices[0].message.content)

Thinking Tokens and the enable_thinking Trap

The Qwen line is a thinking-model line, and that changes both the bill and the request shape. Neither effect is visible from the pricing table, and both are the most common reason a working OpenAI integration breaks the moment the base URL points at Model Studio.

The wire-format trap is separate. Model Studio requires an explicit enable_thinking value on non-streaming calls to reasoning models, and the OpenAI SDK does not send one, so a request that works against OpenAI returns a 400 reading parameter.enable_thinking must be set to false for non-streaming calls (openclaw#21114). The second half of the trap is where the parameter goes. It is not an OpenAI field, so setting it as a keyword argument silently drops it and the same 400 comes back; it has to travel in extra_body (agno#4290).

resp = client.chat.completions.create(
    model="qwen3.7-plus",
    messages=[{"role": "user", "content": "Refactor this function."}],
    extra_body={
        "enable_thinking": False,   # required for non-streaming; a top-level kwarg is dropped
    },
)

# Thinking on, with a cap, streamed:
stream = client.chat.completions.create(
    model="qwen3.7-plus",
    messages=[{"role": "user", "content": "Refactor this function."}],
    stream=True,
    extra_body={"enable_thinking": True, "thinking_budget": 2048},
)
for chunk in stream:
    delta = chunk.choices[0].delta
    # reasoning arrives in reasoning_content, the answer in content
    print(getattr(delta, "reasoning_content", None) or delta.content or "", end="")

Reasoning arrives in a reasoning_content field beside content, so any client that reads only choices[0].delta.content shows nothing while the model thinks. And some open-weight models on the platform, including qwen3-235b-a22b and qwen3-32b, support streaming only: a non-streaming call to them errors regardless of what you set. Commercial models accept both, and Alibaba recommends streaming so reasoning is visible as it is produced.

The placement of the flag differs by server, which is its own source of confusion. On Model Studio it goes in extra_body. On a self-hosted llama.cpp or vLLM server the equivalent is chat_template_kwargs, because there the switch is a chat-template variable rather than a platform parameter. Code that works against one will not disable thinking on the other, and neither errors loudly when the flag is ignored; the only symptom is a bill with more output tokens than expected.

Reasoning billing plus resent context is why Qwen token consumption is hard to predict from the size of a codebase. One developer disputed a Model Studio bill after being charged for 10M tokens across two hours of testing against a roughly 3,200-line project, and Alibaba support attributed the volume to IDE autocompletion sending long context on every call and to conversation history accumulating across turns (Hacker News, August 2025). The dispute itself is one account and was never independently resolved, so treat the fraud framing as unverified. The mechanism support described is real and worth designing against: an agent loop bills the whole conversation on every turn, reasoning tokens are added at the output rate, and neither shows up in a line count. Set a spending alert before the first long run rather than estimating from source size.

Qwen Image and Vision APIs

"Qwen API" covers two surfaces that bill and route differently. Vision-language understanding, where an image goes in and text comes out, runs on the ordinary chat path and is billed per token. Image generation does not: the qwen-image family is not on /compatible-mode/v1 at all. Those models are called through the DashScope MultiModalConversation API at /services/aigc/multimodal-generation/generation, so pointing the OpenAI SDK's images.generate at Model Studio does not work.

Source: Model Studio model pricing, Singapore region, read September 7, 2026. The 1M-token 90-day free quota applies to these models on Singapore and is not offered in other regions. The flagship text models qwen3.8-max and qwen3.7-plus accept image input themselves, so a dedicated VL model is only worth routing to when its cheaper tier matters.

On the generation side the current IDs are qwen-image-3.0-pro (flagship, with prompt rewriting), qwen-image-3.0, the qwen-image-2.0 series, and the older qwen-image-plus and qwen-image-max. Three behaviors are worth knowing before building on them. Text-to-image calls are synchronous, with asynchronous calls available on a subset. Billing is per successfully generated image, so a failed generation is not charged. And qwen-image-max and qwen-image-plus accept only five fixed resolutions, which is the reason teams needing arbitrary aspect ratios end up on the 3.0 series or on Wan. NVIDIA also publishes Qwen-Image in its NIM visual-generative-AI catalog if you would rather run it on your own NIM deployment than call Alibaba.

Third-Party Hosts: OpenRouter, DeepInfra, Fireworks, Together

Alibaba is not the only way to call Qwen. The proprietary Max, Plus, and Flash models are resold through OpenRouter, and the open-weight checkpoints are served by the usual inference providers. Prices below are the provider's list rate on September 1, 2026; routed listings blend several upstreams and can move daily.

Sources: OpenRouter Qwen listings re-read September 7, 2026; DeepInfra Qwen3.8-27B model page and Fireworks Qwen3.8 27B model page (serverless marked not supported), September 1, 2026. Together AI lists Qwen models on its serverless catalog but no Qwen 3.8 rate could be verified on its pricing page, so no number is quoted.

OpenRouter's qwen3.7-plus at $0.32/$1.28 is exactly the Model Studio list rate with Alibaba's 20% promotion applied, which is a useful sanity check on whether a router is passing the upstream price through. For the open-weight 27B, hosted rates run $0.30 to $0.50 input and $2.00 to $3.00 output depending on host and quantization; a cheaper sticker often means FP8 activations rather than reference weights.

Self-Host: The Open-Weight Qwen Lineup

Alibaba publishes most Qwen generations as downloadable weights, which is the main reason Qwen shows up in every self-hosting comparison. The 2026 lineup has two generations that matter and one license change that matters more.

Sources: the Hugging Face model cards linked in Sources. Each checkpoint ships an official FP8 variant (for example Qwen/Qwen3.8-27B-FP8). The 27B models share a 64-layer hybrid layout: 16 blocks of three Gated DeltaNet sublayers followed by one gated-attention sublayer.

For the architecture behind the 27B dense models and why they outscore the 397B MoE they replaced, see Qwen 3.6 27B and Qwen 3.5. For the broader open-weight landscape, see open source LLMs.

vLLM and SGLang Launch Commands

The commands below are the ones in the Qwen3.8 README and the vLLM recipe for Qwen3.8-27B. Both engines need the qwen3 reasoning parser to split thinking from the answer and the qwen3_coder tool-call parser for agent tool use; without them, tool calls arrive as plain text.

vllm serve Qwen/Qwen3.8-27B --port 8000 --tensor-parallel-size 4 \
  --max-model-len 262144 --reasoning-parser qwen3 \
  --enable-auto-tool-choice --tool-call-parser qwen3_coder

vllm serve Qwen/Qwen3.8-27B-FP8 \
  --tensor-parallel-size 4 \
  --max-model-len 262144 \
  --kv-cache-dtype fp8 \
  --reasoning-parser qwen3

sglang serve --model-path Qwen/Qwen3.8-27B --port 8000 --tp-size 4 \
  --context-length 262144 --reasoning-parser qwen3 \
  --tool-call-parser qwen3_coder

The README's --tensor-parallel-size 4 is about KV-cache headroom at 262K context, not weight capacity. The weight arithmetic for a 27B dense model is 27 GB at FP8 (one byte per parameter) and 54 GB at BF16 (two bytes), so a single 80 GB H100 or 141 GB H200 holds the FP8 weights with tens of gigabytes left for KV cache; the vLLM recipe also documents an NVFP4 build at 24.6 GiB on one Blackwell GPU. Run TP=1 for a small team at 32K to 64K context, and go to TP=4 when you need the full 262K window with real concurrency. To push past native context, the recipe passes --max-model-len 1010000 with an --hf-overrides that raises max_position_embeddings, which is YaRN scaling.

Qwen3.8-2.4T-A95B is a different class of deployment: 2.4T parameters is 2.4 TB at FP8 before KV cache, which is a multi-node rack of B200 or B300 GPUs, not a single server. Its model card recommends SGLang, vLLM, or TokenSpeed and does not publish a GPU count. If that is the model you want, the hosted API or a dedicated cluster is the realistic path. For how the serving stack itself is tuned on Morph, see LLM inference and the dedicated inference benchmarks.

Neither the vLLM recipe nor the model card publishes throughput for the 27B, so the only public measured numbers come from practitioners. The most detailed single-GPU writeup runs Qwen3.8-27B on one 24 GB RTX 3090 and reports roughly 1,035 tok/s steady-state decode at 64 concurrent requests (128 in, 512 out) and 948 tok/s end-to-end, plus about 114 tok/s for a single user at default sampling and 124 tok/s greedy. Getting there is not a stock vllm serve: it uses int8 tensor-core GEMMs with an fp16 DeltaNet recurrent state for the batch path, and MTP speculation with a calibrated int4 LM head and split-KV verify attention for the single-user path. Context reaches 150K on the standard config and 262K only with a lossy 4/2-bit KV cache, and the author notes the card must be power-limited to 250 W for the numbers to reproduce (syv-ai/qwen38-27b-rtx3090). Read it as the floor of what a consumer card does, not as a datacenter baseline.

Claude Code, Cline, and Qwen Code Setup

Model Studio runs an Anthropic-compatible Messages endpoint under /apps/anthropic. It serves only /v1/messages; there is no model-list route, so the base URL must end at /apps/anthropic. Appending /v1 makes Claude Code request /v1/models at a doubled path and fail with a 404.

export ANTHROPIC_BASE_URL="https://coding-intl.dashscope.aliyuncs.com/apps/anthropic"
export ANTHROPIC_AUTH_TOKEN="YOUR_MODEL_STUDIO_KEY"
export ANTHROPIC_MODEL="qwen3.8-max"
export ANTHROPIC_DEFAULT_SONNET_MODEL="qwen3.8-max"
claude

# Token Plan users swap the base URL:
# https://token-plan.ap-southeast-1.maas.aliyuncs.com/apps/anthropic

Persist the same four values under an env object in ~/.claude/settings.json to avoid exporting them each session. The key type has to match the endpoint: a pay-as-you-go key against the Coding Plan URL returns an "API key type does not match" error. The legacy dashscope.aliyuncs.com/api/v2/apps/claude-code-proxy URL still works but only serves qwen3-coder-plus. For the general pattern, see using a different LLM in Claude Code.

Qwen Code, Cline, and other OpenAI-SDK agents take the OpenAI-compatible URL instead. Qwen Code reads three environment variables, and the same three values go into ~/.qwen/settings.json under modelProviders if you prefer a file. The pattern is identical for a self-hosted vLLM server: swap the base URL for http://localhost:8000/v1.

export OPENAI_BASE_URL="https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/compatible-mode/v1"
export OPENAI_API_KEY="$DASHSCOPE_API_KEY"
export OPENAI_MODEL="qwen3.7-plus"
qwen
# inside the CLI, pick the OpenAI-compatible provider with /auth

Coding Plan subscribers point Qwen Code at https://coding-intl.dashscope.aliyuncs.com/v1 and the CLI stores the key as BAILIAN_CODING_PLAN_API_KEY. Install and provider details are on the Qwen CLI page.

Undocumented Limits That Break Agents

The rate-limit page covers RPM and TPM. It does not cover the three ceilings that actually stop a coding agent mid-run, each of which surfaces as a 400 with wording no agent framework recognizes. All three are documented only in issue trackers.

The context number is the one that costs the most time. The Coding Plan endpoint at coding-intl.dashscope.aliyuncs.com/v1 serves qwen3.5-plus with an input ceiling of 169,984 tokens, not the 1M the model family advertises and not the 128K most clients assume by default. An agent configured from the model card's context window will run fine for a while and then fail every request once the conversation crosses roughly 170K (hermes-agent#2220). Set the client's context window to the endpoint's limit, not the model's.

The max_tokens ceiling is worse than a plain rejection because of how it fails. DashScope phrases the error as a bracket range rather than in the Anthropic or OpenRouter wording that agent error parsers match on, so a framework misreads it as a context-overflow signal, compresses the conversation, resends the same oversized max_tokens, and gets the identical 400. The result is a compression death loop that reports "context too large" on a two-message conversation while the real cause is one number in the config (hermes-agent#55546). If an agent reports runaway compression against Qwen, check max_tokens before you check the context.

The missing model list is the same root cause as the /apps/anthropic path note above: Alibaba's coding endpoints serve inference routes and not discovery routes, so a /models call returns 404 and any client whose model picker enumerates the provider at startup shows an empty list or fails outright. Pin the model ID in config instead of selecting it from a fetched list.

Qwen API vs DeepSeek vs GLM-5.3 and Kimi K3

The comparison that matters for a coding agent is the monthly bill at agent token shapes, not the sticker. The table prices one profile: 10,000 requests a day at 3,000 input and 1,000 output tokens each, for 30 days, which is 900M input and 300M output tokens per month. No cache hits are assumed, so every row is the ceiling; caching lowers the Qwen, DeepSeek, and Morph rows by different amounts.

Qwen rates from Model Studio Singapore; DeepSeek rates from its official pricing page as checked for our DeepSeek API page (peak hours 01:00 to 04:00 and 06:00 to 10:00 UTC); Morph rates from Morph pricing. Arithmetic: 900 times the input rate plus 300 times the output rate.

Three things fall out of the table. First, the Qwen Flash and Plus tiers sit in the same band as DeepSeek off-peak and Morph's GLM-5.3-Flash; within that band the deciding factors are rate limits, region, and how each model handles your tool-call format, not price. Second, the Max tier costs about 13x the Plus tier for the same tokens, so an agent that routes only hard turns to Max keeps most of Max's quality at a Plus-sized bill; see LLM routing. Third, the 27B open-weight model is more expensive hosted on Model Studio ($0.50/$3.00) than the proprietary Plus model, which is why teams that want the 27B usually self-host it or buy a dedicated endpoint rather than call it per token.

On quality, the model cards put Qwen3.8-27B at 61.7 SWE-bench Pro and Qwen3.8-2.4T-A95B at 67.7. For where GLM-5.3 and Kimi K3 land on the same benchmarks and how Morph serves them, see GLM-5.3, Kimi K3, and Morph's model lineup. For the broader provider table, see LLM API comparison and Kimi API.

A dedicated endpoint is the third way to run Qwen: not Alibaba's shared API, not your own vLLM box. Morph provisions Qwen 3.6 27B on single-tenant B200 GPUs behind the same OpenAI-compatible contract, billed per GPU-hour, so a team's agent traffic never queues behind another customer's and rate limits are whatever the hardware sustains. Use the planner above to turn a team size and agent workload into a GPU count, then open the full calculator or read the dedicated inference overview for pricing and lead time.

FAQ