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
Preços por comprimento de entrada
Toda a solicitação usa a tarifa da faixa de comprimento de entrada. Preços em USD por milhão de tokens.
| Tokens de entrada | Entrada | Saída | Entrada (modo raciocínio) |
|---|
Benchmarks
Publicado pelos provedores: Alibaba (Qwen) Anthropic ByteDance DeepSeek Google MiniMax Moonshot OpenAI Tencent Z.ai
O preço em contexto
Posição do preço entre 76 modelos comparáveis
A barra mostra onde fica o preço deste modelo entre todos os modelos do mesmo tipo na Synthorai. Nas extremidades aparecem o mais barato e o mais caro. São as tarifas base; os descontos de batch, região e escrita de cache estão na página de preços.
Especificações e limites
Tokens
| Janela de contexto (especificação do provedor) | 983.616 |
|---|---|
| Saída máxima (especificação do provedor) | 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 aceito é o 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 fonte das especificações do modelo ↗
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 raciocínio) latência 8.6 s
Se a instrução é seguida (exatamente três frases, dá para contar), a adequação ao público (tom para um CFO) e a diferença de cobrança causada pelo raciocínio oculto, que os medidores de tokens abaixo deixam à mostra.
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 raciocínio) latência 34.7 s
Se a correção está mesmo certa (dá para executar), a densidade da explicação e a eficiência em tokens em uma tarefa bem 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 raciocínio) latência 24.4 s
Aderência ao schema (sem campos inventados), pressão para alucinar (o texto diz explicitamente que o guidance não foi divulgado) 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 raciocínio) latência 46.3 s
Respeito às restrições (limite de palavras, lista de palavras proibidas, uma única pergunta), a marca de estilo de cada modelo e o controle do tamanho.
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 na seção Sobre o quadro completo, tirado das notas de lançamento do próprio provedor.
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 markup da plataforma. Tokens de entrada em cache são cobrados a $0.25/M.
Qual é a janela de contexto do Qwen3.8 Max?
O Qwen3.8 Max tem uma janela de contexto de 984K tokens na Synthorai. Uma única resposta pode ter até 131,072 tokens.
O Qwen3.8 Max suporta cache de prompts?
Sim: o cache automático vem ativado por padrão, e um modo explícito permite escolher o que vai para o cache. 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 o SDK da OpenAI que você já usa 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
As especificações e os benchmarks dos fornecedores incluem links para as fontes. O suporte do gateway descreve a implementação da Synthorai. Os exemplos arquivados são solicitações individuais e não garantem o desempenho geral do modelo. Os preços vêm da API pública ou do snapshot usado na compilação.