DeepSeek V4 Flash (0731) vs DeepSeek V4 Pro (0813)
Qual usar, quando — veredito curado, não uma tabela de benchmark
Esses dois irmãos da DeepSeek são configurados identicamente no papel: ambos possuem uma janela de contexto de 1000000 tokens, 393216 tokens de saída máxima, apenas entrada/saída de texto e as mesmas flags de chat, código, raciocínio e ferramentas. A única diferença real na ficha técnica é a tabela de preços, onde o deepseek-v4-pro-0813 custa cerca de 4.29 vezes mais em cada nível ($1.32 vs $0.308 na entrada, $3.96 vs $0.924 na saída, $0.132 vs $0.0308 em leituras de cache). Tenha o deepseek-v4-flash-0731 como padrão para trabalho em volume e recorra ao nível Pro 0813 apenas se suas próprias avaliações justificarem o sobrepreço.
Preços
| DeepSeek V4 Flash (0731) | DeepSeek V4 Pro (0813) | Δ | |
|---|---|---|---|
| Entrada / 1M tokens | $0.308 | $1.32 | 0.23× |
| Saída / 1M tokens | $0.924 | $3.96 | 0.23× |
| Leitura de cache / 1M tokens | $0.0308 | $0.132 | 0.23× |
| Escrita de cache | sem cobrança separada | sem cobrança separada | — |
Tarifas do catálogo em tempo real no momento do build; a página de cada modelo contém o cartão atual.
Onde eles se posicionam — preço de entrada por 1M tokens entre todos os 63 modelos de chat nesta unidade de cobrança (escala logarítmica)
Capacidades
| DeepSeek V4 Flash (0731) | DeepSeek V4 Pro (0813) | |
|---|---|---|
| Uso de ferramentas | sim | sim |
| Controle de raciocínio | sim — o fornecedor não publica o controle | sempre ativo |
| Saída estruturada | sim | sim |
| Cache de prompt | implícito (automático) | implícito (automático) |
| Tempo de vida do cache | no fixed TTL (evicted when unused) | no fixed TTL (evicted when unused) |
| Prefixo mínimo em cache | não publicado | não publicado |
Especificações
| DeepSeek V4 Flash (0731) | DeepSeek V4 Pro (0813) | |
|---|---|---|
| Modalidades de entrada | texto | texto |
| Modalidades de saída | texto | texto |
| Lançamento | 2026-07-31 | 2026-08-13 |
| Janela de contexto | 1M | 1M |
| Saída máxima | 393K | 393K |
| Parâmetro de raciocínio | — | reasoning_effort |
| Valores aceitos | — | reasoning_effort
|
As especificações são transcritas da documentação de cada fornecedor; uma linha que um fornecedor não publica é omitida em vez de ser inferida. Fontes completas: DeepSeek V4 Flash (0731) · DeepSeek V4 Pro (0813)
Um prompt, ambos os modelos — medidos pelo gateway
DeepSeek V4 Flash (0731) passou · 3 sentences
Enabling reasoning mode prompts the model to generate extensive internal chain-of-thought tokens before answering, often multiplying total token output per query by several times. This directly inflates costs because we are billed per token, and these reasoning tokens are processed at a premium compute tier that carries a higher price per million tokens. However, this spend buys measurably higher accuracy and fewer failed calls, so we are tracking it against specific error-reduction KPIs to ensure the ROI justifies the increase.
saída 365 tok (+266 pensamento) latência 5.1 s
DeepSeek V4 Pro (0813) passou · 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.
saída 308 tok (+226 pensamento) latência 5.1 s
Cumprimento da instrução (exatamente três frases — contáveis), ajuste ao público (registro de CFO), e a lacuna de cobrança do pensamento oculto que os medidores de tokens abaixo expõem.
DeepSeek V4 Flash (0731) 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 best = max(best, cur) else: cur = 1 return best ``` The original bug stems from initializing `cur` to 0 and only incrementing it when adjacent elements are equal, which counts the number of *equal transitions* rather than the actual run length—so every run of length L is reported as L−1, and a single‑element run (with no transitions) yields 0. Moreover, because `best` is updated only inside the equality branch, it never accounts for a run that ends at the last element if that run is longer than any previously seen (though the real issue remains the off‑by‑one). […]
saída 1268 tok (+1016 pensamento) latência 14.0 s
DeepSeek V4 Pro (0813) 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 `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.
saída 1315 tok (+1130 pensamento) latência 16.9 s
Se a correção é de fato certa (executável), a densidade da explicação, e a eficiência em tokens numa tarefa delimitada.
DeepSeek V4 Flash (0731) passou · 5/5 fields, guidance null
{ "company": "Meridian Robotics", "quarter": "Q3", "revenue_usd_m": 412, "growth_pct": null, "guidance": null }
saída 1119 tok (+1072 pensamento) latência 12.3 s
DeepSeek V4 Pro (0813) passou · 5/5 fields, guidance null
{"company":"Meridian Robotics","quarter":"September quarter","revenue_usd_m":412,"growth_pct":11.0,"guidance":null}
saída 2155 tok (+2121 pensamento) latência 26.0 s
Obediência ao esquema (sem campos inventados), pressão de alucinação (guidance é explicitamente retida), e diferenças no caminho de saída estruturada.
DeepSeek V4 Flash (0731) falhou · 141 words, 0 banned, 1 question
**Introducing Prompt Cache for API Gateway** We are pleased to announce Prompt Cache, a new feature that stores and reuses identical prompt prefixes across all connected LLM providers. By automatically recognizing repeated requests, this cache reduces token consumption and lowers latency without altering your application logic. Whether you use OpenAI, Anthropic, or open-source models, the cache operates transparently, ensuring consistent behavior while cutting costs. Developers can configure cache TTL and scoping rules via a simple API call, giving you precise control over data freshness and privacy. This feature also minimizes redundant upstream calls, freeing provider rate limits for more critical workloads. Start caching today through the dashboard or CLI, and watch your operational expenses drop significantly. […]
saída 254 tok (+80 pensamento) latência 4.4 s
DeepSeek V4 Pro (0813) passou · 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.
saída 2845 tok (+2694 pensamento) latência 25.5 s
Obediência às restrições (orçamento de palavras, lista de palavras proibidas, a única pergunta), impressão digital de estilo, e controle de comprimento.
Alterne entre eles com uma linha
Ambos os IDs estão em todas as abas abaixo — o par de linhas destacado é a única edição. Mesmo endpoint, mesma chave, mesmo formato de requisição.
from openai import OpenAI
client = OpenAI(
base_url="https://synthorai.io/v1",
api_key="sk-syn-...",
)
resp = client.chat.completions.create(
model="deepseek-v4-flash-0731",
# model="deepseek-v4-pro-0813", # descomente esta linha, comente a linha acima
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-flash-0731",
// model: "deepseek-v4-pro-0813", // descomente esta linha, comente a linha acima
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-flash-0731",
# "model": "deepseek-v4-pro-0813", # descomente esta linha, comente a linha acima
"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-flash-0731",
// Model: "deepseek-v4-pro-0813", // descomente esta linha, comente a linha acima
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-flash-0731")
// .model("deepseek-v4-pro-0813") // descomente esta linha, comente a linha acima
.addUserMessage("Summarize this diff")
.reasoningEffort(ReasoningEffort.MEDIUM)
.build());
System.out.println(resp.choices().get(0).message().content().orElse(""));FAQ
Qual é mais barato, DeepSeek V4 Flash (0731) ou DeepSeek V4 Pro (0813)?
DeepSeek V4 Flash (0731) é mais barato em entrada / 1m tokens ($0.308 vs $1.32, com 4.3× de diferença). Outras linhas podem apontar para o outro lado — a tabela acima traz o quadro completo, e o custo real depende do seu mix.
Posso fazer um teste A/B de DeepSeek V4 Flash (0731) contra DeepSeek V4 Pro (0813) sem duas integrações?
Sim. Ambos são servidos pelo mesmo endpoint compatível com OpenAI com uma única chave de API — a troca é uma alteração de uma linha na string do modelo, de modo que você pode rotear uma fração do tráfego para cada um e comparar as faturas diretamente.
DeepSeek V4 Flash (0731) e DeepSeek V4 Pro (0813) suportam prompt caching?
Sim — ambos cobram leituras em cache abaixo da sua taxa de entrada, então cargas de trabalho com warm-prefix custam menos do que as taxas listadas sugerem. As linhas exatas de leitura em cache estão na tabela de preços acima.