Gemini 3.8 Flash vs Qwen3.8 Max
Cuál usar y cuándo
Elige gemini-3.8-flash cuando el volumen de entrada o la amplitud de medios impulsen la factura: admite texto, imagen, audio y video, tiene un contexto de 1048576 tokens y cuesta $0.75 por millón en la entrada y $3.75 en la salida, aproximadamente 2.7x más barato en entrada y 1.6x más barato en salida que qwen3.8-max a $2 y $6. Elige qwen3.8-max cuando necesites respuestas únicas largas, ya que su salida máxima de 131072 es el doble de los 65536 de gemini-3.8-flash, aunque su contexto es ligeramente menor con 983616 y solo acepta texto e imagen. Ambos cubren chat, visión, código, herramientas y razonamiento.
Benchmarks
Publicado por los proveedores: Alibaba (Qwen) Anthropic ByteDance DeepSeek Google MiniMax Moonshot OpenAI Tencent Z.ai
Precios
| Gemini 3.8 Flash | Qwen3.8 Max | Δ | |
|---|---|---|---|
| Entrada / 1M tokens | $0.75 | $2 | 0.38× |
| Salida / 1M tokens | $3.75 | $6 | 0.63× |
| Lectura de caché / 1M tokens | $0.075 | $0.25 | 0.3× |
| Escritura en caché | - | 1.25x | - |
Tarifas tomadas del catálogo en vivo al generar el sitio; la página de cada modelo tiene la ficha de precios actualizada.
Dónde queda cada uno: precio de entrada por 1M de tokens entre los 80 modelos de chat que se facturan en esta unidad (escala logarítmica)
Capacidades
| Gemini 3.8 Flash | Qwen3.8 Max | |
|---|---|---|
| Uso de herramientas | sí | sí |
| Control del razonamiento | sí el proveedor no publica cómo ajustarlo | sí el proveedor no publica cómo ajustarlo |
| Salida estructurada | sí | sí |
| Caché de prompts | implícito + explícito | implícito + explícito |
| Duración de la caché | no publicado | explicit: 5m, reset on hit |
| Prefijo mínimo en caché | 4,096 tokens | 1,024 tokens |
Especificaciones
| Gemini 3.8 Flash | Qwen3.8 Max | |
|---|---|---|
| Modalidades de entrada | texto imagen audio vídeo | texto imagen |
| Modalidades de salida | texto | texto |
| Lanzamiento | 2026-09-02 | 2026-08-03 |
| Corte de conocimiento | 2026-03 | - |
| Ventana de contexto | 1M | 984K |
| Salida máxima | 66K | 131K |
Las especificaciones se transcriben de la documentación de cada proveedor; si un proveedor no publica un dato, la fila se omite en vez de deducirlo. Fuentes completas: Gemini 3.8 Flash · Qwen3.8 Max
Un mismo prompt en los dos modelos, medido a través de la pasarela
Gemini 3.8 Flash superado · 3 sentences
When we enabled reasoning, the model began generating hidden "thinking tokens" to work through logic step-by-step before producing a final answer. Because AI vendors bill for every single token processed—visible or not—this internal deliberation dramatically inflated our billable volume per query. In short, while our total number of user requests remained flat, the cost per transaction doubled to buy higher accuracy on complex tasks.
salida 705 tok (+624 razonamiento) latencia 6.4 s
Qwen3.8 Max superado · 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.
salida 378 tok (+305 razonamiento) latencia 8.6 s
Cumplimiento de la instrucción (exactamente tres frases, se pueden contar), adaptación al público (registro de CFO) y la diferencia de facturación por razonamiento oculto que dejan ver los contadores de tokens de abajo.
Gemini 3.8 Flash superado · 8/8 cases
Here is the corrected function: ```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 best = max(best, cur) else: cur = 1 return best ``` ### Explanation of the Bug The original function counted equal-neighbor transitions rather than the actual items making up each run. Because `cur` started at `0` (and was reset to `0` on mismatches), every run was undercounted by one: single-element lists returned `0` because the loop never executed, and any subsequent run—including those ending at the last index—recorded a count of $N - 1$ instead of $N$. The fix handles empty input upfront, initializes both `cur` and `best` to `1` (since any single element forms a run of length 1), and resets `cur` to `1` whenever a new run begins.
salida 1393 tok (+1149 razonamiento) latencia 10.1 s
Qwen3.8 Max superado · 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.
salida 1616 tok (+1411 razonamiento) latencia 34.7 s
Si la corrección funciona de verdad (se puede ejecutar), lo densa que es la explicación y la eficiencia en tokens en una tarea acotada.
Gemini 3.8 Flash superado · 5/5 fields, guidance null
```json { "company": "Meridian Robotics", "quarter": "September quarter", "revenue_usd_m": 412, "growth_pct": null, "guidance": null } ```
salida 3989 tok (+3932 razonamiento) latencia 30.4 s
Qwen3.8 Max superado · 5/5 fields, guidance null
{ "company": "Meridian Robotics", "quarter": "September quarter", "revenue_usd_m": 412, "growth_pct": 11, "guidance": null }
salida 1199 tok (+1141 razonamiento) latencia 24.4 s
Respeto del esquema (sin campos inventados), tentación de alucinar (la guidance se omite a propósito) y diferencias entre las vías de salida estructurada.
Gemini 3.8 Flash superado · 120 words, 0 banned, 1 question
Why pay multiple model providers for the exact same output? Introducing Universal Prompt Cache, our latest API gateway capability engineered to cut compute expenses and drop inference latency. When your application makes a call, the gateway inspects a central memory layer before routing traffic to external LLMs. If an identical query was previously processed by OpenAI, Anthropic, or Mistral, our gateway returns that response immediately. This shared cache eliminates duplicate token fees and insulates your production apps from vendor rate limits or unexpected downtime. Developers can easily customize expiration settings, enforce strict data privacy controls, and configure invalidation logic across every endpoint. Stop wasting your budget on repeated queries. Enable prompt caching in your dashboard to accelerate your pipeline today.
salida 3833 tok (+3688 razonamiento) latencia 21.8 s
Qwen3.8 Max superado · 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.
salida 2744 tok (+2591 razonamiento) latencia 46.3 s
Respeto de las restricciones (límite de palabras, lista de palabras prohibidas, una única pregunta), sello de estilo y control de la longitud.
Cambia de uno a otro con una sola línea
Los dos ids aparecen en todas las pestañas de abajo; lo único que cambia es el par de líneas resaltadas. El endpoint, la clave y la estructura de la solicitud son los mismos.
from openai import OpenAI
client = OpenAI(
base_url="https://synthorai.io/v1",
api_key="sk-syn-...",
)
resp = client.chat.completions.create(
model="gemini-3.8-flash",
# model="qwen3.8-max", # descomenta esta línea, comenta la de arriba
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: "gemini-3.8-flash",
// model: "qwen3.8-max", // descomenta esta línea, comenta la de arriba
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": "gemini-3.8-flash",
# "model": "qwen3.8-max", # descomenta esta línea, comenta la de arriba
"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: "gemini-3.8-flash",
// Model: "qwen3.8-max", // descomenta esta línea, comenta la de arriba
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("gemini-3.8-flash")
// .model("qwen3.8-max") // descomenta esta línea, comenta la de arriba
.addUserMessage("Summarize this diff")
.reasoningEffort(ReasoningEffort.MEDIUM)
.build());
System.out.println(resp.choices().get(0).message().content().orElse(""));Preguntas frecuentes
¿Cuál es más barato, Gemini 3.8 Flash o Qwen3.8 Max?
Gemini 3.8 Flash es más barato en Entrada / 1M tokens ($0.75 frente a $2, una diferencia de 2.7×). En otras filas puede ser al revés: la tabla de arriba recoge todas las tarifas, y el coste real depende de tu combinación de uso.
¿Puedo hacer pruebas A/B de Gemini 3.8 Flash frente a Qwen3.8 Max sin dos integraciones?
Sí. Los dos se sirven desde el mismo endpoint compatible con OpenAI y con una sola clave API. Para cambiar de uno a otro basta con tocar una línea, el nombre del modelo, así que puedes mandar una parte del tráfico a cada uno y comparar directamente las facturas.
¿Admiten Gemini 3.8 Flash y Qwen3.8 Max caché de prompts?
Sí. Los dos cobran las lecturas de caché por debajo de su tarifa de entrada, así que las cargas de trabajo que reutilizan un prefijo ya cacheado cuestan menos de lo que sugieren los precios de lista. Las tarifas exactas de lectura de caché están en la tabla de precios de arriba.