Running DeepSeek V4 locally is a straightforward process for V4-Flash and a serious infrastructure commitment for V4-Pro. Both variants ship as open weights under the MIT license, but their memory footprints place them in entirely different hardware tiers.
DeepSeek V4 is a Mixture-of-Experts family released in April 2026. Both variants are text-only, support a 1M-token context window, and have weights available on Hugging Face under the deepseek-ai organization.
This guide covers the real VRAM numbers for both models, explains which GPU generations support which precision formats, and walks through a serving setup for V4-Flash on Hopper and Blackwell hardware.
Takeaways
- V4-Flash needs roughly 175 GB of VRAM at the native checkpoint, dropping to 131 GB at 3-bit GGUF.
- V4-Pro requires Blackwell hardware or a multi-node H200 cluster.
- The biggest case for self-hosting is data privacy, not cost: the V4-Flash API is cheap enough that renting GPUs rarely wins on price.
DeepSeek V4 Features: Flash vs Pro
DeepSeek V4 is a Mixture-of-Experts (MoE) family with two variants:
- V4-Flash at 284B total parameters (13B active/token)
- V4-Pro at 1.6T total parameters (49B active/token).
The instruct weights for both models ship in a mixed FP4/FP8 format:
- FP4 precision for MoE expert parameters
- FP8 precision for attention, normalization, and router parameters.
Both variants use a hybrid attention design combining Compressed Sparse Attention (CSA) and Heavily Compressed Attention (HCA), which is what makes 1M-token context practical without a prohibitive KV cache footprint. This compressed attention uses roughly 7% of DeepSeek V3.2's KV footprint at equivalent context length.
MoE models require VRAM for every expert, not just the active ones. With V4-Flash, 13B parameters fire per token, but all 284B weights must fit in memory. MoE reduces compute per token, not memory.
DeepSeek V4 Model Variants: Flash, Pro, 0731, and DSpark
The DeepSeek V4 family has grown past the two models it launched with, and the naming can be confusing. The original April 2026 V4-Flash and V4-Pro repositories are now the preview generation.
The current official checkpoints carry release dates:
- DeepSeek-V4-Flash-0731 shipped July 31, 2026
- DeepSeek-V4-Pro-0813 shipped August 13, 2026.
The 0731 Flash keeps the 284B total and 13B active parameter counts but is substantially stronger on agentic tasks than the preview, and it ships with a DSpark speculative-decoding module for faster generation.
DeepSeek-V4.1-Flash is the newest branch, adding native vision input to the Flash line. However, the text-only 0731 checkpoint remains the stable target for local deployment today.
| Variant | Total / Active Params | Released | What's Different | Self-Host Viable? |
|---|---|---|---|---|
| V4-Flash (preview) | 284B / 13B | Apr 24, 2026 | First Flash release; FP4/FP8 mixed weights. | Yes. |
| V4-Flash-0731 | 284B / 13B | Jul 31, 2026 | Official Flash release; stronger agentic performance; ships DSpark speculative decoding. | Yes. |
| V4-Flash-DSpark | 284B / 13B | 2026 | Not new weights: Flash plus a fused speculative-decoding draft head. | Yes. |
| V4-Pro-0813 | 1.6T / 49B | Aug 13, 2026 | Flagship; frontier-class on code and reasoning. Requires Blackwell for native FP4 or multi-node H200. | No |
| V4.1-Flash | Flash-class | Sep 2026 | Newer Flash branch with native vision and multimodal input. | Emerging |
DeepSeek V4-Flash VRAM Requirements
DeepSeek V4-Flash needs about 175 GB of VRAM at the native FP4/FP8 checkpoint, dropping to roughly 131 GB at 3-bit GGUF and 167 GB at 4-bit. At native precision, that fits on a single B200 (180GB) with headroom for the full 1M-token KV cache.
That VRAM budget breaks down into:
- 158 GB for the native FP4/FP8 weights
- Around 10 GB for the KV cache at 1M context
- A few GB of runtime overhead.
The VRAM requirement changes significantly with quantization. Unsloth's community GGUFs compress the model substantially, making smaller multi-GPU configs viable at the cost of some quality.
| Precision | Approx. Weight Size | Total VRAM1 | Practical Config |
|---|---|---|---|
| 3-bit (UD-Q3_K_XL) | 129 GB | ~131 GB | 1x B200 |
| 4-bit (UD-Q4_K_XL) | 155 GB | ~167 GB | 1x B200 |
| 8-bit / lossless (UD-Q8_K_XL) | 162 GB | ~174 GB | 1x B200 |
| Native FP4/FP8 (official instruct) | 167 GB | ~180 GB | 1x B200 (native FP4+FP8)2 |
| 1 KV cache estimate at full 1M-token context.2On Hopper, use the FP8-only build (sgl-project/DeepSeek-V4-Flash-FP8, ~294 GB), which requires 8x H100 (640 GB) for usable serving. | |||
How to Run DeepSeek V4-Flash Locally
The recommended serving stack for V4-Flash is vLLM, which shipped day-0 support for V4's CSA+HCA attention architecture. SGLang is the alternative with equivalent official support. Both expose an OpenAI-compatible endpoint.
The hardware path splits by GPU generation:
- Blackwell (B200, B300): run the native FP4+FP8 instruct checkpoint (
deepseek-ai/DeepSeek-V4-Flash-0731). A single B200 (180-192 GB) fits the full model at native precision with 1M-token context. - Hopper (H100, H200): H100 has no FP4 tensor-core support, so run the FP8-only build (
sgl-project/DeepSeek-V4-Flash-FP8, ~294 GB). 8x H100 (640 GB) is the recommended minimum for usable serving.
Serving V4-Flash on H100 With vLLM
V4-Flash requires vLLM 0.20.0 or later, plus the --kv-cache-dtype fp8_ds_mla and --tokenizer-mode deepseek_v4 flags. Both are required, and the model will not serve correctly without them.
# Install vLLM (0.20.0+ required)
pip install "vllm>=0.20.0"
# Serve the FP8 build across 8x H100
vllm serve sgl-project/DeepSeek-V4-Flash-FP8 \
--tensor-parallel-size 8 \
--enable-expert-parallel \
--kv-cache-dtype fp8_ds_mla \
--trust-remote-code \
--tokenizer-mode deepseek_v4
The server speaks the OpenAI chat-completions format. Point Cursor, Claude Code, or any OpenAI SDK client at http://<your-instance-ip>:8000/v1 with a single base-URL change. See current H100 instance pricing and availability on Thunder Compute.
DeepSeek V4-Pro Hardware Requirements
V4-Pro's native FP4/FP8 instruct checkpoint weighs approximately 865 GB. V4-Pro requires Blackwell hardware (B200 or B300) for native FP4 execution at single-node scale.
Community GGUF quantizations can compress V4-Pro enough to fit on smaller configs, but at a meaningful quality cost. Unlike V4-Flash, where quantization buys significant memory savings, V4-Pro's QAT-trained FP4 experts mean sub-Q4 compression degrades output quality sharply.
| Precision | Approx. Weight Size | Total VRAM1 | Minimum Config |
|---|---|---|---|
| Q2_K-XL (community GGUF) | ~498 GB | ~520 GB | 4x H200 GPU-only |
| Q4_K_M-XL (community GGUF) | ~828 GB | ~870 GB | 8x H200 141GB (1,128 GB) |
| Native FP4/FP8 (official instruct) | ~865 GB | ~900 GB+ | 8x B200 (Blackwell, single node) |
| 1 KV cache estimate at 128K context. Full 1M-token context adds substantial headroom on top of these figures. | |||
DeepSeek V4 Pricing: Self-Hosting vs API
Self-hosting beats the API only past a sustained usage threshold. V4-Flash API pricing starts at $0.14/1M input tokens and $0.28/1M output tokens, though DeepSeek introduced peak and off-peak tiers in August 2026.
V4-Pro is $0.435/1M input and $0.87/1M output at the current promotional rate. At those rates, light or bursty workloads are almost always cheaper via the API, and operational overhead eats the savings fast at small scale.
At $25.60/hr for an 8x H100 setup, the math rarely beats the V4-Flash API on cost alone. The case for self-hosting is data privacy: if your data cannot leave your infrastructure, the API is not an option regardless of price.
| Scenario | Recommended Path | Why |
|---|---|---|
| Light or occasional use | DeepSeek API | $0.14/$0.28 per 1M tokens, zero ops overhead. |
| Privacy-sensitive data | Self-host V4-Flash | Nothing leaves your infrastructure. |
| Fine-tuning or research | Self-host on base checkpoints | MIT license covers commercial redistribution. |
Last Thoughts on Running DeepSeek V4 Locally
V4-Flash is self-hostable for teams with a data privacy requirement or a workload that benefits from direct model access. A single B200 covers the native FP4+FP8 build; 8x H100 is the recommended minimum on Hopper via the FP8-only build. The MIT license means you can modify, fine-tune, and redistribute the weights without restriction. For V4-Pro or teams without a privacy constraint, the API is the right call.
Frequently Asked Questions
How Much VRAM Does DeepSeek V4-Flash Need?
V4-Flash needs ~175 GB at the native FP4/FP8 checkpoint, which fits on a single B200 (180-192 GB) with headroom for the full 1M-token KV cache. On Hopper, the FP8-only build is ~294 GB and requires 8x H100 (640 GB) for usable serving.
Can You Run DeepSeek V4 Pro Locally?
Only with a large cluster. V4-Pro requires Blackwell hardware (B200 or B300) for native FP4 execution at single-node scale, or a multi-node H200 setup on the Hopper FP8 path. The minimum realistic deployment is 8x H200 SXM5 (1,128 GB) on a single node.
What Is the Difference Between V4-Flash-0731 and the Preview Checkpoint?
V4-Flash-0731 is the official July 31, 2026 release and supersedes the April preview. It keeps the 284B total and 13B active parameter counts but is notably stronger on agentic tasks and ships with a DSpark speculative-decoding module for faster generation.
Is Self-Hosting DeepSeek V4 Cheaper Than the API?
Rarely on cost alone. V4-Flash API pricing is $0.14/$0.28 per 1M tokens, which is cheap enough that renting GPUs almost never wins on price. The real case for self-hosting is data privacy: if your data cannot leave your infrastructure, the API is not an option regardless of cost.