TL;DR: DeepSeek V4-Pro (1.6T total / 49B active) is too large for any consumer setup — use the API. V4-Flash (284B / 13B active) is the local option, but the honest quant math puts it at 103–172GB, so 4× RTX 4090 (96GB) can’t hold it. A real local build means 2× RTX PRO 6000 or a used-3090 farm. At $0.14 per million input tokens, the API wins for almost everyone.

	V4-Flash (local)	V4-Flash (API)	V4-Pro (API only)
Best for	Privacy/offline batch	Everyday use	Frontier coding/agents
Params (total / active)	284B / 13B	284B / 13B	1.6T / 49B
Cost	$26k+ hardware	$0.14 / $0.28 per M	$1.74 / $3.48 per M
The catch	160–172GB at Q4	Not private	No local path exists

Honest take: Run V4-Flash locally only if privacy or offline use is non-negotiable and you have $26k for two RTX PRO 6000 cards — otherwise the API at fourteen cents per million tokens is the correct answer, and V4-Pro was never a local model to begin with.

What DeepSeek actually shipped

DeepSeek released the V4 series under an MIT license, and it comes in two very different sizes. Getting the parameter counts straight is the whole game here, because they decide what hardware you need:

• DeepSeek-V4-Pro — a Mixture-of-Experts model with 1.6 trillion total parameters and 49B activated per token.
• DeepSeek-V4-Flash — a smaller MoE with 284B total parameters and 13B activated per token.

Both support a 1-million-token context window, up to 384K output tokens, and both ship with dual thinking / non-thinking modes. Weights and the technical report are public on Hugging Face and arXiv, which is what lets us do this hardware math honestly rather than from vendor slides.

The reason V4 matters for local users isn’t the parameter count — it’s the attention architecture. DeepSeek-V4 uses a hybrid of Compressed Sparse Attention (CSA) and Heavily Compressed Attention (HCA). CSA compresses the KV cache 4× along the sequence and then has each query attend to only the top-k compressed blocks; HCA compresses 128× and attends densely over those blocks. The payoff, per DeepSeek’s paper: at a 1M-token context, V4-Pro needs only 27% of the single-token inference FLOPs and 10% of the KV cache compared with V3.2. That KV-cache reduction is the difference between “1M context is a marketing number” and “1M context you can actually hold in memory.”

Why V4-Pro is a cloud model, full stop

Let’s kill the fantasy first. A 1.6-trillion-parameter model does not run on anything you can buy for a home lab.

V4-Pro precision	Approx. weight size	Reality
FP16	~3.2 TB	Data-center only
FP8	~1.6 TB	8×H200 territory
Q4 (4-bit)	~800 GB	~10× RTX PRO 6000

Even the aggressively quantized Q4 build lands near 800GB of weights — that’s roughly ten RTX PRO 6000 96GB cards (about $130,000 in GPUs alone), before you account for the KV cache. There is no honest “run V4-Pro at home” story in 2026. If you want V4-Pro, you use the API, and the pricing is the reason it’s an easy call: $1.74 per million input tokens and $3.48 per million output, with cached input effectively free at ~$0.0036 per million. At a realistic 10M tokens a month (say 8M in, 2M out) that’s under $21/month for a model scoring 80.6% on SWE-bench Verified — the highest open-weights entry, tied with Gemini 3.1 Pro.

Twenty dollars a month, or a six-figure GPU wall. This isn’t a close decision.

V4-Flash: the honest VRAM math

This is where the trending “4× RTX 4090 runs it” claim needs correcting, because the community GGUF sizes don’t support it.

V4-Flash is a 284B model. At 4 bits per parameter, the weights alone are ~142GB before you add any KV cache — so any story that fits it into 96GB is quietly assuming heavy CPU offload. Here’s what the actual community quants weigh:

Quant	Weight size	Effective bits	Min. VRAM to fit (weights + modest KV)
Q2_K	~103 GB	~2.9	~120 GB
Q3_K_M	~136 GB	~3.8	~150 GB
Q4_K_M	~172 GB	~4.8	~185 GB
Official FP4+FP8 mixed	~160 GB	—	~175 GB (incl. 1M KV)

DeepSeek’s own recommended checkpoint is the FP4+FP8 mixed-precision Instruct build at roughly 160GB of weights, and with the full 1M-token KV cache and runtime overhead you’re looking at ~170–175GB in practice. Native V4 support landed in vLLM v0.22.0 and was hardened for production in v0.23.0, so the serving stack is ready — you just need the memory.

Now line that up against real GPUs:

• 4× RTX 4090 (96GB total) — can’t hold even Q2_K (103GB). You’d be CPU-offloading, which drops you to single-digit tokens/sec. This is the config the hype cited, and it’s the one that doesn’t work.
• 2× H100 80GB (160GB) — fits Q2_K comfortably and the FP8 mixed build tightly; Q3 is a squeeze.
• 2× RTX PRO 6000 Blackwell (192GB) — the cleanest single-box answer. Holds Q4_K_M (172GB) with room for KV. Each card is 96GB GDDR7 at 1,792 GB/s, and they run about $13,250 each right now (up from an ~$8,435 launch listing — a 50%+ hike).
• Used RTX 3090 farm — 6× (144GB, ~$6,400) gets you Q3; 8× (192GB, ~$8,600) gets you Q4. Cheapest on paper, but an 8-card rig is a PCIe-bandwidth and power-delivery project, not a plug-and-play build. We break down why multi-GPU scaling disappoints in our NVLink vs PCIe guide.

So the realistic local floor for a usable V4-Flash is ~$26,500 in two RTX PRO 6000 cards, or a used-3090 farm if you enjoy pain and cheap electricity.

What speed to expect (and why these are estimates)

No independent, measured local tokens/sec figures for V4-Flash existed at the time of writing, so the following are bandwidth-derived estimates, clearly flagged as such — not benchmarks. Decode speed on an MoE is governed by the active parameter count, not the total. V4-Flash fires ~13B parameters per token; at 4-bit that’s roughly 6.5GB of weight reads per token.

• On 2× RTX PRO 6000 (1,792 GB/s each), the theoretical ceiling is high, but tensor-parallel decode plus inter-GPU overhead realistically lands an estimated ~30–60 tok/s.
• On a used-3090 farm (936 GB/s per card, PCIe-bound), expect an estimated ~10–20 tok/s.

Treat those as order-of-magnitude planning numbers. The active-vs-total-parameter logic is the same one that makes big MoE models viable at all — we walk through it in the Kimi K2 hardware guide and the quantization explainer.

Flash vs Pro: how much are you actually giving up?

If Flash is the only model you can self-host, the fair question is what the smaller model costs you in quality. DeepSeek’s published benchmarks say: less than you’d expect on everyday work, more than you’d expect on the hardest agentic tasks.

• SWE-bench Verified: V4-Flash ~79% vs V4-Pro-Max 80.6% — within a couple of points.
• Across most knowledge, reasoning, and coding benchmarks, V4-Flash-Max is within 1–3 points of V4-Pro-Max.
• The gaps open on long-horizon agentic coding (an ~11-point Terminal-Bench gap) and factual world knowledge (a ~23.8-point recall gap).

Translation: for interactive coding, refactors, and single-shot problem-solving, Flash is nearly Pro. For multi-step autonomous agents and trivia-heavy factual recall, Pro pulls clearly ahead. That maps cleanly onto price — Flash is more than 10× cheaper on the API ($0.14/$0.28 vs $1.74/$3.48 per million) — and onto the local story, since Flash is the only one you can host at all.

The cost decision, with real numbers

Here’s the comparison that actually decides it for most people, using a moderate 10M-tokens-per-month workload (≈8M in / 2M out):

Path	Upfront	Monthly	Notes
V4-Flash API	$0	~$1.68	79% SWE-bench, nothing to maintain
V4-Pro API	$0	~$20.88	80.6% SWE-bench, frontier agentic
V4-Flash local (2× RTX PRO 6000)	~$26,500	~electricity	Private, offline, ~30–60 tok/s (est.)
V4-Flash cloud rent (2× H100 on RunPod)	$0	~$4,200 if 24/7	~$2.89/hr each; use for private batch

At $1.68/month for Flash via API, a $26,500 local build takes over a thousand years to break even on token cost alone. Local only makes sense when the value isn’t dollars-per-token: hard privacy requirements, air-gapped/offline operation, or high-volume batch jobs where you’d otherwise be paying by the hour. For those, renting two H100s on RunPod (~$2.89/hr each, A100 80GB as low as ~$1.19/hr) lets you run private jobs without owning the wall of GPUs — the middle path we cover in RunPod vs local and the cloud GPU pricing guide.

For context on where V4-Flash sits among things you can run on a single card, see our open-source LLM shootout — the short version is that if you have one 24GB GPU, V4-Flash isn’t your model, and a Qwen3.6 MoE or Gemma 4 is. For the full head-to-head on which family fits which card, see DeepSeek V4 vs Qwen3 for local AI.

FAQ

Can I run DeepSeek V4-Flash on a single RTX 4090 or 3090? No. Even the smallest usable quant (Q2_K) is ~103GB of weights — over 4× a single 24GB card. A single GPU would offload almost everything to system RAM and crawl at single-digit tokens/sec. V4-Flash needs 120–190GB of VRAM depending on quant.

Does 4× RTX 4090 (96GB) run V4-Flash? Not comfortably. 96GB can’t hold even Q2_K’s 103GB of weights, let alone the KV cache. You’d be CPU-offloading and losing most of the speed benefit. The trending “4× 4090 runs it” claim doesn’t survive the quant math.

What’s the cheapest setup that actually works? For a clean single box, 2× RTX PRO 6000 Blackwell (192GB, ~$26,500) holds Q4_K_M with KV headroom. A used-3090 farm (6–8 cards) is cheaper in GPU cost but is a serious PCIe/power project. For most people, the API is the answer — Flash is $0.14/$0.28 per million tokens.

Why can’t I run V4-Pro locally at all? 1.6 trillion parameters means ~800GB of weights even at 4-bit — roughly ten RTX PRO 6000 cards. There’s no home-lab path. Use the API ($1.74/$3.48 per million) or a cloud cluster.

How much quality do I lose choosing Flash over Pro? On most coding/reasoning benchmarks, 1–3 points (79% vs 80.6% on SWE-bench Verified). The real gaps are in long-horizon agentic coding (~11 points) and factual recall (~23.8 points). For everyday coding, Flash is nearly Pro at a tenth the price.

Is the 1M-token context usable in practice? More so than earlier models, because V4’s CSA + HCA attention cuts KV cache to ~10% of V3.2 at 1M tokens. You still need the VRAM headroom, but the context isn’t just a spec-sheet number.

Sources

• deepseek-ai/DeepSeek-V4-Flash — Hugging Face
• deepseek-ai/DeepSeek-V4-Pro — Hugging Face
• DeepSeek-V4: Towards Highly Efficient Million-Token Context Intelligence — arXiv 2606.19348
• DeepSeek V4: Architecture, Benchmarks, Pricing — morphllm.com
• DeepSeek V4 VRAM & GPU Requirements: Pro vs Flash, Every Quantization — Codersera
• DeepSeek API Pricing — Models & Pricing, DeepSeek API Docs
• NVIDIA now lists RTX PRO 6000 Blackwell 96GB GPU at $13,250 — VideoCardz
• GPU Cloud Pricing — RunPod
• RTX 4090 Price Tracker US — BestValueGPU

Recommended Gear

• RTX PRO 6000 Blackwell — the 96GB card a 2-GPU V4-Flash box is built from
• RTX 3090 — the used-market building block for a budget (if painful) VRAM farm

Prices, benchmarks, and quant sizes as of July 2026 and move quickly — verify current figures before buying. Tokens/sec figures for local V4-Flash are bandwidth-derived estimates, not measured benchmarks. For local AI coding tools, see aicoderscope.com; for self-hosting open-source AI, see aifoss.dev.