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

TL;DR

Current as of September 1, 2026. Every rate below was read from Alibaba Cloud Model Studio's Singapore pricing page 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

Sign in to the Alibaba Cloud Model Studio console, pick a region from the upper-right selector, open the API Key page, and click Create API Key. Keys are region-specific: a Singapore key does not work against the Beijing endpoint, and each region has its own console URL and model catalog. New keys start with sk-ws, and the plaintext is shown once. The SDKs read the key from DASHSCOPE_API_KEY.

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.

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)

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, DeepInfra Qwen3.8-27B model page, 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 at the time of writing, 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.

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.

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