DeepSeek R1 GPU requirements: 342 GB at 4-bit, from $0.48/h

Memory by format

How much VRAM DeepSeek R1 needs, format by format.

Weights are parameters × bytes per parameter, except the native FP8 row, which is the size of the published checkpoint. Each context column adds the KV cache of one sequence of that length.

GPUs by memory

Format	Weights	+ 8Kcontext	+ 32Kcontext	+ 128Kcontext	+ 160Kcontext	Cheapest node, 32K
BF16Published weights, fine-tuning	1.37 TB	1.37 TB	1.37 TB	1.38 TB	1.38 TB	8× MI300X · $7.92/h
FP8 (native)Hopper, Ada, Blackwell, MI300	689 GB	689 GB	691 GB	698 GB	700 GB	8× RTX PRO 6000 Blackwell · $1.52/h
4-bitAWQ, GPTQ, GGUF Q4	342 GB	343 GB	345 GB	351 GB	354 GB	8× A40 · $0.48/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 R1, 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
4-bit	8× A40Ampere · 345 GB needed	384 GB	$0.48	$0.72	$350.40	Deploy
4-bit	8× L40Ada Lovelace · 345 GB needed	384 GB	$0.72	$1.52	$525.60	Deploy
4-bit	8× A100 PCIe 80GBAmpere · 345 GB needed	640 GB	$0.72	$1.52	$525.60	Deploy
4-bit	4× RTX PRO 6000 BlackwellBlackwell · 345 GB needed	384 GB	$0.76	$1.56	$554.80	Deploy
FP8 (native)	8× RTX PRO 6000 BlackwellBlackwell · 691 GB needed	768 GB	$1.52	$3.12	$1,109.60	Deploy
FP8 (native)	4× MI300XCDNA 3 · 691 GB needed	768 GB	$3.96	$5.80	$2,890.80	Deploy
FP8 (native)	4× MI325XCDNA 3 · 691 GB needed	1024 GB	$4.36	$6.36	$3,182.80	Deploy
FP8 (native)	8× H200 NVLHopper · 691 GB needed	1128 GB	$5.52	$7.92	$4,029.60	Deploy
BF16	8× MI300XCDNA 3 · 1.37 TB needed	1536 GB	$7.92	$11.60	$5,781.60	Deploy
BF16	8× MI325XCDNA 3 · 1.37 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.

Multi-head latent attention: one compressed 576-value vector per token and layer, 61 layers.

Context	KV cache, 1 sequence	8 sequences
8K tokens	0.58 GB	4.61 GB
32K tokens	2.3 GB	18.4 GB
128K tokens	9.21 GB	73.7 GB
160K tokens	11.5 GB	92.1 GB

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 — 18.4 GB here.

Recommended node8× A40
Weights at 4-bit342 GB
Context that fits, 1 sequence46K

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 R1, as published.

Developer: DeepSeekReasoning model, the R1-0528 checkpoint
Parameters: 671B total, 37B active per token685B in the published checkpoint (embedding tables, prediction or vision modules included); memory figures use this count
Architecture: Mixture of experts, 61 layersMulti-head latent attention: one compressed 576-value vector per token and layer, 61 layers
Context window: 163,840 tokensAs set in the published configuration
Published format: FP8, 689 GB checkpoint
Licence: MIT
Released: 28 May 2025
Source: deepseek-ai/DeepSeek-R1-0528config.json read 26 October 2026

Serve it with vLLM

template: vLLM

On 8× A40, from the instance terminal:

terminal

$ vllm serve deepseek-ai/DeepSeek-R1-0528 \
    --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 V4.1 Flash 552B · 510 GB at FP4+FP8 $1.52/h

Multimodal mixture of experts: 552B backbone plus 196B of Engram memory, 8B or 16B activated per token (model card), 1M-token context

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 R1 on a GPU — the questions that come up

How much VRAM does DeepSeek R1 need?

For the weights alone: 1.37 TB at BF16, 689 GB at FP8 and 342 GB at 4-bit. Add 2.3 GB of KV cache for one 32K-token context, or 11.5 GB at the full 160K window, and keep about 10% of the memory free for activations.

Can DeepSeek R1 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 R1?

Here, 8× A40 at 4-bit: $0.48 per hour on spot and $0.72 on-demand, billed per minute — $350.40 for a 730-hour month on spot. That node has 384 GB of GPU memory for the 345 GB this setup needs.

Does DeepSeek R1 need less memory because only 37B parameters 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 671B total. What the 37B active parameters 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 R1 is published in FP8, a 689 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-R1-0528) 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 R1 on 8× A40 for $0.48 an hour.

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

Deploy 8× A40 All open models

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