Qwen3.8-Max API: Pricing, Context Window and Setup

Qwen3.8-Max is Alibaba's new flagship model for software engineering, agent workloads, long-document work and image understanding. The API model ID is qwen3.8-max, the context window is 1,000,000 tokens, and the list price is $2 per 1M input tokens and $6 per 1M output tokens.

It is live on RouterPlex now, through the same OpenAI-compatible endpoint used for GPT, Claude, Gemini and the rest of the catalog — and through the Anthropic-compatible /v1/messages format, so Claude Code can point at it directly.

Qwen3.8-Max API pricing #

A $5 prepaid balance buys roughly 2.5 million input tokens, or 833,333 output tokens, if a workload used only one category. Real requests mix both.

Two pricing details worth knowing before you budget:

• The preview rates are gone. Through July 2026 Qwen3.8-Max-Preview was available at promotional credit multipliers — some resellers advertised it around $0.17/$0.51 per 1M. Those were time-limited preview rates on a preview model. The generally available model bills at the standard $2/$6.
• Cache reads are billed at the standard input rate on RouterPlex. Alibaba publishes a discounted cache-read tier for this model. RouterPlex does not currently pass a separate cache tier through for qwen3.8-max, so cached prompt tokens are billed at $2 per 1M like any other input token. If your workload leans hard on a stable cached prefix, price that in.

Qwen3.8-Max vs Claude Opus 4.8, GPT-5.6 Sol and Kimi K3 #

List prices per 1M tokens are hard to compare directly, so here is one agent turn — a 40,000-token prompt returning 2,000 tokens — priced across the frontier models RouterPlex carries:

The arithmetic for the Qwen3.8-Max row:

40,000 input tokens  × $2.00/1M = $0.080
 2,000 output tokens × $6.00/1M = $0.012
                          total = $0.092

The gap widens as output grows. Qwen3.8-Max output is a quarter the price of Claude Opus 4.8 output and a fifth of GPT-5.6 Sol output, so reasoning-heavy and long-generation workloads — where the model emits thousands of tokens per turn — are where the price difference actually lands. On short, input-dominated calls the difference is smaller.

Every price in that table is the vendor's own list price, which is also what RouterPlex charges. You can check each one on its live price page: Qwen3.8-Max, Qwen3.7-Max, Kimi K3, Claude Opus 4.8, GPT-5.6 Sol.

Qwen3.8-Max specifications #

Alibaba describes Qwen3.8-Max as a 2.4-trillion-parameter mixture-of-experts model activating roughly 95 billion parameters per token, and positions it against Claude Opus 4.8, Claude Fable 5 and GPT-5.6 Sol on coding evaluations. Treat vendor-run benchmarks as vendor claims: they were produced by Alibaba, on tasks Alibaba chose. RouterPlex's benchmark pages are built from LMArena snapshots and do not yet include Qwen3.8-Max — we do not publish a score until it appears in the source data.

The operationally useful facts are the ones in the table above: a million tokens of context, image input, tool calling, and both API formats.

Call Qwen3.8-Max with RouterPlex #

Create a RouterPlex key, give it a hard budget, and send a standard chat-completions request:

curl https://api.routerplex.com/v1/chat/completions \
  -H "Authorization: Bearer $ROUTERPLEX_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "qwen3.8-max",
    "messages": [
      {"role": "user", "content": "Review this migration plan and name the riskiest assumption."}
    ]
  }'

The Python version uses the regular OpenAI client — only the base URL, key and model ID change:

import os
from openai import OpenAI
 
client = OpenAI(
    api_key=os.environ["ROUTERPLEX_API_KEY"],
    base_url="https://api.routerplex.com/v1",
)
 
response = client.chat.completions.create(
    model="qwen3.8-max",
    messages=[{"role": "user", "content": "Design a rollback-safe deployment plan."}],
)
 
print(response.choices[0].message.content)

Image input uses the standard OpenAI content-block shape:

response = client.chat.completions.create(
    model="qwen3.8-max",
    messages=[{
        "role": "user",
        "content": [
            {"type": "text", "text": "What is wrong with this dashboard layout?"},
            {"type": "image_url", "image_url": {"url": "https://example.com/dashboard.png"}},
        ],
    }],
)

Qwen3.8-Max in Claude Code #

Qwen3.8-Max is served on the Anthropic-compatible /v1/messages format too, so Claude Code can use it without a wrapper:

export ANTHROPIC_BASE_URL="https://api.routerplex.com"
export ANTHROPIC_AUTH_TOKEN="$ROUTERPLEX_API_KEY"
export ANTHROPIC_MODEL="qwen3.8-max"
claude

That puts a $2/$6 model behind the Claude Code harness on a prepaid balance with a hard per-key budget. See Claude Code router setup for the full walkthrough, including per-key model allowlists.

Where Qwen3.8-Max fits #

Reach for it when the task is large, long-running, or generation-heavy:

• Repository-scale code review and refactor planning across many files.
• Long-horizon agents that call tools over many turns, where output tokens accumulate.
• Large document sets, contracts or logs that need the full million-token window.
• Screenshots, diagrams and UI review mixed into technical reasoning.

It is the cheapest frontier-class option in the RouterPlex catalog on a per-turn basis, which makes it a natural first thing to A/B against a Claude or GPT workload you are already paying for. Qwen3.7-Max stays available as qwen3.7-max if you have runs pinned to it.

Run a controlled test #

Take one narrow workload, create a dedicated key with a hard lifetime budget, and compare answer quality, latency and total cost against whatever you run today. The budget cap means the experiment cannot overrun, whatever the agent does.

Create a RouterPlex account, add the $5 minimum balance, and select qwen3.8-max. You can compare it with Kimi K3, Claude Opus 5 and GPT-5.6 through the same endpoint and the same balance.