Sizing Local Hardware for DeepSeek: A Practical Calculator

“Will the model fit in the available VRAM?” is the question to settle before downloading a DeepSeek checkpoint: the April 2026 V4-Flash Preview files alone total 159.6 GB on Hugging Face (22 October 2026). This guide explains the formulas behind our DeepSeek hardware calculator and shows how parameter count, quantization, KV cache and context length combine into a rough VRAM estimate, and what that estimate leaves out. Presets cover the April 2026 V4-Pro and V4-Flash Preview weights, DeepSeek V3 (671B total / 37B active), four R1-Distill models and Custom.

How the DeepSeek hardware calculator works

Choose a preset (or Custom, with your own total and active parameters), quantization, batch size and a context length from 1K to just under 1M tokens. The calculator shows weights, KV cache, total VRAM, system RAM and rough tokens per second, plus a hint line and a per-GPU fit matrix. The total adds three terms:

• Weights = total parameters × bytes per parameter, every MoE expert included.
• KV cache ≈ 1 KB per token per billion active parameters at FP16 (half at INT8, a quarter at INT4) × context × batch.
• Headroom = 5% of the weights, at least 1 GB.

System RAM is shown as weights × 1.1, and throughput divides an assumed ~1.5 TB/s of memory bandwidth by the bytes read per token (conservative for an H100: NVIDIA lists 3.35 TB/s for the H100 SXM). These are rough estimates from simple formulas, not measurements: real use depends on layer count, head dimension, the engine and its kernels, as the widget’s footnote says. The quantization menu has four settings:

• FP32 — 4 bytes per parameter.
• FP16 / BF16 — 2 bytes.
• INT8 — 1 byte; FP8 matches it.
• INT4 — 0.5 bytes; FP4 roughly matches it.

For GGUF quantizations, compare the actual file size instead. DeepSeek’s V4 Preview model card (April 2026) lists the instruct checkpoints as FP4 + FP8 mixed (MoE experts in FP4, most other parameters in FP8) and the Base checkpoints as FP8 mixed; the calculator has no mixed setting.

Worked example, R1-Distill-Qwen-14B: at FP16, 14,000,000,000 × 2 bytes = 28.0 GB in decimal units, but the calculator divides by 1024³ and labels the result GB, so it shows 26.1 (binary gigabytes, GiB). At INT4, 14,000,000,000 × 0.5 = 7.0 GB decimal, shown as 6.5. With KV cache and headroom at the default 8K context (8,192 tokens) and batch 1, the totals are 27.5 GB (FP16) and 7.5 GB (INT4).

The MoE wrinkle: total parameters vs active parameters

DeepSeek’s V4 Preview release (24 April 2026) lists V4-Pro at 1.6T total / 49B active parameters and V4-Flash at 284B / 13B, both with a 1M-token context; the calculator’s V4 presets use those counts. Active parameters set the compute per token; total parameters set the storage, because the full expert set has to live in memory unless you offload, and the calculator assumes everything is in VRAM.

DeepSeek V4 Preview weights: estimated hardware needs

In April 2026 DeepSeek published four Preview checkpoints, two instruct and two Base. The table gives Hugging Face’s safetensors totals (22 October 2026) and a weights-only check in GiB, the unit in which the calculator compares totals with card memory:

File sizes are not runtime totals: KV cache, activations and engine buffers come on top. The calculator’s INT4 weights for the V4-Pro and V4-Flash presets (745.1 and 132.2 GiB) undercount the instruct files by about 60 and 16 GiB, so its matrix rates the V4-Flash preset (138.9 at INT4, 8K) “Tight” on one 141 GB H200, although the 148.7 GiB of files would not fit. Its hint line says “Multi-node cluster only” for any total above 700, such as V4-Pro’s 782.4 at INT4, yet the instruct files fit one 8 × H200 node.

Newer open weights include DeepSeek-V4-Flash-0731 (31 July 2026, 166.9 GB) and DeepSeek-V4-Pro-0813 (13 August 2026, 892.7 GB), which their model cards call the official releases superseding the Previews, plus DeepSeek-V4.1-Flash (10 September 2026) and V4.1-Flash-1017 (17 October 2026) at 510.3 GB each, all MIT-licensed (22 October 2026). DeepSeek’s 10 September 2026 note describes V4.1-Flash as a 552B-parameter MoE with 8B active parameters for input and 16B for output (DeepSeek has not restated it for V4.1-Flash-1017); no preset covers it, so Custom can only approximate it.

What the V4 Preview report says about long-context memory

DeepSeek’s V4 Preview technical report (arXiv 2606.19348, April 2026) credits its hybrid compressed attention (CSA and HCA): at 1M tokens, it says, V4-Pro needs 27% of DeepSeek-V3.2’s single-token FLOPs and 10% of its KV cache, and V4-Flash 10% and 7%. These are DeepSeek’s figures for the Preview models, not ours; DeepSeek has not restated them for the current hosted builds. The calculator models none of it: its KV term scales with active parameters, so it gives the V4-Pro preset more KV cache than the V3 preset (0.38 against 0.29 GB at 8K, FP16). Treat its V4 KV figure as a placeholder.

R1 and the distilled variants — consumer-hardware territory

DeepSeek released R1 (MIT licence) on 20 January 2025 alongside six distilled models, which the R1 model card lists as dense 1.5B, 7B, 8B, 14B, 32B and 70B checkpoints based on Qwen2.5 and Llama 3. Four are presets; 1.5B and 8B need Custom. R1 itself is 671B total / 37B active per its model card, the size DeepSeek gave V3 at launch (26 December 2024), so the V3 preset stands in for it. Output at 8K context, batch 1, binary GB:

So a 24 GB RTX 4090 or 3090 holds the 32B preset at INT4 with room to spare, but 70B is “Multi-GPU” even on the 32 GB RTX 5090: its INT4 weights alone are 70,000,000,000 × 0.5 ÷ 1024³ = 32.6 GiB, over the card’s 32 before any KV cache. A 32 GB card does fit 32B at INT8 (“Tight”). For 70B at INT4 the “Comfortable” rows start at 48 GB.

The full 671B: what the arithmetic says

At INT4 the V3 preset is “Multi-GPU” only on the 192 GB MI300X row and needs 344 GB of system RAM. The calculator stops at 4 bits and assumes everything is in VRAM, so CPU-offload and sub-4-bit builds are outside it. A machine with 4 × 24 GB of VRAM and 384 GB of RAM has 480 GB, above the 328.2 GB estimate, but the calculator does not estimate how fast such a CPU/GPU split runs.

Don’t forget the KV cache — it grows with every token

The KV cache grows linearly with context and batch, so a model whose weights fit can still run out of memory on long prompts. For the V4-Flash Preview preset at FP16 the calculator counts 1,024 × 13 = 13,312 bytes per token: 0.10 GB at 8,192 tokens and 12.39 GB at the slider’s 999,424-token maximum, eight times that (99.13 GB) at batch 8. Real KV-cache size depends on the attention design, as the calculator notes.

Two practical rules:

1. Read verdicts as computed: “Comfortable” at 1.2× the estimated total or more, “Tight” at 1×, “Multi-GPU” at 0.5×, “No-go” below. That 20% is margin over the whole estimate, not a KV reservation.
2. Budget long V4 contexts explicitly: DeepSeek’s V4 Preview model card (April 2026) recommends at least 384K tokens of context for its Think Max mode when running the weights locally (not the hosted API’s 1M context or 384K output limit), which the generic KV term cannot price.

Apple Silicon: how the calculator counts unified memory

The calculator uses the same formulas for Apple Silicon, counting about 75% of unified memory as GPU-usable: M3 Max 128 GB → 96 GB, M3 Max 64 GB → 48 GB, M3 Pro 36 GB → 27 GB. The 70B preset at INT4 (34.4 GB) is “Comfortable” on the 64 GB M3 Max row (48 ≥ 1.2 × 34.4 = 41.28) and “Multi-GPU” on the M3 Pro; at INT8 (68.7 GB) only the 128 GB M3 Max is “Comfortable” (96 ≥ 1.2 × 68.7 = 82.44). Throughput still assumes ~1.5 TB/s.

The cloud break-even — when local stops making sense

With no verified GPU-rental price, take a hypothetical $3 per GPU-hour: an 8 × H200 node for the V4-Pro weights would cost 8 × $3 = $24 an hour, $24 × 24 = $576 a day, or $576 × 30 = $17,280 per 30-day month, before storage, networking and staff.

For the API, take one million calls of 2,000 cached input tokens (cache hit), 200 uncached (cache miss) and 300 output at DeepSeek’s prices as of 22 October 2026. In total that is 2,000,000,000, 200,000,000 and 300,000,000 tokens; ÷ 1,000,000 gives 2,000, 200 and 300, each × its price per 1M:

• deepseek-flash, peak: 2,000 × $0.006 + 200 × $0.30 + 300 × $1.20 = $12.00 + $60.00 + $360.00 = $432.00
• deepseek-flash, off-peak: 2,000 × $0.003 + 200 × $0.15 + 300 × $0.60 = $6.00 + $30.00 + $180.00 = $216.00
• deepseek-v4-pro, peak: 2,000 × $0.044 + 200 × $1.32 + 300 × $3.96 = $88.00 + $264.00 + $1,188.00 = $1,540.00
• deepseek-v4-pro, off-peak: 2,000 × $0.022 + 200 × $0.66 + 300 × $1.98 = $44.00 + $132.00 + $594.00 = $770.00

Peak hours are 01:00–04:00 and 06:00–10:00 UTC, Monday to Friday, excluding Chinese public holidays; all other hours are off-peak, at half the rate. The totals are exact. Thinking is on by default and reasoning tokens count as output (reasoning_tokens within the completion tokens), so a 300-token answer plus reasoning costs more.

The hypothetical $576 day equals the API bill for about 1.33 million such calls on deepseek-flash at peak ($576 ÷ $0.000432) or 2.67 million off-peak ($576 ÷ $0.000216), and about 374,000 or 748,000 on deepseek-v4-pro ($576 ÷ $0.00154; $576 ÷ $0.00077), rounded. Whether one node could serve that is beyond the calculator. The API’s current builds are open weights too, and their files fit the node’s 1,128 GiB (831.4 for V4-Pro-0813, 475.3 for V4.1-Flash-1017), but no preset covers them; data control or fine-tuning can justify self-hosting. See also our DeepSeek cost estimator and DeepSeek API pricing page.

A worked sizing example: V4-Flash Preview weights on 80 GB GPUs

Take a hypothetical team that wants the V4-Flash Preview weights behind an internal coding assistant. Before renting hardware it can check its prompts’ token counts and cost on the hosted API, where deepseek-flash now serves DeepSeek-V4.1-Flash-1017 (a newer model than the Preview weights), using the OpenAI Python SDK as in DeepSeek’s thinking-mode guide:

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ.get("DEEPSEEK_API_KEY"),
    base_url="https://api.deepseek.com",
)
resp = client.chat.completions.create(
    model="deepseek-flash",
    messages=[{"role": "user", "content": "Refactor this function."}],
    reasoning_effort="high",
    extra_body={"thinking": {"type": "enabled"}},
)
print(resp.choices[0].message.content)
print(resp.usage)

The SDK posts to https://api.deepseek.com/chat/completions; resp.usage reports the cache-hit, cache-miss and completion tokens behind the cost sums above. A self-hosted server has its own base URL and model name. Weights-only budget for the 148.7 GiB (159.6 GB) of V4-Flash Preview files:

• 2 × 80 GB: 160 − 148.7 = 11.3 GiB left across both cards for KV cache, activations and engine buffers, which the calculator cannot size here.
• 4 × 80 GB: 320 − 148.7 = 171.3 GiB left.
• 2 × 141 GB (H200): 282 − 148.7 = 133.3 GiB left.

The calculator (V4-Flash preset, INT4, batch 1) gives 139.3 GiB at 128,000 tokens (132.25 weights + 0.40 KV + 6.61 headroom) and 142.0 GiB at 999,424. Neither shows the longest context 4 × 80 GB will hold; that depends on the engine.

Mapping your build to a DeepSeek model

A rough guide from the calculator’s formulas (INT4 unless stated, 8K context, batch 1):

• 8 GB VRAM — R1-Distill-Qwen-7B (4.3 GB). See the DeepSeek R1 Distill page for variant choices.
• 12–16 GB VRAM — R1-Distill-Qwen-14B, or 7B at INT8 (7.5 GB each).
• 24 GB VRAM — R1-Distill-Qwen-32B (16.0 GB). Pair with our running DeepSeek on Ollama tutorial.
• 32 GB VRAM — R1-Distill-Qwen-32B at INT8 (31.4 GB, “Tight”).
• 48 GB class (L40S, RTX 6000 Ada, 64 GB M3 Max) — R1-Distill-Llama-70B (34.4 GB).
• Several data-centre GPUs — V4-Flash Preview or 0731 weights (148.7 or 155.4 GiB): two 80 GB cards at the margin, four for headroom, or two H200s; see DeepSeek V4-Flash.
• 8× H200 or larger — V4-Pro Preview or 0813 weights: 805.3 or 831.4 GiB within one node’s 1,128 (296.6 spare for 0813). See DeepSeek V4-Pro.

If self-hosting is overkill, fall back on the hosted API. The legacy IDs deepseek-chat and deepseek-reasoner were retired on 24 July 2026; use deepseek-flash (DeepSeek-V4.1-Flash-1017) or deepseek-v4-pro (DeepSeek-V4-Pro-0813). The legacy name deepseek-v4-flash is still accepted but retired; DeepSeek-V4.1-Flash-1017 serves it at the Flash price. See the DeepSeek tools and utilities hub, or the DeepSeek system requirements guide for the chat and app side.

External primary sources

All opened on 22 October 2026:

• The DeepSeek V4-Pro model card on Hugging Face (V4 Preview, April 2026) and the file listings for V4-Pro, V4-Pro-Base, V4-Flash and V4-Flash-Base repos.
• The DeepSeek-V4 technical report (arXiv 2606.19348, April 2026).
• DeepSeek release notes: V4 Preview (24 Apr 2026), V4.1-Flash (10 Sep 2026), V3 (26 Dec 2024), R1 (20 Jan 2025); the R1 model card.
• DeepSeek’s Models & Pricing page and API Change Log.

DeepSeek AI Guide is an independent resource and is not affiliated with DeepSeek or its parent company. Model IDs, pricing and API behaviour change; check the official DeepSeek documentation and pricing page before committing to a production decision.