Qwen3.8 Flash é o nível rápido e econômico da geração Qwen3.8 da Alibaba, lançado em 27 de agosto de 2026.
- Entrada
- texto imagem vídeo $0.15/M
- Saída
- texto $0.47/M
- Leitura de cache
- $0.016/M
- Contexto
- 984K
- vs GPT-4o
- ~97% 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) | 1.000.000 |
|---|---|
| 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 do fornecedor | enable_thinking + thinking_budget + preserve_thinking |
|---|---|
| Valores aceites | enable_thinking true · false; thinking_budget in tokens; preserve_thinking true · false |
| Valor predefinido | 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 aplicado quando o pedido nada indica |
| Pode ser desativado | Sim |
| Comportamento do raciocínio | Trace returns in reasoning_content and is dropped from later turns unless preserve_thinking is true, which appends it to the input and bills it as input tokens; qwen3.8-flash is on Alibaba's preserve_thinking list. |
| Parâmetro | reasoning_effort |
| Valores | minimal · low · medium · high a superfície de parâmetros do gateway - aplica-se o mapeamento do fornecedor acima |
Modelo
| Modalidades | texto + imagem + vídeo → texto |
|---|---|
| Parâmetros | 125B no total · 6B ativos MoE |
- Multimodal Flash model on the Qwen3.8-Flash-Next architecture (Gated DeltaNet with Qwen Sparse Attention, n-gram embeddings; 51B n-gram embedding parameters on top of the 125B MoE)
- text, image and video in, text out
- max input 991,808 tokens, 983,616 in thinking mode
- reasoning chain up to 262,144 tokens
- one price for thinking and non-thinking calls with no length tiers
- batch inference not offered
conforme documentação oficial da Alibaba ↗
Um prompt, medido pelo gateway
Qwen3.8 Flash passou · 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.
saída 330 tok (+262 pensamento) latência 8.9 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 Flash passou · 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.
saída 2123 tok (+1933 pensamento) latência 43.8 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 Flash passou · 5/5 fields, guidance null
{ "company": "Meridian Robotics", "quarter": "September quarter", "revenue_usd_m": 412, "growth_pct": 11, "guidance": null }
saída 519 tok (+463 pensamento) latência 10.5 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 Flash passou · 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.
saída 5958 tok (+5805 pensamento) latência 88.8 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 Flash 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-flash",
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-flash",
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-flash",
"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-flash",
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-flash")
.addUserMessage("Summarize this diff")
.reasoningEffort(ReasoningEffort.MEDIUM)
.build());
System.out.println(resp.choices().get(0).message().content().orElse(""));Sobre o Qwen3.8 Flash
- Ele se baseia em uma nova arquitetura que a equipe Qwen chama de prévia experimental do que vai sustentar o Qwen4: um modelo Mixture-of-Experts com 125 bilhões de parâmetros e 6 bilhões ativos por token, além de 51 bilhões de parâmetros de embeddings de n-gramas, combinando camadas Gated DeltaNet com uma nova Qwen Sparse Attention que, segundo a Alibaba, reduz a latência em entradas longas.
- A versão de pesos abertos dessa arquitetura é o Qwen3.8-Flash-Next; o modelo hospedado é descrito como sua versão de produção, com contexto de 1M de tokens ativado por padrão e as ferramentas integradas da Alibaba.
- Ele aceita texto, imagens e vídeo e retorna texto, com até 131.072 tokens de saída.
- O raciocínio é híbrido e vem ativado por padrão: enable_thinking o desliga por requisição, thinking_budget define um teto, e o rastro volta em reasoning_content e é cobrado como saída.
- Ele também está na lista de preserve_thinking da Alibaba, então um agente pode levar o raciocínio anterior para turnos seguintes em vez de refazê-lo.
- Chamada de funções, saída estruturada, conclusão por prefixo, busca na web e cache de contexto estão listados; inferência em lote não.
- O próprio guia de escolha de modelos da Alibaba o aponta como a forma de reduzir custos em relação ao Qwen3.7 Plus mantendo capacidades semelhantes.
- Os preços são mais simples que os do Qwen3.7 Flash anterior, que cobrava em três faixas de tamanho de contexto: o Qwen3.8 Flash tem uma tarifa única em toda a janela, igual para chamadas com e sem raciocínio, e os acertos de cache custam cerca de um décimo da entrada padrão, seja o cache criado automática ou explicitamente.
- A Synthorai o oferece pelo endpoint de chat completions compatível com a OpenAI.
Perguntas frequentes
A API do Qwen3.8 Flash é gratuita para testar?
Sim. Contas novas recebem 10 chamadas de teste e até $1 em créditos gratuitos, sem precisar de cartão. A $0.15/M de tokens de entrada, só esse crédito já cobre cerca de 833 requisições de ~8K tokens ao Qwen3.8 Flash.
Em que o Qwen3.8 Flash é melhor?
MoE de 125 bilhões de parâmetros, 6 bilhões ativos por token; entrada de texto, imagem e vídeo, até 131K de saída; tarifa única em todo o contexto de 1M. 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 Flash?
Na Synthorai, o Qwen3.8 Flash custa $0.15 por milhão de tokens de entrada e $0.47 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.016/M.
O Qwen3.8 Flash 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.016/M, contra $0.15/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 Flash?
Aponte seu SDK da OpenAI existente para base_url="https://synthorai.io/v1", defina model="qwen3.8-flash" 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.