Qwen3.8 Max é o modelo principal da linha Qwen da Alibaba, publicado em 3 de agosto de 2026.
- Entrada
- texto imagem $2/M
- Saída
- texto $6/M
- Leitura de cache
- $0.25/M
- Contexto
- 984K
- vs GPT-4o
- ~60% mais barato
Benchmarks
Publicado pelos fornecedores: Alibaba (Qwen) Anthropic ByteDance DeepSeek Google MiniMax Moonshot OpenAI Tencent Z.ai
O preço em contexto
Posição do preço entre 66 modelos comparáveis
A barra mostra onde fica o preço deste modelo entre todos os modelos do mesmo tipo na Synthorai. Em cada extremidade está o mais barato e o mais caro. São tarifas base; os descontos de lote, região e escrita em cache estão na página de preços.
Especificações e limites
Tokens
| Janela de contexto (especificação do fornecedor) | 983.616 |
|---|---|
| Saída máxima (especificação do fornecedor) | 131.072 |
Cache de prompts
| Modo | automático + explícito |
|---|---|
| Prefixo mín. | 1.024 |
| Duração | explícito: 5 min, reinicia a cada acerto |
| Custo de escrita | 1.25x |
Raciocínio
| Parâmetro | reasoning_effort |
|---|---|
| Valores | minimal · low · medium · high o conjunto aceite é do provedor |
Modelo
| Modalidades | texto + imagem → texto |
|---|---|
| Parâmetros | 2.4T no 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
conforme documentação oficial da Alibaba ↗
Um prompt, medido pelo gateway
Qwen3.8 Max passou · 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.
saída 378 tok (+305 pensamento) latência 8.6 s
Cumprimento da instrução (exatamente três frases - contáveis), ajuste ao público (registro de CFO), e a lacuna de cobrança do pensamento oculto que os medidores de tokens abaixo expõem.
Qwen3.8 Max passou · 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.
saída 1616 tok (+1411 pensamento) latência 34.7 s
Se a correção é de fato certa (executável), a densidade da explicação, e a eficiência em tokens numa tarefa delimitada.
Qwen3.8 Max passou · 5/5 fields, guidance null
{ "company": "Meridian Robotics", "quarter": "September quarter", "revenue_usd_m": 412, "growth_pct": 11, "guidance": null }
saída 1199 tok (+1141 pensamento) latência 24.4 s
Obediência ao esquema (sem campos inventados), pressão de alucinação (guidance é explicitamente retida), e diferenças no caminho de saída estruturada.
Qwen3.8 Max passou · 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.
saída 2744 tok (+2591 pensamento) latência 46.3 s
Obediência às restrições (orçamento de palavras, lista de palavras proibidas, a única pergunta), impressão digital de estilo, e controle de comprimento.
Use o Qwen3.8 Max em 30 segundos
Compatível com OpenAI: troque a base_url, mantenha seu 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(""));Sobre o Qwen3.8 Max
- A Alibaba o descreve como um modelo Max nativamente visual-linguístico construído sobre uma arquitetura Mixture-of-Experts com 2,4 trilhões de parâmetros e como o modelo mais capaz da linha Qwen até hoje.
- Ele aceita texto e imagens e devolve texto, de modo que uma única requisição pode reunir o prompt com capturas de tela, gráficos ou páginas digitalizadas sem desviar as imagens para um modelo de visão separado.
- O raciocínio faz parte do comportamento padrão: o traço volta separadamente no campo reasoning_content, o que significa que mesmo uma resposta curta consome tokens de raciocínio e que um orçamento de max_tokens muito apertado pode devolver uma resposta vazia embora a requisição tenha tido sucesso.
- Chamada de funções, saída estruturada estrita por esquema JSON e streaming com usage no último fragmento estão todos disponíveis, de modo que ele entra sem tratamento especial em uma integração compatível com OpenAI já existente.
- A janela de contexto chega perto de um milhão de tokens e uma única resposta pode alcançar 131.072 tokens, o dobro do teto de saída da geração Max anterior e a razão concreta para mover para lá a geração de textos longos.
- Os preços são escalonados pelo comportamento do cache e não pelo comprimento do contexto: tarifa de entrada padrão, uma tarifa menor para acertos automáticos de cache e tarifas próprias para criar e ler entradas de cache explicitamente.
- Laços de agente que reutilizam um prefixo estável se beneficiam de forma apreciável.
- A Alibaba indica Pequim e Singapura como regiões.
- A Synthorai o oferece pelo endpoint de chat completions compatível com OpenAI.
Perguntas frequentes
A API do Qwen3.8 Max é gratuita para testar?
Sim. Contas novas recebem 10 chamadas de teste e até $1 em créditos gratuitos, sem precisar de cartão. A $2/M de tokens de entrada, só esse crédito já cobre cerca de 62 requisições de ~8K tokens ao Qwen3.8 Max.
Em que o Qwen3.8 Max é melhor?
MoE de 2,4 trilhões de parâmetros, visual-linguístico nativo; entrada de texto e imagem, saída até 131K; preços escalonados por cache. Veja a seção Sobre para o quadro completo, extraído das notas de lançamento do próprio fornecedor.
Quanto custa o Qwen3.8 Max?
Na Synthorai, o Qwen3.8 Max custa $2 por milhão de tokens de entrada e $6 por milhão de tokens de saída. É o preço de tabela do provedor, sem margem da plataforma. Tokens de entrada em cache são cobrados a $0.25/M.
O Qwen3.8 Max suporta cache de prompts?
Sim: o cache automático vem ativado por padrão, com um modo explícito para economia garantida. Tokens de entrada em cache são cobrados a $0.25/M, contra $2/M sem cache; os prompts precisam de um prefixo estável de 1,024 tokens para entrar em cache (TTL explícito: 5 min, reinicia a cada acerto). Guia de cache de prompts →
Como obtenho acesso ao Qwen3.8 Max?
Aponte seu SDK da OpenAI existente para base_url="https://synthorai.io/v1", defina model="qwen3.8-max" e pronto. Uma única chave de API cobre todos os modelos do gateway.
Modelos relacionados
Comparar
Cada valor desta página é transcrito da documentação do fornecedor, ligada acima, e traz a data em que foi verificado. Os preços são comparados em todo o catálogo; os valores de especificação que os fornecedores definem de forma diferente são apresentados com a diferença indicada em vez de representados num gráfico. Nada aqui é medido por nós, e nada é pontuado.