DeepSeek V4.1 Flash Hardware Requirements: GPU, Memory, and Deployment (2026)

DeepSeek V4.1 Flash is the first Flash model that needs a whole node. Here’s the memory math, the configs that actually work as of mid-September, and what to do if you don’t have eight GPUs.

The checkpoint is 510 GB across 48 shards. That one number decides most of what follows. DeepSeek V4 Flash was 166.9 GB and ran on two H200s; its replacement is three times the size, and the day-one serving recipes from vLLM, SGLang, and NVIDIA all start at four Blackwell-class GPUs or eight H200s. The model’s clever memory tricks are real, but they’re on the cache side. The weights are the problem.

The numbers that matter

Two things in that table explain the rest of this post. First, the model ships pre-quantized: dense layers at FP8, experts at FP4. The easy compression is already spent, exactly as it was with V4 Flash, so there’s no “just quantize it” path to a smaller footprint. Second, 183 GiB of the 510 is the Engram component, an n-gram memory table that sits alongside the transformer. That’s the piece SGLang can move to host RAM, which is the one route to running this on fewer GPUs, covered below.

Why two GPUs became eight

V4 Flash’s whole self-hosting appeal was that a 166.9 GB checkpoint fit two H200s (282 GB) with room for cache. V4.1 Flash at 510 GB doesn’t fit four H200s (564 GB) once you account for activations, the CUDA graph, and the spec-decode draft, which is why the vLLM recipe puts the floor at about 614 GB. The KV cache doesn’t rescue it: at 890 bytes per token, even a million-token context costs under a gigabyte, so cache was never going to be the constraint. The weights are.

The MoE rule holds as always. Eight billion active parameters on prefill make the model cheap to run per token, and Artificial Analysis measures it at 214 output tokens per second on DeepSeek’s own API. But all 552B backbone parameters plus the Engram tables have to sit in memory. Low active count saves compute, not VRAM.

Configurations that work

As of September 15, these are the configs with published recipes. “Verified” means the maintainers of the recipe ran it and marked it; “recipe present” means the config is documented but the verification pass isn’t finished.

The practical reading: on NVIDIA, the floor is a 4-GPU Blackwell tray or an 8-GPU H200 node. On Hopper, eight H200s is the only documented path; eight H100s clears the weights on paper with almost nothing left, and no recipe author has put their name on it. A 4x B200 node (768 GB) is the smallest Blackwell config with a recipe, and if you’re renting, that’s the config to price first.

The Engram host-table option

SGLang ships a preview flag, SGLANG_ENABLE_DSV41_ENGRAM_HOST_TABLE=1, that keeps the 183 GiB Engram table in CPU memory instead of GPU memory. With it, the GPU-resident footprint drops to roughly 330 GB, which puts a 4x H200 pod (564 GB) back in range on paper. The cost is host RAM (you need well over 200 GB free on the node) and a lookup path that crosses PCIe on every step, with a latency penalty the SGLang team hasn’t quantified publicly yet. Treat it as the way to get the model up on a smaller box for evaluation, not as a production config until someone publishes numbers. If it works out, it’s the most interesting development in this model’s self-hosting story, because it would restore something close to the V4 Flash entry point.

Engines, versions, and the launch command

vLLM 0.30.0 or later, with the deepseekv41-flash-0909 tagged image on NVIDIA and the ROCm nightly on AMD. SGLang’s day-zero build supports it with attention and MoE backends auto-selected from the checkpoint; the docs say not to override them manually because you’ll get a slower fallback. NVIDIA Dynamo has a recipe on top of SGLang. DeepSeek’s own inference/ folder on Hugging Face is a reference implementation for reading, not serving.

The vLLM shape on an 8x H200 node:

vllm serve deepseek-ai/DeepSeek-V4.1-Flash \
  --tensor-parallel-size 8 \
  --max-model-len 262144 \
  --language-model-only \
  --speculative-config "$DSPARK_CONFIG"

Three flags to know. --language-model-only is in every day-one recipe: the checkpoint accepts images, but none of the published serving configs enable multimodal input yet, so text-only is what’s tested. --speculative-config turns on DSpark; the recipes use five draft tokens per step, and it’s where most of the decode speed comes from. --max-model-len is yours to set; the KV cache is so small that the 1M window costs almost nothing in memory, but prefill time on a million tokens is still prefill time. Recommended sampling from the model card is temperature 1.0, top_p 0.95 or 1.0, and a generous max_tokens (256K or more) because the model reasons at length.

Copy the exact --speculative-config JSON from the vLLM recipe for your engine version rather than from a blog post; the field names are tied to the build. The vLLM vs SGLang comparison covers the engine choice for either.

Can you run it on a workstation or a Mac?

No, not yet. A 24 GB or 32 GB card can’t hold the checkpoint, no GGUF or MLX conversion existed at publication, and a 512 GB Mac Studio is under the 614 GB floor even before the Engram host-table trick is considered (and that trick is a Linux-and-SGLang feature). This is the model where DeepSeek’s Flash line stopped being a desktop possibility. If you need a DeepSeek model on one machine, the V4 Flash weights are still on Hugging Face under MIT and still run on two H200s; they’re just no longer the current model.

The route most teams should take

Run the math before you rent a node. On DeepSeek’s API, V4.1 Flash is $0.15 per million input tokens and $0.60 output off-peak, $0.30 and $1.20 at peak, with cache hits at $0.003. An 8-GPU H200 node has to serve a very large sustained volume before it beats those rates, and V4 Flash’s two-GPU economics, the thing that made self-hosting DeepSeek a default, are gone with this release.

Self-host V4.1 Flash if you need data to stay on your hardware, if you’re running at a scale where the peak-hour doubling on DeepSeek’s API hurts, or if you want to fine-tune. Otherwise call it. Yotta AI Gateway carries DeepSeek V4 Flash and V4 Pro today at flat per-token rates with no peak windows; V4.1 Flash is not in the catalog as of this writing, and this post will note it when it is. For the self-hosted side, 8-GPU H200 and B300 nodes by the hour cover the configs in the table, and the V4 Flash and Pro deployment tutorial is the closest starting point until a V4.1-specific one is published.

Frequently asked questions

How much VRAM does DeepSeek V4.1 Flash need? About 614 GB of GPU memory with headroom, per the vLLM recipe, for a 510 GB checkpoint. In practice that means a 4-GPU Blackwell tray (GB200, GB300, B200, B300) or an 8-GPU H200 node.

Can DeepSeek V4.1 Flash run on 8x H100? Eight 80 GB H100s give 640 GB, which clears the 614 GB floor by 26 GB. No published recipe uses that config, and the margin is too thin to plan production on. Use H200s or Blackwell.

Can it run on 4x H200? Not with the default configuration; 564 GB is under the floor. SGLang’s preview Engram host-table option moves 183 GiB of the model to CPU RAM and may make 4x H200 workable, but it’s unbenchmarked.

Is there a GGUF or Ollama version? Not at publication. The checkpoint already ships at FP8 and FP4, so there’s little room for further quantization, and no desktop-class conversion had appeared.

How much bigger is V4.1 Flash than V4 Flash? Three times on disk: 510 GB against 166.9 GB. V4 Flash ran on two H200s; V4.1 Flash needs a node. The KV cache went the other way, to about a quarter of V4 Flash’s per token.

Which engines support DeepSeek V4.1 Flash? vLLM 0.30.0 and later, SGLang’s day-zero build, and NVIDIA Dynamo on top of SGLang, on NVIDIA Hopper and Blackwell and AMD MI350X/MI355X. Day-one recipes serve text only.

What does it cost on the API instead? $0.15 in / $0.60 out per million tokens off-peak on DeepSeek’s API, double at peak, $0.003 for cache hits. The full breakdown is in the DeepSeek V4.1 Flash pricing and specs post.

How does the hardware compare to GLM 5.3 Flash? GLM 5.3 Flash’s checkpoint is about 306 GiB and also needs an 8-GPU node, with more headroom on 8x H100. DeepSeek V4.1 Flash vs GLM 5.3 Flash compares the two node-scale models on price, speed, and benchmarks.

Bottom line

DeepSeek V4.1 Flash needs about 614 GB of GPU memory, which means a four-GPU Blackwell tray or an eight-GPU H200 node, and there is no desktop or two-GPU path today. The one thing to watch is SGLang’s Engram host-table option, which could bring 4x H200 back into play. Until it’s benchmarked, the honest advice is the same as for any node-scale model at a Flash-scale API price: self-host for data control or extreme volume, and call the API for everything else. When you do rent the node, 8-GPU H200 and B300 nodes by the hour are the configs in the recipes, and Yotta AI Gateway has the rest of the DeepSeek lineup behind one key in the meantime.