DeepSeek V4 Pro (0813) vs MiniMax M3
Cuál usar y cuándo — veredicto seleccionado, no una tabla de benchmarks
Ambos comparten un contexto de 1,000,000 tokens y cubren chat, código, razonamiento y herramientas, por lo que la diferencia está en el precio y las entradas: minimax-m3 cuesta $0.3 de entrada y $1.2 de salida frente a $1.32 y $3.96 para deepseek-v4-pro-0813, haciendo que el modelo de DeepSeek tenga 4.4x la tarifa de entrada y 3.3x la de salida. Elige minimax-m3 para trabajo económico en alto volumen, para entrada de imágenes o video, para su mayor salida máxima de 524288 tokens, o cuando desees el razonamiento desactivado. Elige deepseek-v4-pro-0813 cuando desees específicamente el modelo más reciente de solo texto de 2026-08-13 y puedas absorber la lista de precios más alta.
Precios
| DeepSeek V4 Pro (0813) | MiniMax M3 | Δ | |
|---|---|---|---|
| Entrada / 1M tokens | $1.32 | $0.3 | 4.4× |
| Salida / 1M tokens | $3.96 | $1.2 | 3.3× |
| Lectura de caché / 1M tokens | $0.132 | $0.06 | 2.2× |
| Escritura en caché | sin cargo por separado | sin cargo por separado | — |
Tarifas del catálogo en vivo en el momento de la compilación; la página de cada modelo incluye la ficha actualizada.
Dónde se sitúan — precio de entrada por 1M de tokens en todos los 63 modelos de chat en esta unidad de facturación (escala logarítmica)
Capacidades
| DeepSeek V4 Pro (0813) | MiniMax M3 | |
|---|---|---|
| Uso de herramientas | sí | sí |
| Control de pensamiento | siempre activo | configurable |
| Salida estructurada | sí | — |
| Caché de prompt | implícito (automático) | implícito (automático) |
| Tiempo de vida de la caché | no fixed TTL (evicted when unused) | no publicado |
| Prefijo mínimo en caché | no publicado | 512 tokens |
Especificaciones
| DeepSeek V4 Pro (0813) | MiniMax M3 | |
|---|---|---|
| Modalidades de entrada | texto | texto imagen vídeo |
| Modalidades de salida | texto | texto |
| Lanzamiento | 2026-08-13 | 2026-06-01 |
| Ventana de contexto | 1M | 1M |
| Salida máxima | 393K | 524K |
| Parámetro de pensamiento | reasoning_effort |
|
| Valores aceptados | reasoning_effort
| thinking.type
reasoning_split
|
| Predeterminado | — | adaptive: thinking on, with the model deciding when extra reasoning helps |
Las especificaciones se transcriben de la documentación de cada proveedor; si un proveedor no publica una fila, se omite en lugar de inferirse. Fuentes completas: DeepSeek V4 Pro (0813) · MiniMax M3
Un prompt, ambos modelos — medido a través del gateway
DeepSeek V4 Pro (0813) superado · 3 sentences
Enabling reasoning causes the model to generate a hidden chain-of-thought with many additional tokens before producing the final answer, which sharply increases compute consumption per request. Those extra reasoning tokens are billed at the same or higher rates, so total usage doubled even though the volume of final outputs stayed similar. We can control this by adjusting reasoning effort, setting token limits, or routing only complex requests through reasoning mode.
salida 308 tok (+226 pensamiento) latencia 5.1 s
MiniMax M3 superado · 3 sentences
Reasoning-enabled models deliberately produce extensive internal "chain-of-thought" tokens before answering, often consuming 5–10x more tokens per query than a standard model. Because LLM providers bill per token for both that reasoning trace and the final response, your cost-per-query rises proportionally—and that multiplier is the primary driver of the doubled bill. The right response isn't to disable reasoning, but to route only genuinely complex queries to it while keeping routine traffic on the cheaper standard tier, which typically recovers 60–80% of the cost without sacrificing quality where it matters.
salida 665 tok (+548 pensamiento) latencia 5.7 s
Seguimiento de la instrucción (exactamente tres frases — contables), adaptación a la audiencia (registro de CFO), y la brecha de facturación por pensamiento oculto que los medidores de tokens de abajo dejan ver.
DeepSeek V4 Pro (0813) superado · 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 `cur` was initialized to `0` and only counted adjacent matching pairs, so a run of length `n` produced `n - 1` (or `0` for a single element) instead of `n`. The code also reset to `0` on a change, when the new run should start at length `1`. Initializing `cur` and `best` to `1` fixes both the single-element case and runs ending at the last index.
salida 1315 tok (+1130 pensamiento) latencia 16.9 s
MiniMax M3 superado · 8/8 cases
The bug is in the loop bound: `range(1, len(xs))` iterates from index 1 up to but not including `len(xs) - 1`... wait, actually it goes up to `len(xs) - 1`, so the last index is included. The real problems are two: 1. **Starting `best` and `cur` at 0** and iterating from index 1 means a single-element list (`len(xs) == 1`) never enters the loop, so the function returns `0` instead of `1`. The fix is to either seed `best = cur = 1` when `xs` is non-empty, or include index 0 in the loop logic. 2. **Missing the final run**: the function only updates `best` *inside* the loop when it finds a continuation. If the longest run ends at the very last element, the loop body never gets to compare it after the increment — actually it does, but only if the run is longer than the previous `best`. […]
salida 464 tok latencia 7.9 s
Si el arreglo es realmente correcto (ejecutable), la densidad de la explicación, y la eficiencia en tokens sobre una tarea acotada.
DeepSeek V4 Pro (0813) superado · 5/5 fields, guidance null
{"company":"Meridian Robotics","quarter":"September quarter","revenue_usd_m":412,"growth_pct":11.0,"guidance":null}
salida 2155 tok (+2121 pensamiento) latencia 26.0 s
MiniMax M3 superado · 5/5 fields, guidance null
```json { "company": "Meridian Robotics", "quarter": "September quarter", "revenue_usd_m": 412, "growth_pct": 11, "guidance": null } ```
salida 2212 tok (+2161 pensamiento) latencia 23.3 s
Obediencia al esquema (sin campos inventados), presión de alucinación (guidance se retiene explícitamente), y diferencias en la ruta de salida estructurada.
DeepSeek V4 Pro (0813) superado · 121 words, 0 banned, 1 question
Introducing cross-provider prompt caching in our API gateway. Send a prompt once, and the gateway stores its computed prefix across Anthropic, OpenAI, and other LLM providers. Subsequent requests with the same prompt hit the cache, cutting latency and token costs while keeping outputs consistent across routing decisions and provider failovers. Teams can route identical prompts between providers without reprocessing shared context or lengthy system instructions. How much could you save on repeated prompt prefixes? The cache respects provider-specific key formats, handles TTLs automatically, and works with streaming and batch requests. Enable it with one configuration flag—no changes to your application code. Available today on all plans. Monitor cache hit rates, token savings, and provider-specific performance metrics in the live dashboard.
salida 2845 tok (+2694 pensamiento) latencia 25.5 s
MiniMax M3 superado · 120 words, 0 banned, 1 question
Introducing PromptCache, our new API gateway feature that caches prompts across multiple LLM providers. Developers can store prompt-completion pairs centrally, reducing redundant inference calls and lowering costs without sacrificing quality. How will your workflow change when repeated requests resolve instantly from a shared cache layer? The gateway intercepts outgoing requests, checks for matching prompt fingerprints, and serves previously generated completions when available, falling back to the original provider on misses. Compatible with OpenAI, Anthropic, Cohere, and custom endpoints, PromptCache integrates with existing routing rules and supports TTL, versioning, and per-tenant namespaces. Teams now gain predictable latency, reduced token spend, and improved throughput during traffic spikes today. […]
salida 3256 tok (+2892 pensamiento) latencia 21.5 s
Obediencia a las restricciones (presupuesto de palabras, lista de palabras prohibidas, la única pregunta), huella de estilo, y control de la longitud.
Cambia entre ellos con una línea
Ambos IDs están en cada pestaña a continuación — el par de líneas resaltadas es la única edición. Mismo endpoint, misma clave, misma estructura de solicitud.
from openai import OpenAI
client = OpenAI(
base_url="https://synthorai.io/v1",
api_key="sk-syn-...",
)
resp = client.chat.completions.create(
model="deepseek-v4-pro-0813",
# model="minimax-m3", # 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: "deepseek-v4-pro-0813",
// model: "minimax-m3", // 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": "deepseek-v4-pro-0813",
# "model": "minimax-m3", # 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: "deepseek-v4-pro-0813",
// Model: "minimax-m3", // 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("deepseek-v4-pro-0813")
// .model("minimax-m3") // 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, DeepSeek V4 Pro (0813) o MiniMax M3?
MiniMax M3 es más barato en entrada / 1m tokens ($0.3 vs $1.32, con una diferencia de 4.4×). Otras filas pueden indicar lo contrario — la tabla anterior muestra la ficha completa, y el costo real depende de su combinación.
¿Puedo hacer pruebas A/B de DeepSeek V4 Pro (0813) frente a MiniMax M3 sin dos integraciones?
Sí. Ambos se sirven a través del mismo endpoint compatible con OpenAI con una clave API — el cambio es una modificación de una línea en la cadena del modelo, por lo que puede enrutar una fracción del tráfico a cada uno y comparar las facturas directamente.
¿Admiten DeepSeek V4 Pro (0813) y MiniMax M3 caché de prompts?
Sí — ambos cobran las lecturas en caché por debajo de su tarifa de entrada, por lo que las cargas de trabajo con prefijo caliente cuestan menos de lo que sugieren las tarifas de lista. Las filas exactas de lectura en caché están en la tabla de precios de arriba.