Qwen3.8 Max API

Access Alibaba Qwen Qwen3.8 Max—also searched as Qwen 3.8 Max / Qwen3.8-Max— through EvoLink's unified chat API. Test long-context coding, tool use, structured output before integrating.

Alibaba QwenText GenerationAvailable

from $1.900 / 1M input tokens$2.000 official price-5%

API docs

Long-context reasoningControllable thinkingFunction calling + Structured OutputExplicit + implicit cachingChat + Responses + Messages

Production routeLive

Live

Context

1.05M context · 131K max output

Best For

Repository-wide engineering, multi-document synthesis, tool-heavy agents

Input

Text + images

Output

Text · JSON (structured output) · tool calls

Models Pricing Readme API

Choose Qwen3.8 Max

A premium reasoning route exposed over three API protocols, for repository-scale coding, long-document analysis, large evidence sets, long-running agents, and complex knowledge work that benefits from a 1,048,576-token working context.

Qwen3.8 Max

Alibaba Tongyi Qwen flagship Max model

Selected

Model ID

qwen3.8-max

Best for

Repository-wide engineering, multi-document synthesis, tool-heavy agents over Chat, Responses, or Messages, and difficult tasks where fewer retries or less human correction can justify a premium route.

Input

$1.900 / 1M-5%

129.2 cr / 1M$2.000official price

Output

$5.700 / 1M-5%

387.6 cr / 1M$6.000official price

Cache write

$2.375 / 1M-5%

161.5 cr / 1M$2.500official price

Cache read (implicit)

$0.381 / 1M-5%

25.9 cr / 1M$0.400official price

Cache read (explicit)

$0.192 / 1M-4%

13 cr / 1M$0.200official price

All rates are per 1M tokens, shown in USD and credits, and reflect your account's current pricing.

Qwen3.8 Max pricing

Estimate what one Qwen3.8 Max request costs before you integrate. The calculator uses your account's current rates, with official pricing as a reference.

Request calculator

Enter the token mix for one request and the number of successful tool calls.

Cache read mode

One request uses one mode, so pick the one you are pricing. Explicit: send cache_control, pay 125% of the input rate to create the cache, then 10% on every hit. Implicit: nothing to send, no write charge, 20% on every hit.

Input tokensCache write tokensImplicit caching has no write charge.Cache read tokens · ImplicitOutput tokens

Estimated request cost

Qwen3.8 Max · Implicit

USD$0.0037

Credits0.2507

Official estimate $0.0039 · save $0.0002 (5%)

Input tokens0.1292 cr

Cache write tokens0 cr

Cache read tokens · Implicit0.0052 cr

Output tokens0.1163 cr

Minimum charge: 0.01 credits per request. Explicit and implicit caching use different rates; a single request uses one mode.

Budget guide

Approximate requests using the current token mix.

Add credits

$10

About 2592 requests

For quick testing

$50

About 13562 requests

For regular development

$100

About 27124 requests

For production evaluation

Server-side tool rates

Only successful server-side calls are billed per call; failed attempts have no tool fee, but tokens still apply.

Web search (turbo)Chat$0.010per call0.68 cr per call
Web search (max)Chat$0.010per call0.68 cr per call
Web searchResponses$0.010per call0.68 cr per call
Web search (image)Responses$0.0080per call0.544 cr per call
Image searchResponses$0.0080per call0.544 cr per call
PDF parseChat$0.0033per page0.2244 cr per page

Qwen3.8 Max API for long-context reasoning and agent workflows

Access Alibaba’s Tongyi Qwen flagship Max model through EvoLink’s unified API. Qwen3.8 Max serves the same model over OpenAI Chat Completions, OpenAI Responses, and Anthropic Messages with full byte passthrough, a 1,048,576-token context window, controllable thinking, and both explicit and implicit prompt caching for repository-scale engineering, long-document analysis, and multi-step tool workflows.

Qwen3.8 Max is served on EvoLink under the model ID qwen3.8-max through Chat Completions · Responses · Anthropic Messages, with the same API key and balance you use for every other model. It offers a 1.05M context window and up to 131K output tokens, plus long-context coding, tool use, structured output.

Qwen3.8 Max specs and capabilities

Numbers come from the EvoLink route configuration; capabilities are what the API exposes today.

Context window: 1.05M tokens
Max output: 131K tokens
Input: Text + images
Output: Text · JSON (structured output) · tool calls
Reasoning: Configurable reasoning effort
Tool use: Function calling with multi-step tool sequences
Prompt caching: Explicit + implicit cache tiers
Server-side tools: Web search (turbo), Web search (max), Web search, Web search (image), Image search, PDF parse, billed per successful call
Protocols: Chat Completions · Responses · Anthropic Messages
Model ID: qwen3.8-max
Parameters: 2.4T

Why Qwen3.8 Max can handle these workloads

The model is most useful when long context, sustained reasoning, and reusable prompt prefixes work together. Context capacity alone does not improve an answer; the workload still needs relevant evidence, clear structure, and an output budget.

A 1M-token workspace, not a target to fill

The 1,048,576-token window can keep related code, specifications, and prior tool results available without excessive chunking. Retrieval and context compaction still matter because irrelevant input competes for attention and increases processing cost.

Sustained reasoning needs an output budget

Reasoning and final-answer tokens both contribute to usage. Treat the output limit as capacity rather than a normal completion size, and set a task-appropriate budget with reasoning_effort.

Caching pays off when prefixes stay stable

Repository instructions, system prompts, reference material, and tool schemas create the strongest cache opportunity when their ordering stays consistent. Frequent model or prompt-structure changes can force the long prefix to be processed again.

Function calling, built-in tools, and Structured Output

Qwen lists function calling, built-in tools, and Structured Output for the production model. Treat support as a capability boundary, then validate the exact tool and schema behavior required by your workflow through the EvoLink route before scaling traffic.

Where Qwen3.8 Max earns a place in a production model stack

A flagship model should not become the default route for every request. Its strongest fit is work where long context, sustained reasoning, or complex tool sequences can reduce retries, handoffs, and human correction.

Repository-scale coding

Use it when an engineering task depends on architecture documents, related services, test history, large diffs, and constraints spread across many files. Measure accepted patches and review time rather than isolated code-generation quality.

Long-document analysis

Keep connected specifications, research papers, contracts, logs, or knowledge-base evidence in one working context. Retrieval and document structure still matter: a 1M-token window does not make irrelevant context useful.

Tool-calling agents across three protocols

Fits multi-step tool selection, structured output, and repeated external actions over Chat, Responses, or Messages. Preserve complete messages, thinking, tool-call IDs, arguments, and tool results across turns.

When a lighter model is the better route

Short chat, classification, rewriting, simple extraction, and latency-sensitive UI actions rarely need maximum reasoning or a 1M context. Keep those on a cheaper route and escalate only when task difficulty justifies the premium.

What sets Qwen3.8 Max apart on EvoLink

These are contract-level capabilities of the EvoLink route, not benchmark claims. Verify latency, quality, and caching behavior on your own tasks before making it a production default.

Three-protocol byte passthrough

OpenAI Chat, OpenAI Responses, and Anthropic Messages all reach the same model with byte passthrough, so thinking, signatures, and cache markers survive the gateway instead of being lossily re-serialized.

Explicit and implicit prompt caching

Explicit cache_control lets you mark reusable prefixes and bills cached reads at 10% of the input rate; implicit caching applies automatically at 20%. The two modes are mutually exclusive per request, and the gateway keeps cache_control markers rather than stripping them.

Reasoning effort you control

Reasoning is on by default at xhigh and can be dialled to medium or low through reasoning_effort. The gateway passes the field through instead of forcing thinking on or off. Do not send reasoning_effort and thinking_budget in the same request.

Thinking must be replayed between turns

This model keeps preserve_thinking enabled by default, so every assistant reasoning_content in the history has to be sent back unchanged and cannot be folded into the content field. Replayed reasoning counts as input tokens and is billed.

Two ways to use Qwen3.8 Max: EvoLink API or Agent

Use the EvoLink API for product backends and batch jobs, or call Qwen3.8 Max from Codex, Claude, or Gemini for coding and analysis workflows. Both paths share the same EvoLink API key, balance, model ID, and request history.

Option 1

Integrate with the EvoLink API

Best for: product backends, batch jobs, automated pipelines

Send OpenAI-compatible Chat Completions (or Anthropic Messages) requests to EvoLink and control the model ID, system prompt, output budget, tools, and structured output.

1Create an EvoLink API key in the console
2Point your OpenAI or Anthropic SDK at the EvoLink base URL and select the model ID shown above
3Send one representative request and read the usage field for input, cached, and output tokens
4Set max_tokens and retries per task; keep tool-call IDs and results across turns

Create EvoLink API Key

Option 2

Call it with an Agent

Best for: coding, review, and analysis tasks in Codex, Claude, and Gemini

Give the Agent the task, the inputs to include, and the acceptance criteria. It assembles the request, calls Qwen3.8 Max through EvoLink, and returns the answer with token usage.

1Set EVOLINK_API_KEY in your local environment; never put it in code or a prompt
2Describe the task, the inputs to include, and the expected output format
3Ask the Agent to call Qwen3.8 Max through EvoLink and show the request before sending
4Let the Agent report the answer, token usage, and any error body

Qwen3.8 Max API code example and error handling

This example shows the shortest runnable request: an OpenAI-compatible Chat Completions call with a system prompt, a user message, and an output budget. Open the API tab for the complete parameter and response reference.

View complete API docs

cURL

curl -X POST https://api.evolink.ai/v1/chat/completions \
  -H "Authorization: Bearer $EVOLINK_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "qwen3.8-max",
    "messages": [
      { "role": "system", "content": "You are a senior engineer reviewing a pull request." },
      { "role": "user", "content": "Review this diff and list every risky change with file and line:\n<diff>" }
    ],
    "max_completion_tokens": 4096,
    "temperature": 0.2
  }'

# Chat Completions uses max_completion_tokens; Responses uses
# max_output_tokens; Anthropic Messages requires max_tokens.
# The response includes choices[0].message and a usage object (prompt,
# cached, and completion tokens).

Invalid request or unsupported parameter

Check the model ID, the messages array, and parameter ranges against the API reference; remove fields this route does not support.

Authentication or balance issue

Check the Authorization bearer token and confirm the available balance in the console.

Context length exceeded

Prompt tokens exceed the Qwen3.8 Max context window. Trim or retrieve only the relevant evidence and reuse cached prefixes.

Rate limited (429)

Back off and retry with jitter; batch or queue requests instead of sending parallel bursts.

Content or tool call rejected

Review sensitive content, malformed tool-call arguments, and JSON schema mismatches before retrying.

What to verify before routing production traffic to Qwen3.8 Max

A suitable workload can still fail because the integration uses the wrong identifier, the wrong max-token field for an endpoint, or drops agent state between turns. Verify the request surface before evaluating model quality.

Use the qwen3.8-max model ID

Use qwen3.8-max on the EvoLink route for Chat Completions, Responses, and Anthropic Messages.

Model ID

Use the right max-token field per endpoint

Chat uses max_completion_tokens, Responses uses max_output_tokens, and Anthropic Messages requires max_tokens. Sending the wrong field can be ignored or rejected upstream.

Endpoints

Replay complete thinking and tool state

Multi-turn agents should retain complete messages, thinking and signature blocks, tool-call IDs, arguments, and tool results. Keeping only the final text breaks state continuity even when the context window is large enough.

Tool state

Send reasoning_content back on every turn

preserve_thinking is enabled by default for this model. Every assistant reasoning_content in the conversation history must be returned unchanged, and it cannot be merged into the content field. Budget for it: replayed reasoning is billed as input tokens.

Thinking replay

Create explicit caches on Chat or Messages

Cache reads work on all three protocols, but creating a large explicit cache on the Responses endpoint is the least reliable path upstream. Mark cache_control prefixes on Chat Completions or Anthropic Messages and read them from any protocol.

Caching

Explicit and implicit prompt caching

Mark reusable prefixes with cache_control and cached reads bill at 10% of the input rate; without it, implicit caching applies automatically at 20%. Writing a cache costs 125% of input, so reuse has to be frequent enough to pay it back. The gateway keeps cache_control markers instead of stripping them.

1M-token context with controllable thinking

Keep connected code, specifications, documents, and agent state in one working context, and control reasoning with reasoning_effort. Treat the window as capacity, not a target: retrieve relevant evidence and set task-appropriate output budgets.

Compare Qwen3.8 Max cost per accepted task, not token price alone

Qwen3.8 Max earns a premium route only when it reduces chunking, retries, failed tool sequences, or human rework on the same production workload. Evaluate identical task sets instead of comparing isolated prompt prices.

First-pass successAccepted deliverable rateRetry countOutput tokensCache-hit rateValid tool callsTime to accepted resultHuman correction and fallback rate

If the model produces usable results with fewer retries and less review effort, a cost-based token rate can still lower total task cost. If those gains do not appear, keep the workload on a lighter route.

Compare Qwen3.8 Max with leading long-context models after workload testing

EvoLink

First verify whether Qwen3.8 Max reduces retries and review effort on your tasks. Then compare price, context, caching, and workload fit to choose the production route.

Model	Qwen3.8 Max	Claude Opus 5	Kimi K3
Input / output	$1.9 / $5.7	$4.75 / $23.75	$2.85 / $14.25
Context	1.05M	1M	1M
Caching	Explicit + implicit	Read + write	Read + write
Best for	Repository-wide engineering, multi-document synthesis, tool-heavy agents over Chat, Responses, or Messages, and difficult tasks where fewer retries or less human correction can justify a premium route.	Premium baseline for long-running coding agents, complex review, and judgment-heavy professional workflows.	Moonshot long-context route for repository-scale coding and multi-document reasoning at a mid-tier rate.

Qwen3.8 Max

Input / output$1.9 / $5.7

Context1.05M

CachingExplicit + implicit

Best forRepository-wide engineering, multi-document synthesis, tool-heavy agents over Chat, Responses, or Messages, and difficult tasks where fewer retries or less human correction can justify a premium route.

Claude Opus 5

Input / output$4.75 / $23.75

Context1M

CachingRead + write

Best forPremium baseline for long-running coding agents, complex review, and judgment-heavy professional workflows.

Kimi K3

Input / output$2.85 / $14.25

Context1M

CachingRead + write

Best forMoonshot long-context route for repository-scale coding and multi-document reasoning at a mid-tier rate.

Other text models on EvoLink besides Qwen3.8 Max

Claude Opus 5

Premium baseline for long-running coding agents, complex review, and judgment-heavy professional workflows.

View model

Kimi K3

Moonshot long-context route for repository-scale coding and multi-document reasoning at a mid-tier rate.

View model

DeepSeek V4 Pro

Cost-sensitive baseline for high-volume coding, reasoning, and agent workloads with a 1M context window.

View model

GPT-5.6

Sol, Terra, and Luna tiers provide a direct comparison for capability, latency, and cost-routing flexibility.

View model

Qwen3.8 Max guides and related reading

Qwen3.8 Max release and features

Separate the production release, early-channel differences, official capabilities, and open-weight status.

Read guide

Qwen3.8 Max benchmark evidence

Review official results, third-party evidence, and the production test plan EvoLink will run.

Read guide

Qwen3.8 Max vs Qwen3.7 Max

Choose whether to stay, canary, or migrate with a reversible production checklist.

Read guide

Qwen3.8 Max vs Kimi K3

Compare coding, agents, long context, cost, and main/challenger/fallback routing roles.

Read guide

Qwen3.8 Max API FAQ

What is the Qwen3.8 Max API model ID?

Use qwen3.8-max for Chat Completions, Responses, and Anthropic Messages on EvoLink.

Which API protocols does it support?

Three: OpenAI Chat Completions, OpenAI Responses, and Anthropic Messages. All serve the same model with full byte passthrough.

What max-token field should I use?

Chat uses max_completion_tokens, Responses uses max_output_tokens, and Anthropic Messages requires max_tokens. Sending the endpoint-native field is safest.

Does it support a 1M-token context?

The EvoLink route records a 1,048,576-token context window. Use it to keep genuinely connected files, documents, and agent state together rather than filling it by default.

How does thinking work?

Reasoning is on by default and controllable through reasoning_effort, which accepts xhigh (default), medium, and low. Do not send reasoning_effort and thinking_budget together. The gateway passes these through and preserves thinking and signature blocks on the Messages endpoint.

Do I need to send reasoning_content back in multi-turn chats?

Yes. Qwen3.8 Max enables preserve_thinking by default, so every assistant reasoning_content in the conversation history must be sent back unchanged, and it cannot be merged into the content field. Returned reasoning tokens count as input tokens and are billed.

How does caching work and what does it cost?

Both explicit caching (cache_control) and automatic implicit caching are supported, and a single request uses one of them, never both. An explicit cached read bills at 10% of the input rate, an implicit one at 20%. Writing an explicit cache bills at 125% of input; implicit caching has no separate write charge.

Can I use the OpenAI SDK or Anthropic Messages?

Yes. Keep the same EvoLink API key, select qwen3.8-max, and use compatible Chat Completions, Responses, or Anthropic Messages flows.

Is it a good default for real-time or high-volume requests?

Usually not without testing. Maximum reasoning and long outputs add latency and cost to simple work. Keep short chat, classification, and lightweight extraction on a smaller route.

How is it priced?

Billing uses four token segments—input, output, cache write, and cache read—at cost-based rates, with cache read split into an explicit and an implicit rate. Live backend pricing takes priority over the fallback rates shown here.