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
Prezzi per lunghezza in ingresso
L’intera richiesta usa la tariffa della fascia di lunghezza in ingresso. Prezzi in USD per milione di token.
| Token in ingresso | Input | Output | Input (modalità ragionamento) |
|---|
Benchmark
Dati pubblicati dai provider: Alibaba (Qwen) Anthropic ByteDance DeepSeek Google MiniMax Moonshot OpenAI Tencent Z.ai
Il prezzo a confronto
Dove si colloca il prezzo tra 76 modelli confrontabili
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 provider) | 1.000.000 |
|---|---|
| Output massimo (specifica del provider) | 131.072 |
Prompt caching
| Modalità | automatico + esplicito |
|---|---|
| Prefisso min. | 1.024 |
| Durata | esplicita: 5 min, si azzera a ogni hit |
| Costo di scrittura | 1.25x |
Ragionamento
| Parametro del provider | enable_thinking + thinking_budget + preserve_thinking |
|---|---|
| Valori accettati | enable_thinking true · false; thinking_budget in tokens; preserve_thinking true · false |
| Valore di default | 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 parametri esposti dal gateway: vale la mappatura del provider indicata 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 delle istruzioni (esattamente tre frasi: si contano), adattamento al destinatario (registro da CFO) e lo scarto di fatturazione dovuto al ragionamento nascosto, che i contatori di token qui sotto mettono in luce.
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 (si può eseguire), quanto è densa la spiegazione e quanti token servono per un compito circoscritto.
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), tentazione di allucinare (il testo dice espressamente che la guidance non viene comunicata) e differenze tra i percorsi 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 con OpenAI: cambi base_url e 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 bisogno di carta. A $0.15/M per i token di input, quel credito basta da solo per circa 833 richieste da ~8K token a 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», ripreso dalle note di rilascio ufficiali del provider.
Quanto costa Qwen3.8 Flash?
Su Synthorai Qwen3.8 Flash costa $0.15 per milione di token di input e $0.47 per milione di token di output: è il prezzo di listino del provider, senza sovrapprezzo di piattaforma. I token di input letti dalla cache costano $0.016/M.
Qual è la finestra di contesto di Qwen3.8 Flash?
Qwen3.8 Flash ha una finestra di contesto di 984K token su Synthorai. Una singola risposta può arrivare a 131,072 token.
Qwen3.8 Flash supporta il prompt caching?
Sì: il caching automatico è attivo di default, e una modalità esplicita permette di scegliere cosa mettere in cache. I token di input letti dalla cache costano $0.016/M, contro $0.15/M senza cache; per andare in cache un prompt deve avere un prefisso stabile di 1,024 token (TTL esplicita: 5 min, si azzera a ogni hit). Guida al prompt caching →
Come ottengo l'accesso a Qwen3.8 Flash?
Fai puntare l'SDK OpenAI che usi già a base_url="https://synthorai.io/v1", imposta model="qwen3.8-flash" e hai finito: una sola chiave API vale per tutti i modelli del gateway.
Modelli correlati
Confronta
Le specifiche e i benchmark dei fornitori rimandano alle rispettive fonti. Il supporto del gateway descrive l’implementazione di Synthorai. Gli esempi archiviati sono singole richieste e non garantiscono le prestazioni generali del modello. I prezzi provengono dal servizio pubblico o dalla sua istantanea usata durante la compilazione.