Qwen3.8 Flash è il livello veloce ed economico della generazione Qwen3.8 di Alibaba, rilasciato il 27 agosto 2026.
- Input
- testo immagine video $0.15/M
- Output
- testo $0.47/M
- Lettura cache
- $0.016/M
- Contesto
- 984K
- vs GPT-4o
- ~97% più economico
Benchmark
Dati pubblicati dai fornitori: Alibaba (Qwen) Anthropic ByteDance DeepSeek Google MiniMax Moonshot OpenAI Tencent Z.ai
Il prezzo nel contesto
Posizione del prezzo tra 66 modelli comparabili
La barra mostra dove si colloca il prezzo di questo modello tra tutti i modelli dello stesso tipo su Synthorai. Alle due estremità sono indicati il più economico e il più caro. Sono tariffe base; gli sconti per batch, regione e scrittura in cache sono nella pagina dei prezzi.
Specifiche e limiti
Token
| Finestra di contesto (specifica del fornitore) | 1.000.000 |
|---|---|
| Output massimo (specifica del vendor) | 131.072 |
Caching prompt
| Modalità | automatico + esplicito |
|---|---|
| Prefisso min. | 1.024 |
| Durata | esplicita: 5 min, si azzera a ogni hit |
| Costo di scrittura | 1.25x |
Ragionamento
| Parametro del fornitore | enable_thinking + thinking_budget + preserve_thinking |
|---|---|
| Valori accettati | enable_thinking true · false; thinking_budget in tokens; preserve_thinking true · false |
| Valore predefinito | 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 applicato se la richiesta non specifica nulla |
| Disattivabile | Sì |
| Comportamento del ragionamento | 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. |
| Parametro | reasoning_effort |
| Valori | minimal · low · medium · high la superficie parametri del gateway - vale la mappatura del fornitore sopra |
Modello
| Modalità | testo + immagine + video → testo |
|---|---|
| Parametri | 125B totali · 6B attivi 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
Un solo prompt, misurato attraverso il gateway
Qwen3.8 Flash superato · 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.
out 330 tok (+262 ragionamento) latenza 8.9 s
Rispetto dell'istruzione (esattamente tre frasi - contabili), adattamento al pubblico (registro da CFO), e il divario di fatturazione del pensiero nascosto che i contatori di token qui sotto rivelano.
Qwen3.8 Flash superato · 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.
out 2123 tok (+1933 ragionamento) latenza 43.8 s
Se la correzione è davvero giusta (eseguibile), la densità della spiegazione, e l'efficienza in token su un compito delimitato.
Qwen3.8 Flash superato · 5/5 fields, guidance null
{ "company": "Meridian Robotics", "quarter": "September quarter", "revenue_usd_m": 412, "growth_pct": 11, "guidance": null }
out 519 tok (+463 ragionamento) latenza 10.5 s
Aderenza allo schema (nessun campo inventato), pressione di allucinazione (guidance è esplicitamente sospesa), e differenze nel percorso di output strutturato.
Qwen3.8 Flash superato · 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.
out 5958 tok (+5805 ragionamento) latenza 88.8 s
Rispetto dei vincoli (budget di parole, elenco di parole vietate, l'unica domanda), impronta stilistica, e controllo della lunghezza.
Usa Qwen3.8 Flash in 30 secondi
Compatibile OpenAI: cambia la base_url, tieni il tuo 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(""));Informazioni su Qwen3.8 Flash
- Si basa su una nuova architettura che il team Qwen definisce un'anteprima sperimentale di ciò su cui poggerà Qwen4: un modello Mixture-of-Experts con 125 miliardi di parametri, di cui 6 miliardi attivi per token, più 51 miliardi di parametri di embedding n-gram, che affianca strati Gated DeltaNet a una nuova Qwen Sparse Attention che, secondo Alibaba, riduce la latenza sugli input lunghi.
- La versione a pesi aperti di questa architettura è Qwen3.8-Flash-Next; il modello ospitato ne è descritto come la build di produzione, con un contesto di 1M di token attivo per impostazione predefinita e gli strumenti integrati di Alibaba.
- Accetta testo, immagini e video e restituisce testo, con fino a 131.072 token di output.
- Il ragionamento è ibrido e attivo di default: enable_thinking lo disattiva per singola richiesta, thinking_budget lo limita, e la traccia torna in reasoning_content ed è fatturata come output.
- Compare anche nell'elenco preserve_thinking di Alibaba, quindi un agente può portare il ragionamento precedente nei turni successivi invece di ricavarlo di nuovo.
- Sono elencati function calling, output strutturato, completamento da prefisso, ricerca web e cache del contesto; l'inferenza batch no.
- La guida alla scelta dei modelli di Alibaba lo indica come il modo per ridurre i costi rispetto a Qwen3.7 Plus mantenendo capacità simili.
- I prezzi sono più semplici di quelli del precedente Qwen3.7 Flash, che fatturava in tre fasce di lunghezza del contesto: Qwen3.8 Flash ha un'unica tariffa su tutta la finestra, uguale per chiamate con e senza ragionamento, e gli hit di cache costano circa un decimo dell'input standard, sia che la cache sia stata creata automaticamente sia esplicitamente.
- Synthorai lo offre tramite l'endpoint chat completions compatibile con OpenAI.
FAQ
L'API di Qwen3.8 Flash si può provare gratis?
Sì: i nuovi account ricevono 10 chiamate di prova e fino a $1 di credito gratuito, senza carta richiesta. A $0.15/M token in input, quel credito da solo copre circa 833 richieste da ~8K token verso Qwen3.8 Flash.
In cosa eccelle Qwen3.8 Flash?
MoE da 125 miliardi di parametri, 6 miliardi attivi per token; input di testo, immagini e video, fino a 131K di output; un'unica tariffa su tutto il contesto da 1M. Il quadro completo è nella sezione «Informazioni», tratto dalle note di rilascio ufficiali del vendor.
Quanto costa Qwen3.8 Flash?
Su Synthorai, Qwen3.8 Flash costa $0.15 per milione di token in input e $0.47 per milione di token in output: il prezzo di listino del provider, senza ricarico della piattaforma. I token di input in cache si fatturano a $0.016/M.
Qwen3.8 Flash supporta il caching dei prompt?
Sì: il caching automatico è attivo di default, con una modalità esplicita per risparmi garantiti. I token di input in cache si fatturano a $0.016/M contro $0.15/M senza cache; per andare in cache i prompt richiedono un prefisso stabile di 1,024 token (TTL esplicita: 5 min, si azzera a ogni hit). Guida al caching dei prompt →
Come ottengo l'accesso a Qwen3.8 Flash?
Punta il tuo SDK OpenAI esistente a base_url="https://synthorai.io/v1", imposta model="qwen3.8-flash" e hai finito: una sola chiave API copre tutti i modelli del gateway.
Modelli correlati
Confronta
Ogni valore di questa pagina è trascritto dalla documentazione del fornitore, collegata sopra, e riporta la data in cui è stato verificato. I prezzi sono confrontati sull'intero catalogo; i valori di specifica che i fornitori definiscono in modo diverso sono mostrati indicando la differenza anziché messi a grafico. Nulla qui è misurato da noi e nulla è valutato con un punteggio.