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
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) | 1.000.000 |
|---|---|
| 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 do provedor | enable_thinking + thinking_budget + preserve_thinking |
|---|---|
| Valores aceitos | enable_thinking true · false; thinking_budget in tokens; preserve_thinking true · false |
| Valor padrão | 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 usado quando a requisição não define nada |
| 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 parâmetros expostos pelo gateway; vale o mapeamento do provedor indicado 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 fonte das especificações do modelo ↗
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 raciocínio) latência 8.9 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 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 raciocínio) latência 43.8 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 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 raciocínio) latência 10.5 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 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 raciocínio) latência 88.8 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 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 na seção Sobre o quadro completo, tirado das notas de lançamento do próprio provedor.
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 markup da plataforma. Tokens de entrada em cache são cobrados a $0.016/M.
Qual é a janela de contexto do Qwen3.8 Flash?
O Qwen3.8 Flash tem uma janela de contexto de 984K tokens na Synthorai. Uma única resposta pode ter até 131,072 tokens.
O Qwen3.8 Flash 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.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 o SDK da OpenAI que você já usa 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
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.