Jeff Bruchado
Back to blog

DeepSeek V4.1 Flash: The Open Weights Model That Costs 40x Less and Ties With Opus 5

Hello HaWkers, on September 10, 2026 DeepSeek published V4.1-Flash with the weights on Hugging Face under an MIT license. It is not a preview, it is not a closed API with a waiting list: it is the whole file, 552 billion parameters in the backbone, available to download and run on your own infrastructure. And the official API price starts at US$ 0.003 per million input tokens on a cache hit.

Have you ever stopped to calculate how much your agent spends per month on output tokens? If the answer scared you, this article is for you. We are going to look at the model's real architecture, the full pricing table with the peak hour catch, the benchmarks DeepSeek published and, most importantly, how to decide whether it is worth migrating your use case or staying where you are.

What DeepSeek Actually Released

V4.1-Flash is a sparse, multimodal Mixture-of-Experts. The number in the headlines is the backbone: 552 billion parameters. But what matters for inference cost is how much of that lights up per token, and here is the trick in the architecture: the model activates 8 billion parameters when processing input and 16 billion when generating output.

That asymmetric split is deliberate. Loading context is cheap, generating text is expensive, so DeepSeek sized each stage accordingly. The result is a model that behaves like a giant in terms of quality and like a small model on the compute bill per token.

The context specs match the ambition:

  • Context window: 1,048,576 tokens (exactly 1M, not rounded up for marketing)
  • Max output: 131,072 tokens in a single response
  • Compressed KV cache: cache memory dropped to roughly a quarter of the previous Flash generation
  • License: MIT, weights published on Hugging Face
  • API name: deepseek-flash, with a concurrency limit of 2,500 requests

That compressed KV cache is the detail that matters most for anyone running agents. In an agentic workload you resend the same history dozens of times per task; if the cache takes a quarter of the memory, many more simultaneous sessions fit on the same GPU.

The Pricing Table and the Peak Hour Catch

This is where the conversation gets interesting, and where most of the comparisons floating around are wrong. DeepSeek charges two different prices depending on the time of day.

Off-peak:

Item Price per 1M tokens
Input with cache hit US$ 0.003
Input without cache US$ 0.15
Output US$ 0.60

During peak hours: exactly double each value above.

The peak windows run from 01:00 to 04:00 and from 06:00 to 10:00 UTC, on weekdays only. Everything else, including nights, weekends and holidays, falls into the cheap tier. If you are in the Americas that is great news: DeepSeek's peak lands in the middle of the night and early morning in your time zone, so most of your business hours are already off-peak.

Comparing Against Whoever Is on Top

For scale, here are the public prices of the direct competitors:

Model Input Cached input Output
DeepSeek V4.1 Flash (off-peak) US$ 0.15 US$ 0.003 US$ 0.60
DeepSeek V4.1 Flash (peak) US$ 0.30 US$ 0.006 US$ 1.20
GPT-5.6 Sol US$ 4.00 US$ 0.40 US$ 20.00
Claude Opus 5 US$ 5.00 US$ 0.50 US$ 25.00

V4.1-Flash output during peak hours is around 20 times cheaper than Claude Opus 5. Off-peak, it goes past 40 times. On cached input the gap is even more violent: US$ 0.003 against US$ 0.50.

The honest caveat is worth writing down: the comparison is not perfectly symmetric, because DeepSeek's lowest price depends on you running outside the peak window. If your traffic is synchronous and follows European business hours, a relevant share of your calls will land at double the price. Even so, even at double, the distance to the frontier models is still an order of magnitude.

The Benchmarks: What the Numbers Say

DeepSeek published V4.1-Flash with 74.2 points on DeepSWE v1.1, against 74.0 for Claude Opus 5 and 73.0 for GPT-5.6 Sol. That is a technical tie with the top of the table on an agentic software engineering benchmark.

OpenDesign published an independent evaluation and arrived at a number that sums up the pitch well: V4.1-Flash reached 98% of GPT-6 Astra's quality score for 1.4% of the cost, on the company's day-to-day set of design requests.

Before you swap out your entire stack, two caveats that are worth more than any headline:

  1. The DeepSWE benchmarks were run by DeepSeek itself. That does not invalidate them, but it puts the burden of verification on your lap. Run your own evaluation set before deciding.
  2. Tying on a benchmark is not tying on your use case. A 0.2 point difference in an aggregate hides enormous variation by task type.

If you want a broader picture of how the models behave in the daily life of someone writing code, I already broke that down in the comparison of the best AI coding assistants in 2026.

Calling the Model in Practice

DeepSeek's API follows the Chat Completions format, so any compatible client works without adaptation. The model name is deepseek-flash:

// Direct call with fetch, no SDK at all.
// The API accepts the Chat Completions format, so the payload is the same
// one you already use with other providers.
const resposta = await fetch('https://api.deepseek.com/chat/completions', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    Authorization: `Bearer ${process.env.DEEPSEEK_API_KEY}`
  },
  body: JSON.stringify({
    model: 'deepseek-flash',
    messages: [
      { role: 'system', content: 'You answer in English, in an objective way.' },
      { role: 'user', content: 'Explain what a sparse Mixture-of-Experts is.' }
    ],
    // With 131,072 output tokens available, capping here is a
    // cost guardrail, not a limitation of the model.
    max_tokens: 2048
  })
})

const dados = await resposta.json()
console.log(dados.choices[0].message.content)

The thing to watch is max_tokens. The model is allowed to generate up to 131,072 tokens in a single response. Without an explicit ceiling, a badly calibrated agent loop can burn through budget fast even at the low price.

DeepSeek also published deepseek-recipe, a set of Rust libraries with Python bindings. It converts requests in the Messages, Chat Completions and Responses API formats into the internal Conversation format, encodes V4 and V4.1 prompts into token IDs and parses the output back, streaming included. If you are building your own runtime on top of the weights, that is where you start.

Running Locally With the MIT Weights

The MIT license is what separates this release from "a cheap model in the cloud". You can download, serve, modify and use it commercially without asking anyone for permission. The model card documents four deployment paths: Transformers, vLLM, SGLang and Docker.

# Serving with vLLM. The model is big: plan the GPU cluster
# before running this in production.
pip install vllm

vllm serve deepseek-ai/DeepSeek-V4.1-Flash \
  --tensor-parallel-size 8 \
  --max-model-len 1048576 \
  --served-model-name deepseek-flash

# The endpoint comes up Chat Completions compatible at
# http://localhost:8000/v1/chat/completions

Be realistic about the cost of running this at home. A 552B MoE at reduced precision still asks for several accelerators with a lot of memory. For most teams, the official API at US$ 0.60 per million output tokens comes out cheaper than keeping the cluster running. The practical value of the open weights, in the short term, is something else: you stop depending on a single vendor, you can audit the model and you have an exit ready in case the price changes tomorrow.

Calculating the Real Cost of Your Agent

Before migrating, put numbers on paper. This function calculates the cost of a run taking DeepSeek's peak hours into account:

// Prices in dollars per 1 million tokens (off-peak table).
const TABELA_OFF_PEAK = {
  entradaCache: 0.003,
  entradaSemCache: 0.15,
  saida: 0.6
}

// Peak: 01:00-04:00 and 06:00-10:00 UTC, on weekdays only.
function estaEmPico(data = new Date()) {
  const diaDaSemana = data.getUTCDay()
  const ehDiaUtil = diaDaSemana >= 1 && diaDaSemana <= 5
  if (!ehDiaUtil) return false

  const hora = data.getUTCHours()
  return (hora >= 1 && hora < 4) || (hora >= 6 && hora < 10)
}

function calcularCusto({ tokensCache, tokensEntrada, tokensSaida }, data = new Date()) {
  // During peak every value doubles.
  const multiplicador = estaEmPico(data) ? 2 : 1
  const porMilhao = (tokens, preco) => (tokens / 1_000_000) * preco * multiplicador

  return (
    porMilhao(tokensCache, TABELA_OFF_PEAK.entradaCache) +
    porMilhao(tokensEntrada, TABELA_OFF_PEAK.entradaSemCache) +
    porMilhao(tokensSaida, TABELA_OFF_PEAK.saida)
  )
}

// An agent that resends 400 thousand cached context tokens,
// 20 thousand new tokens and generates 8 thousand response tokens.
const custo = calcularCusto({
  tokensCache: 400_000,
  tokensEntrada: 20_000,
  tokensSaida: 8_000
})

console.log(`US$ ${custo.toFixed(5)} per run`)
// Off-peak: around US$ 0.00900 per run.

Run the same math with the Claude Opus 5 table and compare. In scenarios with a lot of cached context, which is exactly the profile of a coding agent, the difference explodes, because DeepSeek's cache hit costs US$ 0.003 against US$ 0.50.

When to Migrate and When to Stay Where You Are

Migrate if

  • Your bottleneck is cost and not the last few percentage points of quality.
  • The workload is asynchronous: batch processing, content generation, classification, data enrichment. You schedule it off-peak and pay the full discount table.
  • You need a giant context. 1M tokens for less than a dollar per million changes which architectures are viable.
  • Vendor independence is a requirement. MIT weights mean nobody shuts your feature down.

Stay where you are if

  • Your product depends on very low, predictable latency, and you have not measured DeepSeek's on your real traffic yet.
  • You have data residency requirements that DeepSeek's infrastructure does not meet, and you do not have the budget to serve the weights yourself.
  • Your stack is already deeply tied to another provider's specific features.

The middle path

The most sensible move for most teams is not swapping everything: it is routing. Send the high volume, low risk tasks to Flash and keep the expensive model for what really demands it. With the API being Chat Completions compatible, that routing is usually a dozen lines:

// Simple router: an expensive task is the only one that goes to the expensive model.
const MODELO_BARATO = { url: 'https://api.deepseek.com', nome: 'deepseek-flash' }
const MODELO_PREMIUM = { url: 'https://api.provedor-caro.com', nome: 'modelo-premium' }

function escolherModelo(tarefa) {
  // A business criterion, not a technical one: what breaks if it comes out wrong?
  const exigeMaximaQualidade =
    tarefa.tipo === 'revisao-final' || tarefa.impactoNoCliente === 'alto'

  return exigeMaximaQualidade ? MODELO_PREMIUM : MODELO_BARATO
}

What This Means For the Market

The pattern DeepSeek has been repeating since V3 is now hard to ignore: deliver frontier quality, publish the weights under a permissive license and charge a fraction of the price. When a model with MIT weights ties with Claude Opus 5 on DeepSWE and costs twenty times less on output, the question stops being "which is the best model" and becomes "how much extra quality do I need, and what does it cost".

For anyone building product, the reading is straightforward: cost per token is no longer the main design constraint. Architectures that used to be too expensive, like reprocessing the entire repository on every pull request, keeping an agent watching logs continuously, or generating five answers and picking the best one, are back on the table.

For the frontier labs, the pressure is obvious. You cannot sustain US$ 25 per million output tokens when an open model at US$ 0.60 ties on an engineering benchmark. Either the quality difference becomes glaring in the cases that matter, or the price comes down.

And for you, today, the practical action is small: take a real task from your system, run it on both models, measure quality and cost. The right answer is in your traffic, not in anyone's chart.

Let's go! 🦅

📚 Want to Keep Up With What Is Coming?

This article covered the DeepSeek V4.1 Flash release, but the ecosystem changes every week and not everything turns into an article here.

On X I share what I am testing, the behind the scenes of my projects and the news that shows up before it becomes a post.

Follow Me There

👉 Follow @jeffbruchado on X

💡 Daily content about development, career and the tools I actually use

Comments (0)

This article has no comments yet 😢. Be the first! 🚀🦅

Add comments