DeepSeek-V4-Flash: specs, size, benchmarks and how to run it

Size decides how you run it. In the serving recipe for vLLM, a widely used open-source inference server, one copy of the model fills four large GPUs. So test it through an API first. Size a GPU server only when your traffic justifies one.

How big is DeepSeek-V4-Flash, and what does it take to run it? The question comes up when a team likes the benchmarks and must choose between an API and its own GPUs.

How DeepSeek-V4-Flash works and what it is best for

DeepSeek-V4-Flash is a mixture-of-experts model. Its 284 billion parameters are split into many experts, small sub-networks, and for each token a router picks a few of them. Only about 13 billion parameters run per token, so each token costs about as much compute as a 13-billion-parameter model.

Two more design choices shape how you use it. A compressed form of attention, the step where the model looks back at earlier text, keeps long inputs manageable, so one request can carry up to 1M tokens. And the model can reason before it answers: you choose low, high or max effort, or switch reasoning off on our API.

That makes it best for coding and agent work. DeepSeek tests this release on agents working in a command line, in code repositories, with tools and on security tasks, and it scores higher there than both earlier V4 previews. It also suits jobs that read a lot of text at once, such as long documents or large codebases, at a low price per token. It reads text only, so image input needs a different model.

DeepSeek-V4-Flash specs: parameters, size and context

DeepSeek publishes the parameter counts, context length and precision on its model card.

FP4 and FP8 are number formats that store each weight in 4 or 8 bits. DeepSeek stores the expert weights in FP4 and most other parameters in FP8. That is how 284 billion parameters fit in about 167 GB on disk for 0731, against about 160 GB for the April preview. Those extra 7 GB are a draft module, a small network that guesses the next few tokens. The full model then checks all the guesses in one step, which saves time when they are right. The technique is called speculative decoding.

DeepSeek-V4-Flash-0731 is the official release and supersedes the preview. DeepSeek built it like its DSpark checkpoint, the variant that carries this draft module, so the module ships inside the 0731 download.

Why a 1M-token context stays usable

Attention is the step where the model looks back at earlier tokens. The KV cache (key-value cache) is the record it keeps for that, one entry per token it has read. In standard attention this record grows with every token of context. DeepSeek-V4 stores it in compressed form, using two designs it calls Compressed Sparse Attention (CSA) and Heavily Compressed Attention (HCA). DeepSeek's technical report gives the effect only for its larger V4-Pro: at 1M tokens, it needs 10% of the KV cache of the older DeepSeek-V3.2. Flash uses the same design, but DeepSeek gives no number for Flash itself. Our guide to long-context inference GPU requirements covers the memory side.

How much GPU memory DeepSeek-V4-Flash needs

Every one of the 284 billion parameters must sit in GPU memory, because the router can pick any expert for the next token. Only the compute per token follows the 13 billion active ones. Our guide to mixture-of-experts VRAM requirements explains the split between memory and compute.

The memory left after the weights holds the KV cache and the working memory of the serving software:

memory left = number of GPUs × memory per GPU − 167 GB of weights

The table applies that to NVIDIA's data-centre GPUs (H100, H200, B200 and B300), with the memory sizes from our machine types page. It is a calculated example for the weights only.

The example leaves out the KV cache your context length needs and how many requests a setup serves at once. A single B300 holds the weights on paper, with 121 GB left for everything else. Test it at your context length before you rely on it.

The vLLM recipe is the tested reference. It spreads the experts of one copy across four GPUs, called expert parallelism, on H200, B200 or B300. It then runs more copies side by side on the same server, called data parallelism. The recipe also cites a reported 0731 deployment on 8×H100 that served requests with vLLM 0.26.0. It lists NVIDIA's GB10, the chip in DGX Spark with 128 GB of memory, as too small on its own. DeepSeek's own example uses one server with four NVIDIA GB300 GPUs.

The reasoning level also changes the server setup. Think Max is DeepSeek's name for the max reasoning effort, and it writes long reasoning traces. So the server's maximum model length, the longest request it accepts, has to be at least 384K tokens.

Our GPU virtual machines come with 1, 2, 4 or 8 GPUs per instance, subject to availability. A four-GPU H200, B200 or B300 instance matches the recipe's layout for one copy.

DeepSeek-V4-Flash benchmarks for coding and agents

DeepSeek-V4-Flash-0731 scores higher than both the Flash preview and the V4-Pro preview on every benchmark in DeepSeek's release table. DeepSeek ran the code-agent tasks at max reasoning effort, with sampling settings of temperature 1.0 and top_p 0.95. These are vendor-reported numbers, so test on your own tasks. Terminal Bench tests agent work in a command line, DeepSWE and NL2Repo in code repositories, Toolathlon-Verified with tools and Cybergym on security tasks.

For reasoning, the latest published scores are the preview's. In Max mode the preview reached 91.6 on LiveCodeBench, a coding benchmark, and 94.8 on the February 2026 HMMT maths competition set. Both scores are Pass@1, the share of problems solved on the first attempt. The 0731 weights support three reasoning effort levels: low, high and max. On our API, "none" switches reasoning off entirely.

Open models now trail the best closed models by about four months, on Epoch AI's data insight of 29 May 2026. So European teams no longer need a US API for near-frontier quality, and we serve these open models in Europe.

How to run DeepSeek-V4-Flash through our API

Lyceum is a sovereign European AI inference provider for open-source models. Our serverless models run in Paris and Finland, and our model page lists DeepSeek V4 Flash as EU-hosted. Prompts and outputs are processed, not stored, and never used for training. You call the model with the OpenAI SDK. Set the base URL to https://api.lyceum.technology/openai/v1, pass your Lyceum API key as a Bearer token and use the model id deepseek/deepseek-v4-flash-0731.

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["LYCEUM_API_KEY"],
    base_url="https://api.lyceum.technology/openai/v1",
)

stream = client.chat.completions.create(
    model="deepseek/deepseek-v4-flash-0731",
    messages=[
        {"role": "system", "content": "You are a senior backend engineer."},
        {"role": "user", "content": "Explain why this test fails: [paste output]"},
    ],
    max_tokens=8192,
    stream=True,
)
for chunk in stream:
    if chunk.choices and chunk.choices[0].delta.content:
        print(chunk.choices[0].delta.content, end="")

The same request from a terminal:

curl https://api.lyceum.technology/openai/v1/chat/completions \
  -H "Authorization: Bearer $LYCEUM_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model": "deepseek/deepseek-v4-flash-0731", "messages": [{"role": "user", "content": "Hello!"}], "reasoning_effort": "none"}'

Four behaviours of our serverless inference endpoint matter in production:

• Reasoning is on by default. The curl call above shows the switch, reasoning_effort: "none".
• The trace can arrive in message.reasoning_content or message.reasoning, depending on which serving engine on our side handles the request. Read both fields.
• A request gets up to 300 seconds of generation time. Set stream: true for long outputs.
• Tool calling uses the OpenAI tools format, but tool_choice: "required" is not enforced. Check message.tool_calls and fall back when it is empty, and verify function calling before you switch.

Time to first token (TTFT) is the wait before the first output token arrives. Our status checks measured a median TTFT of 286 ms and 86 tokens per second for short requests. The window is the 7 days to 20 October 2026. Both figures count reasoning tokens, so with reasoning on, the first token can be reasoning rather than answer text. Our status page shows availability live. Long prompts reach the first token later, as our guide on time to first token explains.

The model reads text only, and image requests return a 400 error. If you code with Claude Code, our Claude Code setup guide covers the endpoint configuration.

What one DeepSeek-V4-Flash agent call costs

The per-token rates in the specs table are our list prices of 20 October 2026, with no base fee. Prompt caching means a repeated prompt start is billed at a lower rate, and it is automatic. When requests share an identical start, that part is billed at the cached-input rate.

Take one hypothetical coding-agent call. It sends 200,000 input tokens and gets 4,000 tokens back. The first 150,000 input tokens are a prefix, a prompt start identical to the previous call:

cost = fresh input × $0.25/1M + cached input × $0.06/1M + output × $0.30/1M
     = 50,000 × $0.25/1M + 150,000 × $0.06/1M + 4,000 × $0.30/1M
     = $0.0125 + $0.0090 + $0.0012
     = $0.0227

A cache hit means the provider found that prefix stored and billed it at the cached rate. Without the hit, the same call costs $0.0512: $0.0500 for input plus $0.0012 for output. The token counts are an example, not a measurement. A cache hit is best effort, so read usage.prompt_tokens_details.cached_tokens to confirm it; the field is missing on a miss. Our pricing page lists the rates for every model.

When to self-host DeepSeek-V4-Flash and when to call the API

Call the API while your traffic comes and goes. Per-token billing follows usage, so quiet hours cost nothing and no server needs sizing. Our guide to pay-per-token vs dedicated GPU inference shows where the break-even sits.

Move to reserved capacity when traffic is steady all day. A dedicated endpoint runs a Hugging Face model on replicas, copies of the model on GPUs reserved for you. It sits behind the same OpenAI-compatible API, with commitment pricing agreed per contract. Running the weights yourself on GPU virtual machines makes sense when you need your own serving stack.

For harder knowledge work, DeepSeek V4 Pro 0813 costs $2.00 input, $0.50 cached and $4.00 output per 1M tokens; see our DeepSeek-V4-Pro article. For image input, DeepSeek V4.1 Flash costs $0.50 input and $1.50 output; see our V4.1 Flash specs article. Our guide on where to run DeepSeek in Europe compares the two V4 models.

Start with one real agent trace on the API and compare its cached-token share and latency with your target. Send your first request from our DeepSeek V4 Flash model page.