Qwen API pricing is not one universal rate. Your cost depends on the Qwen platform, exact Model ID, deployment region, input length, output length, thinking tokens, cached tokens, Batch API usage, and built-in tools.
Quick answer: On the current QwenCloud pay-as-you-go service,
qwen3.8-maxcosts $2 per million input tokens and $6 per million output tokens.qwen3.8-27bcosts $0.50 input and $3 output, while the first Qwen3.7-Flash pricing tier costs $0.03 input and $0.13 output. Long prompts, reasoning, cache operations, and built-in tools can change the final bill.
This page explains API tokens used for model inference. It does not cover the market price of an unrelated cryptocurrency that may also use the name “Qwen token.”
Pricing warning: Prices and temporary discounts can change. QwenCloud states that the final cost is determined by actual billed usage. Check the official model page and your console before approving a production budget.
Independent verification note: Try-Qwen-AI.com is an independent Qwen resource. It is not affiliated with, endorsed by, or operated by Alibaba Group, Alibaba Cloud, QwenCloud, or the Qwen team.
Qwen API Pricing Snapshot
| Pricing item | Current rule |
|---|---|
| Text generation | Input and output are billed separately per 1 million tokens. |
| Thinking tokens | Reasoning tokens count as output tokens and use the output-token rate. |
| Tiered models | The total input tokens in one request determine the tier; all tokens in that request use that tier’s rates. |
| Batch API | Input and output cost 50% of the real-time rates for supported models. |
| Context cache | Cached input receives a model-specific discount; cache creation can have a separate price. |
| Built-in tools | Some tools charge per successful call in addition to model tokens. |
| Failed requests | Failed API calls are not charged and do not consume the free inference quota. |
| Free quota | Model-specific and time-limited; it does not cover every product or fee. |
The official QwenCloud pricing guide distinguishes text-token billing from image, video, audio, and speech billing. This article focuses primarily on text and multimodal text-generation models whose usage is measured in tokens.
QwenCloud vs Alibaba Cloud Model Studio
“Qwen API” can refer to more than one official service.
| Service | Primary pricing source | Important difference |
|---|---|---|
| QwenCloud | QwenCloud Model Marketplace and API Pricing pages | Includes the newest Qwen3.8 models, pay-as-you-go pricing, Token Plan, and built-in tools. |
| Alibaba Cloud Model Studio | Regional Model Studio pricing tables and console | Prices, available models, promotions, endpoints, and free quotas can vary by region and deployment scope. |
| Third-party Qwen provider | The provider’s own pricing page | The provider sets its own rates, cache policy, limits, and model aliases. |
| Self-hosted Qwen | Your infrastructure bill | No provider token charge, but GPU, storage, networking, power, and engineering costs remain. |
Do not combine a QwenCloud price with an API key and endpoint from another service. Regional Model Studio deployments can expose different prices for the same model family.
The current official pricing references are the QwenCloud API Pricing page, the QwenCloud Model Marketplace, and the Alibaba Cloud Model Studio pricing table.
Current QwenCloud Text Model Prices
The table below uses public QwenCloud or Model Studio list rates in US dollars per 1 million tokens. Temporary promotions are separated from standard prices because they can expire.
| Model ID | Input range per request | Input price | Output price | Pricing note |
|---|---|---|---|---|
qwen3.8-max | Up to 1M | $2.00 | $6.00 | Current hosted flagship; flat public rate across its listed context. |
qwen3.8-2.4t-a95b | Up to 1M | $2.00 | $6.00 | Hosted access to the Max-class open-weight checkpoint. |
qwen3.8-27b | Up to 1M | $0.50 | $3.00 | Smaller Qwen3.8 model with hosted and open-weight access. |
qwen3.7-max | Up to 1M | List: $2.50 | List: $7.50 | A temporary 50% discount was displayed when this page was verified. |
qwen3.7-plus | Up to 256K | List: $0.40 | List: $1.60 | A temporary 20% discount was displayed. |
qwen3.7-plus | Above 256K to 1M | List: $1.20 | List: $4.80 | All request tokens use the higher tier. |
qwen3.7-flash | Up to 32K | $0.03 | $0.13 | Higher pricing tiers apply when the request exceeds 32K. |
qwen3.6-flash | Up to 256K | $0.25 | $1.50 | Supports Batch and context caching. |
qwen3.6-flash | Above 256K to 1M | $1.00 | $4.00 | Long-context tier. |
The table is not a complete model catalog. Audio, speech, image generation, video generation, embeddings, reranking, translation, and specialist document models can use different units such as images, seconds, characters, or modality-specific tokens.
Current Promotions vs List Prices
Promotional prices should not be used as the only long-term budget assumption.
When this article was verified:
qwen3.7-maxdisplayed a 50% discount, reducing its public $2.50/$7.50 list rates to $1.25/$3.75.qwen3.7-plusdisplayed a 20% discount on its list rates.- Some Model Studio regions displayed separate daytime and nighttime promotions.
- Token Plan can apply its own Credits discounts that are independent of pay-as-you-go token rates.
Use list prices for conservative forecasting, then show promotions as a separate temporary saving. Store the price source and verification date with every budget model.
How Qwen Token Billing Works
A token is a unit used by the model to process text and other supported inputs. One token is not always one word, one character, or one byte.
The basic text-generation cost is:
Total cost =
(input tokens ÷ 1,000,000 × input rate)
+
(output tokens ÷ 1,000,000 × output rate)A production request can also include:
- Cached-input charges.
- Explicit cache-creation charges.
- Reasoning tokens.
- Built-in tool-call fees.
- Image, video, or audio input tokens.
- Taxes or currency-conversion charges applied to the account.
What Counts as Input Tokens?
Input tokens can include more than the newest user message:
- The system prompt.
- The current user message.
- Previous user and assistant messages sent again with the request.
- Tool definitions and JSON schemas.
- Tool results included in the conversation.
- Retrieved documents and web content.
- Historical
reasoning_contentwhen preserved. - Images, video, and audio converted into model-specific tokens.
Long conversations become more expensive when the application resends the full message history on every turn. Function descriptions also count as input tokens even though calling a developer-defined function has no separate Qwen tool fee.
What Counts as Output Tokens?
Output tokens include the content produced by the model. Depending on the model and request, they can include:
- The visible final answer.
- Reasoning or thinking tokens.
- Function-call names and arguments.
- Structured JSON output.
- Text generated after the model receives tool results.
Output is usually more expensive than input, so uncontrolled response length can dominate the bill even when prompts are short.
How Thinking Tokens Are Billed
Qwen reasoning tokens are counted inside completion_tokens and billed at the model’s output-token rate.
A typical usage object can look like this:
{
"usage": {
"prompt_tokens": 50,
"completion_tokens": 300,
"total_tokens": 350,
"completion_tokens_details": {
"reasoning_tokens": 245,
"text_tokens": 55
}
}
}In this example, all 300 completion tokens are billed at the output rate, not only the 55 visible answer tokens.
- Disable thinking for simple extraction, rewriting, or classification when quality remains acceptable.
- Use
thinking_budgetor the supported reasoning control to cap reasoning. - Log
reasoning_tokensseparately from visible text. - Remember that preserved historical reasoning can become billed input on later turns.
How Tiered Pricing Works
Some Qwen models use pricing tiers based on the total input tokens in a single request.
Important: When a request enters a higher tier, all input tokens and the applicable output tokens use that tier’s prices. Qwen does not bill the first part at the lower rate and only the excess at the higher rate.
For example, the Qwen3.7-Plus list rates are:
| Total input in one request | Input price | Output price |
|---|---|---|
| Up to 256K | $0.40 per 1M | $1.60 per 1M |
| Above 256K to 1M | $1.20 per 1M | $4.80 per 1M |
A request containing 256,001 input tokens moves the complete request into the second tier. Conversation history, tool schemas, images, retrieved documents, and preserved reasoning all contribute to the threshold.
Qwen API Cost Formula
A more complete cost formula is:
Total =
(uncached input ÷ 1,000,000 × standard input rate)
+
(cached input ÷ 1,000,000 × cache-read rate)
+
(cache-creation tokens ÷ 1,000,000 × cache-creation rate)
+
(completion tokens ÷ 1,000,000 × output rate)
+
built-in tool feesChoose the input and output rates from the pricing tier triggered by that individual request. Do not choose the tier from the total monthly token volume.
Cost Examples for 1,000 Requests
Assume each request uses:
- 2,000 input tokens.
- 500 output tokens.
- No thinking tokens beyond the visible output.
- No cache, tools, Batch discount, free quota, tax, or promotion.
| Model | 2M input-token cost | 0.5M output-token cost | Total for 1,000 requests |
|---|---|---|---|
qwen3.7-flash, first tier | $0.060 | $0.065 | $0.125 |
qwen3.6-flash | $0.50 | $0.75 | $1.25 |
qwen3.7-plus, list rate | $0.80 | $0.80 | $1.60 |
qwen3.8-27b | $1.00 | $1.50 | $2.50 |
qwen3.8-max | $4.00 | $3.00 | $7.00 |
The cheapest model is not automatically the cheapest completed task. A weaker model can require more retries, longer prompts, human correction, or escalation to another model. Measure cost per successful business result, not only cost per token.
Long-Context Pricing Example
Suppose one Qwen3.7-Plus request contains:
- 300,000 input tokens.
- 5,000 output tokens.
The request exceeds 256K, so all tokens use the higher list-price tier:
Input:
300,000 ÷ 1,000,000 × $1.20 = $0.36
Output:
5,000 ÷ 1,000,000 × $4.80 = $0.024
Total:
$0.384Splitting a document into smaller calls can reduce the tier, but only when the task does not require the model to reason over the entire document at once. Artificially splitting context can reduce accuracy or create additional output and orchestration costs.
Thinking-Mode Cost Example
Assume a Qwen3.8-Max request uses:
- 10,000 input tokens.
- 40,000 reasoning tokens.
- 2,000 visible answer tokens.
Total completion tokens are 42,000:
Input:
10,000 ÷ 1,000,000 × $2 = $0.02
Reasoning + answer:
42,000 ÷ 1,000,000 × $6 = $0.252
Total:
$0.272Looking only at the 2,000 visible tokens would significantly underestimate the request cost.
Qwen Context Cache Pricing
Context caching reduces the cost of repeated input prefixes such as:
- A large system prompt.
- Tool definitions.
- A policy or reference document.
- A shared repository map.
- Repeated multi-turn context.
| Model | Standard input | Implicit cached input | Explicit cache creation | Explicit cache read |
|---|---|---|---|---|
qwen3.8-max | $2.00 | $0.25 | $2.50 | $0.17 |
qwen3.8-2.4t-a95b | $2.00 | $0.25 | $2.50 | $0.17 |
qwen3.8-27b | $0.50 | $0.10 | $0.625 | $0.05 |
qwen3.7-plus, first list tier | $0.40 | $0.08 | $0.50 | $0.04 |
qwen3.7-flash, first tier | $0.03 | $0.006 | $0.038 | $0.003 |
qwen3.6-flash, first tier | $0.25 | Check model page | $0.3125 | $0.025 |
All prices in this table are per 1 million applicable input tokens. Output tokens keep their normal output rate.
Explicit vs Implicit Cache
| Cache type | How it works | Generic Model Studio billing rule | Best use |
|---|---|---|---|
| Implicit cache | The service automatically detects repeated prefixes | Cached input is commonly billed at 20% of standard input | Applications that want automatic savings without managing cache objects |
| Explicit cache | The application deliberately creates and reuses a cache | Creation commonly costs 125% of standard input; hits cost 10% | Large stable prompts or documents with predictable reuse |
| Session cache | Context is reused across supported Responses API turns | Uses the applicable session-cache rules | Long-running agent and conversation workflows |
QwenCloud model pages publish exact per-model cache prices that can differ slightly from the generic percentages. Use the model page when calculating a real bill.
Cache hits appear in:
usage.prompt_tokens_details.cached_tokensExplicit cache-creation usage can appear in fields such as:
usage.prompt_tokens_details.cache_creation_input_tokensContext Cache Savings Example
Assume a Qwen3.8-Max application sends the same 100,000-token prefix in 100 requests.
Without cache:
100,000 × 100 = 10,000,000 input tokens
10M × $2 = $20With one explicit cache creation and 99 complete cache reads:
Cache creation:
0.1M × $2.50 = $0.25
99 cache reads:
9.9M × $0.17 = $1.683
Simplified cached-prefix total:
$1.933This simplified example excludes changing prompt tokens, output, tool calls, failed cache hits, expiration, and taxes. The saving depends on actually reusing the prefix while the cache remains valid.
Use the dedicated Qwen Context Caching Guide before designing a production cache strategy.
Qwen Batch API Pricing
For supported text-generation and embedding models, QwenCloud Batch API bills input and output tokens at 50% of the real-time rates.
Batch is suitable for:
- Dataset classification.
- Document extraction.
- Large-scale summarization.
- Evaluation jobs.
- Embedding generation.
- Offline content processing.
Thinking and visible answer tokens both receive the Batch output discount. Only successful requests are billed.
Batch and context-cache discounts cannot be combined on the same request. Compare both approaches rather than assuming two discounts can be stacked.
Built-In Tool Fees
Some QwenCloud built-in tools add a per-call fee on top of the model’s input and output tokens.
| Tool | Current public fee | Additional token effect |
|---|---|---|
| Web Search | $10 per 1,000 calls, or $0.01 per call | Search results and extracted content can increase input tokens. |
| Image Search | $8 per 1,000 calls, or $0.008 per call | Returned results and model analysis can increase tokens. |
| Web Extractor | Temporarily free | Extracted page content is added to model input and billed as tokens. |
| Code Interpreter | Temporarily free | The model’s requests and returned context can increase token usage. |
| Developer function calling | No separate Qwen tool fee | Tool definitions, arguments, and tool results count as tokens. |
| MCP tools | No standard QwenCloud tool fee | The MCP provider may charge separately, and context still consumes tokens. |
“Free tool” does not mean “zero-cost request.” A free web extractor can add thousands of input tokens to the model call.
Are Failed Requests Charged?
QwenCloud states that failed API calls are not charged and do not consume the free quota. Batch API also bills only successful requests.
However:
- A successful response that your application discards is still billable.
- A successful retry is billed even when the earlier attempt failed.
- A tool can complete an external action before your client loses the response.
- Repeated valid requests created by an application bug are billable.
- A moderation or parameter failure should not be retried unchanged.
Use bounded retries and idempotency protection to avoid both duplicate costs and duplicate external actions.
Qwen Free Quota
QwenCloud and Model Studio provide free quotas for selected models and new accounts, but there is no single permanent free-token allowance covering every Qwen model.
- Quota size varies by model.
- Model Studio international quotas are commonly valid for 90 days after activation.
- Some regional or mainland deployments provide no free quota.
- Promotional eligibility can depend on account type and activation date.
- Token Plan and Coding Plan dedicated keys do not consume the general pay-as-you-go free quota.
QwenCloud states that the free inference quota does not cover:
- Batch API calls.
- Built-in tool-call fees.
- Fine-tuning.
- Model deployment.
- Custom models.
Check the free quota in the current model page and account console rather than assuming a quota listed for another model applies.
Pay-As-You-Go vs Token Plan vs Coding Plan
| Billing option | Billing unit | Best fit | Main limitation |
|---|---|---|---|
| Pay-As-You-Go | Tokens, images, seconds, characters, or tool calls | Custom applications, APIs, variable workloads, and transparent metering | Monthly cost varies with usage. |
| Token Plan | Subscription Credits | Supported coding and agent tools requiring predictable spending | Credits are model-dependent and cannot be converted to one universal token amount. |
| Coding Plan | Subscription request quotas | Supported AI coding tools | Request-based quotas are not equivalent to standard pay-as-you-go token prices. |
| Self-hosted | Infrastructure and operations | High steady volume, privacy control, or custom deployment | Requires hardware, serving, monitoring, and engineering. |
Dedicated keys and Base URLs are not interchangeable between Pay-As-You-Go, Token Plan, and Coding Plan. A billing-mode mismatch can produce authentication errors even when the key is valid.
Qwen Token Plan Prices and Credits
The current QwenCloud Token Plan Personal Edition displayed the following limited-time monthly prices when this article was verified:
| Plan | Limited-time monthly price | 7-day quota | Concurrent agents |
|---|---|---|---|
| Lite | $6 | 2,500 Credits | 1–2 |
| Standard | $18 | 10,000 Credits | 3–4 |
| Pro | $68 | 40,000 Credits | 6–8 |
| Credit Pack | $15 per pack | 20,000 Credits | Requires an active subscription |
These are promotional prices and can differ from another Alibaba Cloud purchase channel or later date. Check the official Token Plan Personal Edition page before subscribing.
Why Credits Are Not Tokens
A Qwen Token Plan Credit is a subscription accounting unit, not one model token.
Credit consumption can depend on:
- The selected model.
- Input tokens.
- Cached tokens.
- Output and reasoning tokens.
- Image, audio, or video generation.
- Built-in Harness tools.
- Temporary discounts.
There is no single accurate formula such as “one Credit equals 1,000 tokens” for all Qwen models. Use the Token Plan usage details to see actual deductions.
How to Read the API Usage Object
Use the returned usage object instead of estimating tokens from word count:
{
"usage": {
"prompt_tokens": 1520,
"completion_tokens": 85,
"total_tokens": 1605,
"prompt_tokens_details": {
"cached_tokens": 1480,
"cache_creation_input_tokens": 0
},
"completion_tokens_details": {
"reasoning_tokens": 30,
"text_tokens": 55
}
}
}| Field | Meaning |
|---|---|
prompt_tokens | Total input tokens, including cached input. |
completion_tokens | Total generated tokens, including reasoning where applicable. |
total_tokens | Prompt plus completion tokens. |
cached_tokens | Input tokens billed at the applicable cache-hit rate. |
cache_creation_input_tokens | Tokens used to create an explicit cache. |
reasoning_tokens | Thinking tokens included in completion billing. |
text_tokens | Text portion of the relevant input or output. |
For streaming Chat Completions, enable usage reporting so that the final usage-only chunk is returned:
stream_options={"include_usage": True}Node.js Qwen Cost Calculator
The calculator below separates uncached input, cached input, cache creation, output, and tool fees.
/**
* Estimate Qwen API cost in USD.
*
* Rates must be the correct per-1M-token prices for the
* model, region, billing mode, and per-request pricing tier.
*/
function estimateQwenCost({
inputTokens,
outputTokens,
inputRate,
outputRate,
cachedInputTokens = 0,
cachedInputRate = inputRate,
cacheCreationTokens = 0,
cacheCreationRate = inputRate,
toolCalls = 0,
toolFeePerCall = 0,
}) {
const values = {
inputTokens,
outputTokens,
inputRate,
outputRate,
cachedInputTokens,
cachedInputRate,
cacheCreationTokens,
cacheCreationRate,
toolCalls,
toolFeePerCall,
};
for (const [name, value] of Object.entries(values)) {
if (!Number.isFinite(value) || value < 0) {
throw new TypeError(`${name} must be a non-negative number.`);
}
}
if (cachedInputTokens > inputTokens) {
throw new RangeError(
"cachedInputTokens cannot exceed total inputTokens."
);
}
const uncachedInputTokens = inputTokens - cachedInputTokens;
const uncachedInputCost =
(uncachedInputTokens / 1_000_000) * inputRate;
const cachedInputCost =
(cachedInputTokens / 1_000_000) * cachedInputRate;
const cacheCreationCost =
(cacheCreationTokens / 1_000_000) * cacheCreationRate;
const outputCost =
(outputTokens / 1_000_000) * outputRate;
const toolCost = toolCalls * toolFeePerCall;
const total =
uncachedInputCost +
cachedInputCost +
cacheCreationCost +
outputCost +
toolCost;
return {
uncachedInputCost,
cachedInputCost,
cacheCreationCost,
outputCost,
toolCost,
total,
};
}
// Example: 1,000 Qwen3.8-Max requests,
// 2,000 input and 500 output tokens each.
const estimate = estimateQwenCost({
inputTokens: 2_000_000,
outputTokens: 500_000,
inputRate: 2,
outputRate: 6,
});
console.log({
...estimate,
formattedTotal: `$${estimate.total.toFixed(4)}`,
});This function does not select the pricing tier automatically. Your application must select rates according to the input-token count of each request before aggregating monthly costs.
How to Estimate a Monthly Qwen Budget
- Record real usage from a representative test period.
- Separate models and pricing tiers.
- Separate input, cached input, cache creation, reasoning, and visible output.
- Count built-in tool calls.
- Measure successful requests and retries.
- Apply expected monthly growth.
- Add a safety margin for traffic spikes and longer outputs.
- Use list prices rather than relying entirely on temporary promotions.
- Add applicable tax and currency effects.
- Compare the estimate with the provider’s actual bill every month.
A useful budget report should calculate cost by:
- Application.
- Environment.
- Customer or project.
- Model.
- Feature.
- Successful business outcome.
Use the planned Qwen API Cost Calculator for interactive estimates.
How to Reduce Qwen API Costs
Route each task to the right model
Use Flash for routine extraction, classification, rewriting, or high-volume tasks when its measured quality is sufficient. Escalate difficult tasks to Plus or Max instead of routing everything to the flagship.
Control output and reasoning
- Ask for concise output.
- Set a realistic output limit.
- Disable thinking for simple tasks.
- Cap the thinking budget for reasoning tasks.
- Do not generate explanations that the application does not use.
Manage conversation history
- Remove irrelevant turns.
- Summarize old history.
- Trim large tool results.
- Start a new session when full history is unnecessary.
- Monitor proximity to tier thresholds.
Cache stable prefixes
Cache large system prompts, policies, documents, and tool definitions that remain identical across many requests.
Use Batch API for offline workloads
Move dataset processing, extraction, annotation, and evaluation to Batch when users do not need an immediate answer.
Control tools
- Do not force web search on every request.
- Limit search depth and extracted pages.
- Keep tool schemas compact.
- Cache retrieved content when permitted.
- Track tool fees separately from token fees.
Fix retry loops
Retry only transient errors. An application that repeatedly submits valid but unnecessary requests can create a bill even when the final user experience fails.
Qwen API vs Self-Hosting Costs
Open-weight Qwen models do not have a QwenCloud per-token fee when you run them on your own infrastructure. Self-hosting is not free.
Include:
- GPU purchase or rental.
- CPU, RAM, and storage.
- Network transfer.
- Power and cooling.
- Quantization and serving engineering.
- Monitoring and incident response.
- Idle capacity.
- Availability, scaling, and backup infrastructure.
- Security and compliance operations.
A self-hosted checkpoint may also differ from the managed API in modalities, context size, tools, performance, and model updates. Compare equivalent capabilities rather than only comparing a GPU-hour price with a token rate.
Cost Monitoring Checklist
- Log Model ID and provider.
- Log region and billing mode.
- Record input and output pricing tier.
- Record
prompt_tokens. - Record
completion_tokens. - Record reasoning tokens.
- Record cache hits and cache creation.
- Count built-in tool calls.
- Track retries and failed requests.
- Tag application, feature, project, or customer.
- Create daily and monthly budget alerts.
- Compare internal estimates with the official bill.
- Review model and pricing changes before migration.
Frequently Asked Questions
How much does the Qwen API cost?
It depends on the model and request. Current selected QwenCloud rates range from $0.03 input and $0.13 output per million tokens for the first Qwen3.7-Flash tier to $2 input and $6 output for Qwen3.8-Max. Long-context tiers, reasoning, cache, and tools can change the result.
What is the Qwen token price?
There is no single Qwen token price. Input, output, cached input, cache creation, and reasoning can use different rates. The exact model, region, billing mode, and request tier must be specified.
How much is Qwen3.8-Max?
The current QwenCloud public rate is $2 per million input tokens and $6 per million output tokens. Implicit cached input is $0.25 per million, explicit cache creation is $2.50, and explicit cache reads are $0.17.
What is the cheapest Qwen API model?
Among the current featured general models reviewed, Qwen3.7-Flash has the lowest first-tier public rate at $0.03 input and $0.13 output per million tokens for requests up to 32K input tokens. Higher context tiers cost more.
Are Qwen reasoning tokens billed?
Yes. Reasoning tokens are part of completion_tokens and are billed at the model’s output rate.
Are cached Qwen tokens cheaper?
Yes. Cache reads are billed below standard input rates. Exact implicit, explicit-creation, and explicit-read prices differ by model.
Does Qwen Batch API cost less?
Yes. Supported Batch API input and output tokens cost 50% of their real-time prices. Batch and context-cache discounts cannot be combined on the same request.
Does Qwen charge for failed requests?
QwenCloud states that failed API calls are not charged and do not consume the free inference quota. A successful response, successful retry, or successful tool call can still be billed.
Does Qwen web search cost extra?
Yes. QwenCloud currently lists Web Search at $10 per 1,000 successful calls. Retrieved content can also increase the model’s input-token charge.
What happens when a Qwen request exceeds 256K tokens?
For models with a 256K pricing threshold, the request moves into the higher tier. All tokens in that request use the higher tier’s applicable input and output rates.
Is Qwen Token Plan cheaper than pay-as-you-go?
QwenCloud markets Token Plan as a lower-cost option for supported AI tools, but the answer depends on the model mix, Credits usage, workload, and unused quota. Pay-as-you-go is easier to calculate directly from tokens.
Are Qwen Credits the same as tokens?
No. Credits are subscription accounting units. Their consumption varies by model, input, cached input, output, thinking, modality, and built-in tool.
Can I use the Qwen API for free?
Selected models provide new-user free quotas, but the amount, duration, region, and eligibility vary. Batch, built-in tools, fine-tuning, deployment, and custom models are not covered by the general free inference quota.
Is self-hosting Qwen cheaper than the API?
It can be cheaper at high, steady utilization, but self-hosting replaces token charges with GPU, storage, networking, engineering, monitoring, idle-capacity, and security costs. The downloadable model may also differ from the hosted API.
Official Sources and Verification
- QwenCloud API Pricing
- QwenCloud Model Marketplace
- Qwen3.8-Max pricing
- Qwen3.8-27B pricing
- Qwen3.8-2.4T-A95B pricing
- Qwen3.7-Plus pricing
- Qwen3.7-Flash pricing
- QwenCloud billing rules
- QwenCloud token counting
- QwenCloud Batch API pricing
- Model Studio context-cache billing
- Alibaba Cloud Model Studio regional pricing
- QwenCloud Token Plan Personal Edition
- QwenCloud free quota
Verification status: Model prices, cache rates, current promotions, free-quota rules, Token Plan prices, Batch discounts, built-in tool fees, and reasoning-token billing were checked against official QwenCloud and Alibaba Cloud pages on August 23, 2026. Cost examples use the displayed list or fixed rates and exclude promotions unless explicitly stated. Prices, eligibility, taxes, and billing behavior remain subject to the official account bill.
Last verified: August 23, 2026.