New Sign up free, 10 calls on us. Up to $1, no card needed.

Qwen3.8 Flash vs Qwen3.8 Max

vs

Which one, when

Both are Alibaba models with the same capability set (chat, vision, code, reasoning, tools, long-context) and the same 131072 max output, so the split is price and inputs. Pick qwen3.8-flash for high-volume work: at $0.15 input and $0.47 output it runs roughly 13x cheaper on both legs than qwen3.8-max at $2 and $6, its cache reads are $0.016 against $0.25, it holds 1000000 tokens of context versus 983616, it also accepts video, and its thinking can be disabled. Choose qwen3.8-max when you specifically want the higher-tier text-and-image model and the cost difference is not the constraint.

Benchmarks

LeadsAbove averageNo peer higherQwen3.8 Flash313 / 163 / 16Qwen3.8 Max731 / 408 / 40

10 measured on both.

Qwen3.8 Flash Qwen3.8 Max other models measured peer average no peer scored higher
SWE-Bench Pro
62.5%
67.7%
OSWorld 2.0 partial
52.3%
N/A
Cybergym
N/A
78.5%
HealthBench
N/A
no peer scored higher 60.2%
JobBench
55.7%
53.4%
PLawBench
N/A
no peer scored higher 73.2%
GPQA Diamond
91.7%
92.6%
ERQA
no peer scored higher 72.3%
N/A
Agents' Last Exam Pass
24.3%
27%
LVBench
76.6%
N/A

Vendor-published: Alibaba (Qwen) Anthropic ByteDance DeepSeek Google MiniMax Moonshot OpenAI Tencent Z.ai

Pricing

Qwen3.8 Flash Qwen3.8 Max Δ
Input / 1M tokens $0.15 $2 0.075×
Output / 1M tokens $0.47 $6 0.078×
Cache read / 1M tokens $0.016 $0.25 0.064×
Cache write 1.25x 1.25x -

Rates from the live catalog at build time; each model page carries the current card.

Where they sit - input price per 1M tokens across all 71 chat models on this billing unit (log scale)

Qwen3.8 Flash · $0.15 Qwen3.8 Max · $2
$0.05 · Qwen3 VL Flash $30 · GPT-5.4 Pro

Capabilities

Qwen3.8 Flash Qwen3.8 Max
Tool use yes yes
Thinking control configurable yes - vendor dial not published
Structured output yes yes
Prompt caching implicit + explicit implicit + explicit
Cache lifetime explicit: 5m, reset on hit explicit: 5m, reset on hit
Minimum cached prefix 1024 tokens 1024 tokens

Specs

Qwen3.8 Flash Qwen3.8 Max
Input modalities text image video text image
Output modalities text text
Released 2026-08-27 2026-08-03
Context window 1M 984K
Max output 131K 131K
Thinking parameter
  • enable_thinking
  • thinking_budget
  • preserve_thinking
-
Accepted values
enable_thinking
  • true
  • false
thinking_budget
  • in tokens
preserve_thinking
  • true
  • false
-
Default

on

qwen3.8-flash is hybrid thinking with thinking enabled by default, thinking_budget defaults to the 262,144-token chain maximum, and preserve_thinking is off

-

Specs are transcribed from each vendor’s documentation; a row a vendor does not publish is left out rather than inferred. Full sources: Qwen3.8 Flash · Qwen3.8 Max

One prompt, both models - measured through the gateway

PROMPT Explain to a CFO, in exactly three sentences, why our LLM bill doubled after we enabled reasoning. CHECK exactly 3 sentences

Qwen3.8 Flash passed · 3 sentences

Enabling reasoning makes the model spend additional output tokens to plan and validate answers before responding, and those tokens are billed. It also increases compute and latency per request, so each task consumes more capacity than a non-reasoning call. As a result, billable tokens and compute roughly doubled, directly driving the higher invoice.

out 330 tok (+262 thinking) latency 8.9 s

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.

PROMPT This function is supposed to return the longest run of consecutive equal items, but callers report it is off by one on single-element inputs and misses runs that end at the last index. Fix it and explain the bug in one paragraph. CHECK fix passes tests

Qwen3.8 Flash passed · 8/8 cases

```python def longest_run(xs): if not xs: return 0 best = 1 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 version counts adjacent equal pairs rather than items in a run, starting both `cur` and `best` at `0`, and it resets `cur` to `0` after a mismatch, thereby discarding the first element of the new run. That makes single-element inputs return `0`, and because every run is effectively measured in “steps” between equal elements, the last element is not counted—particularly noticeable when the longest run ends at the final index.

out 2123 tok (+1933 thinking) latency 43.8 s

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.

PROMPT Extract a JSON object with fields {company, quarter, revenue_usd_m, growth_pct, guidance} from this text. Use null for anything not stated; add no other fields. CHECK valid JSON, schema exact

Qwen3.8 Flash passed · 5/5 fields, guidance null

{ "company": "Meridian Robotics", "quarter": "September quarter", "revenue_usd_m": 412, "growth_pct": 11, "guidance": null }

out 519 tok (+463 thinking) latency 10.5 s

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.

PROMPT Write a 120-word product announcement for an API gateway feature that caches prompts across providers. Forbidden words: "seamless", "unlock", "game-changer", "revolutionize", "empower". Exactly one sentence must be a question. CHECK 120 words, 0 banned words

Qwen3.8 Flash passed · 120 words, 0 banned, 1 question

We are announcing prompt caching across providers in our API gateway. Store approved prompt outputs once and reuse them across supported model providers, cutting latency, cost, and duplicate token spend. The feature matches identical requests, checks validity, and returns cached results while preserving routing controls. Developers keep existing endpoints; the gateway manages storage, invalidation, and provider differences. This reduces noisy repeat calls, improves steady responses, and frees teams to focus on better agent workflows. OpenAI, Anthropic, Google, Mistral, and custom routes are supported. Cache hits appear in analytics with latency, token, and cost reductions visible. Check retention and privacy rules before enabling it. Ready to add cache controls to your gateway? Enable it in settings and watch spend drop now.

out 5958 tok (+5805 thinking) latency 88.8 s

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.

Switch between them with one line

Both ids are in every tab below - the highlighted pair of lines is the only edit. Same endpoint, same key, same request shape.

from openai import OpenAI

client = OpenAI(
    base_url="https://synthorai.io/v1",
    api_key="sk-syn-...",
)

resp = client.chat.completions.create(
    model="qwen3.8-flash",
    # model="qwen3.8-max",  # uncomment this line, comment the one above
    messages=[{"role": "user", "content": "Summarize this diff"}],
    reasoning_effort="medium",
)
print(resp.choices[0].message.content)

Get your API key →

FAQ

Which is cheaper, Qwen3.8 Flash or Qwen3.8 Max?

Qwen3.8 Flash is cheaper on input / 1m tokens ($0.15 vs $2, 13× apart). Other rows may point the other way - the table above carries the full card, and real cost depends on your mix.

Can I A/B test Qwen3.8 Flash against Qwen3.8 Max without two integrations?

Yes. Both are served through the same OpenAI-compatible endpoint with one API key - switching is a one-line model-string change, so you can route a fraction of traffic to each and compare bills directly.

Do Qwen3.8 Flash and Qwen3.8 Max support prompt caching?

Yes - both bill cached reads below their input rate, so warm-prefix workloads cost less than the list rates suggest. The exact cache-read rows are in the pricing table above.

Related comparisons

From our measured studies