Qwen3.8 Max is Alibaba's flagship Qwen model, published on 3 August 2026.
- Input
- text image $2/M
- Output
- text $6/M
- Cache read
- $0.25/M
- Context
- 984K
- vs GPT-4o
- ~60% cheaper
Benchmarks
Vendor-published: Alibaba (Qwen) Anthropic ByteDance DeepSeek Google MiniMax Moonshot OpenAI Tencent Z.ai
Price in context
Where the price sits among 66 comparable models
The bar shows how this model’s price compares with every other model of the same kind on Synthorai. The cheapest and the most expensive are named at each end. These are base rates; batch, region and cache-write discounts are on the pricing page.
Specs & limits
Tokens
| Context window (vendor spec) | 983,616 |
|---|---|
| Max output (vendor spec) | 131,072 |
Prompt caching
| How it caches | automatic + explicit |
|---|---|
| Min prefix | 1,024 |
| Lifetime | explicit: 5m, reset on hit |
| Write cost | 1.25x |
Thinking
| Parameter | reasoning_effort |
|---|---|
| Values | minimal · low · medium · high accepted set is the provider's |
Model
| Modalities | text + image → text |
|---|---|
| Parameters | 2.4T total MoE |
- Flagship Qwen3.8 Max: natively vision-language, 2.4T-parameter MoE
- thinking trace returned in reasoning_content
- text and image in, text out
One prompt, measured through the gateway
Qwen3.8 Max passed · 3 sentences
Enabling reasoning makes the model produce additional hidden steps before responding, and those tokens are billable. It also tends to lengthen each interaction because the model works through more possibilities before settling on an answer. Therefore, the bill doubled mainly due to higher compute and token usage per request, not necessarily because the number of requests doubled.
out 378 tok (+305 thinking) latency 8.6 s
Instruction following (exactly three sentences - countable), audience shaping (CFO register), and the hidden-thinking billing gap the token meters below expose.
Qwen3.8 Max passed · 8/8 cases
```python def longest_run(xs): if not xs: return 0 best = cur = 1 for i in range(1, len(xs)): if xs[i] == xs[i - 1]: cur += 1 else: cur = 1 best = max(best, cur) return best ``` The bug is that the original code starts `best` and `cur` at `0`, so it counts adjacent equal *transitions* rather than the number of items in the run. A run of length `n` has only `n - 1` equal-neighbor transitions, so single-element inputs return `0`, and runs that reach the end are undercounted by one. Initializing the current run to `1` for the first element, resetting it to `1` on a break, and updating `best` from that count fixes the off-by-one.
out 1616 tok (+1411 thinking) latency 34.7 s
Whether the fix is actually correct (runnable), explanation density, and token efficiency on a bounded task.
Qwen3.8 Max passed · 5/5 fields, guidance null
{ "company": "Meridian Robotics", "quarter": "September quarter", "revenue_usd_m": 412, "growth_pct": 11, "guidance": null }
out 1199 tok (+1141 thinking) latency 24.4 s
Schema obedience (no invented fields), hallucination pressure (guidance is explicitly withheld), and structured-output path differences.
Qwen3.8 Max passed · 120 words, 0 banned, 1 question
Today, our API gateway adds prompt caching across major model providers. It stores prompts and responses in one fast cache layer. Teams can lower token spend, reduce latency, and repeat reliable answers. The feature supports OpenAI, Anthropic, Google, and Mistral through one configuration. You can set retention rules, scope access, and invalidate entries quickly. How does your team maintain consistent results during provider outages? Approved cached responses keep applications stable while fallback routes recover. The dashboard shows hit rates, savings, latency, and provider usage. Engineers receive audit trails for every cached prompt, enabling safer testing. Product managers can compare cost trends before and after cache adoption. Start with a small route, then safely expand caching to production traffic right now.
out 2744 tok (+2591 thinking) latency 46.3 s
Constraint obedience (word budget, banned-word list, the single question), style fingerprint, and length control.
Use Qwen3.8 Max in 30 seconds
OpenAI-compatible: swap the base_url, keep your SDK. POST /v1/chat/completions
from openai import OpenAI
client = OpenAI(
base_url="https://synthorai.io/v1",
api_key="sk-syn-...",
)
resp = client.chat.completions.create(
model="qwen3.8-max",
messages=[{"role": "user", "content": "Summarize this diff"}],
reasoning_effort="medium",
)
print(resp.choices[0].message.content)import OpenAI from "openai";
const client = new OpenAI({
baseURL: "https://synthorai.io/v1",
apiKey: "sk-syn-...",
});
const resp = await client.chat.completions.create({
model: "qwen3.8-max",
messages: [{ role: "user", content: "Summarize this diff" }],
reasoning_effort: "medium",
});
console.log(resp.choices[0].message.content);curl https://synthorai.io/v1/chat/completions \
-H "Authorization: Bearer sk-syn-..." \
-H "Content-Type: application/json" \
-d '{
"model": "qwen3.8-max",
"messages": [{"role": "user", "content": "Hello"}],
"reasoning_effort": "medium"
}'package main
import (
"context"
"fmt"
"github.com/openai/openai-go/v3"
"github.com/openai/openai-go/v3/option"
)
func main() {
client := openai.NewClient(
option.WithBaseURL("https://synthorai.io/v1"),
option.WithAPIKey("sk-syn-..."),
)
resp, _ := client.Chat.Completions.New(context.TODO(), openai.ChatCompletionNewParams{
Model: "qwen3.8-max",
Messages: []openai.ChatCompletionMessageParamUnion{
openai.UserMessage("Summarize this diff"),
},
ReasoningEffort: openai.ReasoningEffortMedium,
})
fmt.Println(resp.Choices[0].Message.Content)
}import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.models.chat.completions.*;
import com.openai.models.ReasoningEffort;
OpenAIClient client = OpenAIOkHttpClient.builder()
.baseUrl("https://synthorai.io/v1")
.apiKey("sk-syn-...")
.build();
ChatCompletion resp = client.chat().completions().create(
ChatCompletionCreateParams.builder()
.model("qwen3.8-max")
.addUserMessage("Summarize this diff")
.reasoningEffort(ReasoningEffort.MEDIUM)
.build());
System.out.println(resp.choices().get(0).message().content().orElse(""));About Qwen3.8 Max
- Alibaba describes it as a natively vision-language Max model built on a Mixture-of-Experts architecture with 2.4 trillion parameters, and as the most capable model in the Qwen line to date.
- It takes text and images and returns text, so a single request can mix a prompt with screenshots, charts or scanned pages instead of routing images through a separate vision model.
- Thinking is part of the default behaviour: the model returns its reasoning trace in a separate reasoning_content field alongside the answer, which means short replies still consume reasoning tokens and a very small max_tokens budget can come back with an empty answer even though the request succeeded.
- Function calling, strict JSON-schema structured output and streaming with usage in the final chunk are all available, so it drops into an existing OpenAI-compatible integration without special handling.
- Context is just under one million tokens and a single response can run to 131,072 tokens, which is double the output ceiling of the previous Max generation and the concrete reason to move long-form generation onto it.
- Pricing is tiered by cache behaviour rather than by context length: standard input, a cheaper rate for automatic cache hits, and a separate pair of rates for explicitly created and read cache entries, so prompt-heavy agent loops benefit materially from reusing a stable prefix.
- Alibaba lists availability in its Beijing and Singapore regions.
- Synthorai serves it through the OpenAI-compatible chat completions endpoint.
FAQ
Is the Qwen3.8 Max API free to try?
Yes: new accounts get 10 trial calls and up to $1 in free credit, no card required. At $2/M input tokens, that credit alone covers roughly 62 requests of ~8K tokens against Qwen3.8 Max.
What is Qwen3.8 Max best at?
2.4T-parameter MoE, natively vision-language; text and image in, 131K max output; tiered cache pricing for prompt-heavy loops. See the About section for the full picture from the vendor's own release notes.
How much does Qwen3.8 Max cost?
Qwen3.8 Max costs $2 per million input tokens and $6 per million output tokens on Synthorai. That is the provider's list price, with no platform markup. Cached input tokens bill at $0.25/M.
Does Qwen3.8 Max support prompt caching?
Yes: automatic caching is on by default, with an explicit mode for guaranteed savings. Cached input tokens bill at $0.25/M vs $2/M uncached; prompts need a 1,024-token stable prefix to cache (TTL explicit: 5m, reset on hit). Prompt caching guide →
How do I get access to Qwen3.8 Max?
Point your existing OpenAI SDK at base_url="https://synthorai.io/v1", set model="qwen3.8-max", and you're done. One API key covers every model on the gateway.
Related models
Compare
Every value on this page is transcribed from the vendor's own documentation, linked above, and carries the date it was checked. Prices are compared across the catalogue; specification values that vendors define differently are shown with the difference stated rather than charted. Nothing here is measured by us, and nothing is scored.