DeepSeek V4.1 Flash GPU requirements: 510 GB at FP4+FP8

Memory by format

How much VRAM DeepSeek V4.1 Flash needs, format by format.

Weights are parameters × bytes per parameter, except the native FP4+FP8 row, which is the size of the published checkpoint. The KV cache of this architecture is not estimated (see below), so only the weights are shown.

GPUs by memory

Format	Weights	Cheapest node, 32K
BF16Published weights, fine-tuning	1.53 TB	8× MI325X · $8.72/h
FP8Hopper, Ada, Blackwell, MI300	763 GB	4× MI325X · $4.36/h
FP4+FP8 (native)AWQ, GPTQ, GGUF Q4 · the published checkpoint	510 GB	8× RTX PRO 6000 Blackwell · $1.52/h

Arithmetic on published facts, not a benchmark.

The serving engine adds its own buffers, and an 8-bit KV cache halves the context columns. We keep 10% of a node's memory free when we say a model fits. Speed is a separate question: it follows memory bandwidth and, for a mixture of experts, the active parameters.

Where it runs

GPUs that run DeepSeek V4.1 Flash, cheapest first.

For each format, the smallest node of each GPU model that holds the weights and a 32K context, sorted by spot price. One row per GPU model; larger nodes of the same GPU work too.

All prices

Format	GPU	GPU memory	Spot	On-demand	730 h spot	Action
FP4+FP8 (native)	8× RTX PRO 6000 BlackwellBlackwell · 510 GB needed	768 GB	$1.52	$3.12	$1,109.60	Deploy
FP4+FP8 (native)	4× B200 SXMBlackwell · 510 GB needed	720 GB	$6.76	$9.96	$4,934.80	Deploy
FP8	4× MI325XCDNA 3 · 763 GB needed	1024 GB	$4.36	$6.36	$3,182.80	Deploy
FP8	8× H200 NVLHopper · 763 GB needed	1128 GB	$5.52	$7.92	$4,029.60	Deploy
FP8	8× H200 SXMHopper · 763 GB needed	1128 GB	$6.00	$8.72	$4,380.00	Deploy
FP8	8× MI300XCDNA 3 · 763 GB needed	1536 GB	$7.92	$11.60	$5,781.60	Deploy
BF16	8× MI325XCDNA 3 · 1.53 TB needed	2048 GB	$8.72	$12.72	$6,365.60	Deploy

Spot capacity can be reclaimed with a 2-minute notice; for a live endpoint, use on-demand. How spot works · serving a language model.

Context and the KV cache

What a long context costs in memory.

Compressed Sparse Attention 2 (CSA2): each layer runs in Full, Reindex or Reuse mode and shares the main KV and indexer keys with other layers; its cache is a small fraction of a standard model's and we publish no estimate we cannot check.

No cache estimate for this architecture.

The cache is a small fraction of a standard model's at the same length, but its size depends on details we cannot check from the published configuration, so we do not print a number. The node recommendations on this page are sized on the weights plus the 10% margin.

Serving several users

KV cache

Every concurrent request keeps its own cache, so memory for context grows with users × context length. A server batching 8 requests of 32K needs eight times the single-sequence figure.

Paged attention (vLLM, SGLang) allocates the cache in blocks as requests grow, so a node holds more short requests than the worst case suggests.

Model facts

DeepSeek V4.1 Flash, as published.

Developer: DeepSeekMultimodal mixture of experts: 552B backbone plus 196B of Engram memory, 8B or 16B activated per token (model card), 1M-token context
Parameters: 552B total, active count not published763B in the published checkpoint (embedding tables, prediction or vision modules included); memory figures use this count
Architecture: Mixture of experts, 40 layersCompressed Sparse Attention 2 (CSA2): each layer runs in Full, Reindex or Reuse mode and shares the main KV and indexer keys with other layers; its cache is a small fraction of a standard model's and we publish no estimate we cannot check
Context window: 1,048,576 tokensAs set in the published configuration
Published format: FP4+FP8, 510 GB checkpoint
Licence: MIT
Released: 10 September 2026
Source: deepseek-ai/DeepSeek-V4.1-Flashconfig.json read 26 October 2026

Serve it with vLLM

template: vLLM

On 8× RTX PRO 6000 Blackwell, from the instance terminal:

terminal

$ vllm serve deepseek-ai/DeepSeek-V4.1-Flash \
    --tensor-parallel-size 8 \
    --max-model-len 32768

Very recent architectures need a recent vLLM; the model card gives the minimum version and any extra flags.

Related models

Other models of a similar size.

All 64 models

DeepSeek V3.2 671B · 37B active · 343 GB at 4-bit $0.48/h

V3 architecture with DeepSeek Sparse Attention

DeepSeek R1 671B · 37B active · 342 GB at 4-bit $0.48/h

Reasoning model, the R1-0528 checkpoint

DeepSeek V4 Flash 284B · 13B active · 167 GB at FP4+FP8 $0.38/h

Fast DeepSeek V4 mixture of experts with a 1M-token context, the 0731 update

DeepSeek V4 Pro 1.6T · 49B active · 865 GB at FP4+FP8 $8.72/h

The large DeepSeek V4 model, 1M-token context

FAQ

DeepSeek V4.1 Flash on a GPU — the questions that come up

How much VRAM does DeepSeek V4.1 Flash need?

For the weights alone: 1.53 TB at BF16, 763 GB at FP8 and 510 GB at FP4+FP8. Its attention scheme keeps a much smaller cache than a standard model and we do not publish an estimate we cannot check; keep a margin for the cache on top of the weights.

Can DeepSeek V4.1 Flash run on a single GPU?

One RTX 4090 (24 GB): no. One RTX 5090 (32 GB): no. One H100 SXM (80 GB): no. One H200 SXM (141 GB): no. One B200 SXM (180 GB): no. Those answers assume a 32K context and the widest format that still fits.

What is the cheapest way to run DeepSeek V4.1 Flash?

Here, 8× RTX PRO 6000 Blackwell at FP4+FP8 (native): $1.52 per hour on spot and $3.12 on-demand, billed per minute — $1,109.60 for a 730-hour month on spot. That node has 768 GB of GPU memory for the 510 GB this setup needs.

Does DeepSeek V4.1 Flash need less memory because only a few experts are active?

No. A mixture-of-experts model routes each token through a few experts, but every expert has to be resident in GPU memory, so the memory bill follows the 552B total. What the active experts change is the work per token: generation reads far less of the weights each step than a dense model of the same size would, which is why it is fast for its size.

Which format should I run it in?

DeepSeek V4.1 Flash is published in FP4+FP8, a 510 GB checkpoint — the format its developers serve it in, so it is the safe default. BF16 keeps the published weights untouched and is the format for fine-tuning. FP8 halves the memory and runs in hardware on Hopper, Ada, Blackwell and MI300-class GPUs. 4-bit quantisation (AWQ, GPTQ, GGUF) quarters it, at a quality cost that is larger on small models than on big ones; check it against your own evaluation before relying on it.

How do I deploy it?

Pick the node in the table above and launch it with the vLLM template; the model downloads from Hugging Face (deepseek-ai/DeepSeek-V4.1-Flash) on first start. Spread the weights over the node with --tensor-parallel-size equal to the GPU count, and set --max-model-len to the context you need. New architectures need a recent vLLM: check the model card for the minimum version.

Sizing another model? GPU requirements for 64 open models · serving a language model · fine-tuning.

Get started

DeepSeek V4.1 Flash on 8× RTX PRO 6000 Blackwell for $1.52 an hour.

Launch the node with the vLLM template, point it at deepseek-ai/DeepSeek-V4.1-Flash, stop it when you are done. Prepaid, billed by the minute.

Deploy 8× RTX PRO 6000 All open models

Billed per minute from the moment the instance is reachable. Minimum credit $30, no subscription.