# DeepSeek V4 Flash 0731: Is It Cheaper to Run It at Home or Pay Per Token?

> Source: <https://grigio.org/deepseek-v4-flash-0731-is-it-cheaper-to-run-it-at-home-or-pay-per-token/>
> Published: 2026-08-04 23:08:27+00:00

# DeepSeek V4 Flash 0731: Is It Cheaper to Run It at Home or Pay Per Token?

A note from the reviewer.I re-ran every calculation in this post myself. The math now checks out end to end and uses one consistent blended API rate throughout (see section 4). I couldn't independently verify external claims like the model specs, API pricing, Unsloth's GGUF measurements, or August 2026 hardware street prices, so those are repeated from the cited sources (see section 7). The headline conclusion, that running V4 Flash locally never beats the API on pure token cost, still holds, and it actually comes outstrongeronce the numbers are consistent.

## The short version

DeepSeek V4 Flash is a 284B-parameter **Mixture-of-Experts** model. Only **13B parameters** are active per token, and it handles a native 1M-token context under an **MIT** license. But that "thin" active count is misleading: all 284B weights still have to sit in memory, so you need a machine with **128GB+ of unified memory**. No consumer GPU comes close.

The key finding of the simulation: **running V4 Flash locally basically never breaks even against DeepSeek's own API.** The API is so cheap (about $0.13 per million blended tokens; $0.14/$0.28 in and out) that a home machine can't even generate enough tokens to cover its own electricity at API rates, let alone pay back the hardware. The best possible local setups use Q4 and Q8 quantization on 192GB machines (those are near-lossless and bit-identical to the **April preview** checkpoint), and they still lose on cost per token: the best home config spends **2.4× what the API costs on electricity alone**, before you've even bought the machine.

Buying hardware only makes sense for **privacy, data sovereignty, offline use, or fine-tuning**. Not for saving money. Full break-even tables are below.

## 1. The model

| Property | DeepSeek V4 Flash |
|---|---|
| Total parameters | 284B |
| Active parameters per token | 13B |
| Architecture | Mixture-of-Experts, CSA + HCA attention |
| Context window | 1,000,000 tokens (native) |
| Native precision | FP4 expert weights, FP8 KV cache |
| Reasoning modes | Non-Think, Think High, Think Max |
| License | MIT (free to download, commercial use allowed) |
| API price | $0.14 / $0.28 per million input/output tokens |

The **0731 build** is V4 Flash's official release, with big agentic gains over the April preview (Terminal Bench 2.1: 82.7 vs 61.8). It even beats the far bigger V4-Pro preview at 72.1.

One important catch:as of the research date, the improved0731 weights are API-only. The weights you can download are theApril preview(same 284B/13B architecture, just slightly weaker agentic performance). Local means April preview; the API means 0731. The call-site is the same either way:`deepseek-v4-flash`

. So the hardware simulation below runs the April-preview weights, and you should treat the local quality numbers as applying to that checkpoint.

## 2. What you need to run it: the full quantization ladder

Active parameters set how much compute each token needs, but **total parameters set the memory bill**. The router can send any token to any expert, so every expert has to stay loaded in memory.

Here's Unsloth's measured GGUF ladder (July 2026), showing file size and combined RAM+VRAM floor:

| Build | File size | Memory floor | Measured quality |
|---|---|---|---|
| 2-bit (UD-IQ2_XXS) | 87 GB | 92–102 GB | about 78% top-token agreement |
3-bit (UD-IQ3_XXS) |
103 GB | about 110 GB | Unsloth's pick for 128GB machines |
| 4-bit (UD-Q4_K_XL) | 155 GB | about 162 GB | about 96% top-token, near-lossless |
8-bit (UD-Q8_K_XL) |
162 GB | about 169 GB | Lossless, bit-identical to the April preview |

Here's the surprising part of the ladder: **being lossless costs almost nothing.** V4 Flash was trained to be quantization-aware, and its expert weights already ship natively in MXFP4, so the 8-bit repack is only about 7 GB bigger than the 4-bit. That's the whole price of running the exact April preview checkpoint. On a 192GB machine, the Q8 vs Q4 memory difference hardly matters.

The official checkpoint (FP4+FP8) is about 156 GB. On 80GB-GPU datacenter nodes, that's a tight **2× A100 (80GB)** fit (160GB total) or a comfortable **2× H200** (282GB). Note that a **single 141GB H200 does not fit** the roughly 156GB checkpoint without heavy offload. The original post listed "1× H200 (141GB)" as a valid config, but that was a math slip and is corrected here.

About context: the 1M window is aimed at datacenters. At home, plan on **8K–32K context**, with room for the KV cache included in the memory floors above.

## 3. The candidate machines (street prices, August 2026)

The 2026 memory shortage has pushed unified-memory prices way up. NVIDIA raised the DGX Spark MSRP from $3,999 to $4,699 in February, and used M3 Ultra 512GB units have traded near $25K.

| Machine | Price | Builds that fit | Est. tps* |
|---|---|---|---|
| Mini PC Ryzen AI Max+ 395 (128GB) | $2,600–3,200 | Q2, Q3 | about 8–9 |
| NVIDIA DGX Spark (128GB) | $4,699 | Q2, Q3 | about 7–8 |
| Mac Studio M2 Ultra 192GB (used) | about $4,000 | Q2, Q3, Q4, Q8 | Q4 about 18 |
| Mac Studio M3 Ultra 192GB (used) | about $6,000 | Q2, Q3, Q4, Q8 | Q4 about 22 |
DeepSeek API |
pay per token | full precision | about 84 |

* Speeds are extrapolated from published measurements: about 6 tps on a GB10 at 2-bit (llama.cpp PR #24162), about 11 tps on Strix Halo for a 235B-class MoE (Tech Times), about 25 tps on a 192GB M3 Ultra (MLX, June). There's no canonical V4 Flash on home hardware benchmark yet, so treat these speeds as rough.

For MoE generation, bandwidth matters more than raw compute. The 128GB boxes measure around 215 GB/s, while the M2/M3 Ultra run at 800–819 GB/s. Token speed is bound by memory bandwidth.

**Assumptions I pinned down for reproducibility (used in every table below):**

- Purchase prices (midpoints): Ryzen $2,900 · DGX Spark $4,699 · M2 Ultra $4,000 · M3 Ultra $6,000.
- Electricity: $0.20/kWh, 24/7. Ryzen 100W → $0.48/day · DGX 200W → $0.96/day · Macs 121W → $0.58/day.
**Blended API rate = $0.128/M**(see section 4 for how I got there). Used consistently in 4b, 4c, and 4e.- Weights: April preview locally; 0731 full precision on the API.

## 4. The simulation

**Method.** I blended the token mix so that 2/3 of generated tokens are input and 1/3 are output. Input is priced at 30% cache miss ($0.14/M) and 70% cache hit ($0.014/M, a conservative pick; sources range $0.0028–0.028). Blended input = 0.30×$0.14 + 0.70×$0.014 = **$0.0518/M**. Blended API rate = (2/3)×$0.0518 + (1/3)×$0.28 = **$0.128/M**. Electricity runs at $0.20/kWh around the clock. Token speed sets max capacity per day with `tps × 86,400`

. "Local opex $/M" is the electricity you need to generate 1M tokens locally. Break-even months = purchase ÷ (API revenue/day minus electricity/day).

### 4a. Monthly API cost, by usage scenario

| Scenario | Tokens/day | API cost/day | API cost/month |
|---|---|---|---|
| Light (casual chat) | 1,000,000 | $0.13 | $3.8 |
| Medium (AI coding + agent) | 5,000,000 | $0.64 | $19 |
| Heavy (autonomous agent) | 20,000,000 | $2.56 | $77 |
| Team service | 100,000,000 | $12.79 | $384 |

*(The original post quoted $0.11 / $3.3 for the "Light" row, which came from an inconsistent token-mix assumption. I corrected it to the same $0.128/M blended rate used everywhere else.)*

### 4b. Local capacity and unit cost (per config, running flat out 24/7)

| Hardware | Quant | Max tok/day | Elec/day | Local opex $/M | vs API* |
|---|---|---|---|---|---|
| Ryzen AI Max+ 395 | Q3 | 691,200 | $0.48 | $0.69 | 5.4× |
| Ryzen AI Max+ 395 | Q2 | 777,600 | $0.48 | $0.62 | 4.8× |
| DGX Spark | Q3 | 604,800 | $0.96 | $1.59 | 12.4× |
| DGX Spark | Q2 | 691,200 | $0.96 | $1.39 | 10.9× |
| Mac Studio M2 Ultra 192GB | Q4 | 1,555,200 | $0.58 | $0.37 | 2.9× |
| Mac Studio M2 Ultra 192GB | Q8 |
1,209,600 | $0.58 | $0.48 | 3.8× |
| Mac Studio M3 Ultra 192GB | Q4 | 1,900,800 | $0.58 | $0.30 | 2.4× |
| Mac Studio M3 Ultra 192GB | Q8 |
1,468,800 | $0.58 | $0.39 | 3.1× |

* `vs API`

= local opex divided by the blended API $0.128/M. *(The original post's ratios implied an unstated rate of about $0.19/M. I corrected them to the $0.128/M used everywhere else.)*

Even the best option (192GB M3 Ultra at Q4) costs **2.4× the API in electricity alone**, before you've bought anything. Running local is the pricier route in every config.

### 4c. Break-even months to recover the purchase (no resale)

Break-even is tied to each machine (it depends on purchase plus electricity, not the quant). And the numbers show it's only "reachable" at token volumes these machines **physically can't produce**:

| Hardware | Quant | 1M/d | 5M/d | 20M/d | 100M/d |
|---|---|---|---|---|---|
| Ryzen AI Max+ 395 | Q3 | never | 596 mo (50 yr) | 46 mo | 8 mo |
| DGX Spark | Q3 | never | never | 97 mo | 13 mo |
| Mac Studio M2 Ultra 192GB | Q4 | never | 2,193 mo | 67 mo | 11 mo |
| Mac Studio M3 Ultra 192GB | Q4 | never | 3,290 mo | 100 mo | 16 mo |

At 100M tokens/day the hardware "pays for itself" in 8–16 months. But 100M tokens/day is **50–165× more than a 128–192GB machine can produce** (capacity sits at 0.6–1.9M/day). Every non-"never" cell is physically impossible. *(The 5M/day cells came out to decades, and I re-derived them from the pinned purchase prices, correcting the original 2,105/3,158 months.)*

### 4d. Five-year total cost of ownership (purchase + electricity minus 40% resale)

| Hardware | Quant | 5-yr TCO | $/month |
|---|---|---|---|
| Ryzen AI Max+ 395 | Q3 | $2,616 | $44 |
| DGX Spark | Q3 | $4,571 | $76 |
| Mac Studio M2 Ultra 192GB | Q4/Q8 | $3,451 | $58 |
| Mac Studio M3 Ultra 192GB | Q4/Q8 | $4,651 | $78 |

Compare that to the API: even the "heavy" 20M-token/day scenario costs just **$77/month** on the API. The annualized hardware cost alone ($44–78/month) tops the API bill for every usage level except the very highest. (The TCO formula is `0.6 × purchase + electricity`

, which assumes the machine keeps 40% of its value after five years.)

### 4e. Operational break-even (tokens/day just to cover electricity)

This is the API-usage volume whose bill equals the machine's daily electricity, or the "revenue" the machine would need to earn to pay for its own power. The last column reads: **what share of that target the machine can actually supply running flat out.**

| Hardware | Quant | Elec/day | Op. break-even | % of target supplied |
|---|---|---|---|---|
| Ryzen AI Max+ 395 | Q3 | $0.48 | 3.75M tok/day | 18% |
| Ryzen AI Max+ 395 | Q2 | $0.48 | 3.75M tok/day | 21% |
| DGX Spark | Q3 | $0.96 | 7.50M tok/day | 8% |
| DGX Spark | Q2 | $0.96 | 7.50M tok/day | 9% |
| Mac Studio M2 Ultra 192GB | Q4 | $0.58 | 4.53M tok/day | 34% |
| Mac Studio M2 Ultra 192GB | Q8 | $0.58 | 4.53M tok/day | 27% |
| Mac Studio M3 Ultra 192GB | Q4 | $0.58 | 4.53M tok/day | 42% |
| Mac Studio M3 Ultra 192GB | Q8 | $0.58 | 4.53M tok/day | 32% |

If a machine supplies fewer tokens/day than its operational break-even, and that's true for **all** the home configs here, then local generation is pricier per token than the API **even before you add the purchase price**. The fastest machine (M3 Ultra Q4) can only supply **42%** of the volume it would need to pay its own electricity at API rates. *(The original post called this column "% of capacity" and used a stray $0.21/M rate. I corrected it to "% of target supplied" at $0.128/M.)*

## 5. When does buying hardware actually make sense?

On pure token economics: **never.** DeepSeek sells tokens cheaper than your home electricity. Buying hardware only wins on these non-financial grounds:

**Privacy / data sovereignty** for regulated sectors and confidential code or documents that have to stay on premises. This is the one case where the premium is clearly worth it.**Predictable fixed costs.** One capex charge instead of a variable bill, with no token limits, no rate caps, and no 3 a.m. outages.**Offline operation.** Full autonomous inference with no connectivity needed.**Fine-tuning / research.** The MIT open weights let you modify the model in ways a hosted API never will. (Here's where Q4/Q8 matter: Q8 gives you the*bit-identical*April preview checkpoint locally.)**Hardware speculation.** The 2026 memory shortage is making unified-memory boxes appreciate (DGX Spark up 17% in six months; used M3 Ultra 512GB spiked to about $25K). That's an investment bet, not cost savings.

**When it does not make sense:** to save money, to get more speed (the API is about 4–14× faster at roughly 84 tps vs 6–22 tps local), or to reach the improved 0731 build (API-only for now).

## 6. Caveats

**Quality.** Local runs are quantized (up to 96% top-token at Q4; Q8 is lossless to the**April preview**, not the 0731). The API serves the full-precision** 0731**build.** Context.**The 1M-window target is datacenter-first; realistic local context is 8K–32K.** Speed.**6–22 tps local vs about 84 tps on the API. Fine for chat, slow for autonomous agents.** Speed figures**are extrapolated from community reports; there was no canonical home benchmark for V4 Flash when this was written.** Prices**reflect the memory-shortage market of August 2026 and drift quickly.** External facts**(model specs, GGUF quality, street prices) come from the sources in section 7 and weren't independently verifiable on the research date.

## 7. Assumptions & sources

- API pricing: deepseek.com official (V4-Flash $0.14 in miss / $0.28 out per million; assumed cache-hit discount of 1/10). Sources disagree on the cache-hit value ($0.0028 vs $0.028), but the conclusion doesn't depend on it.
**One blended rate used throughout: $0.128/M.** - GGUF ladder and memory floors: Unsloth published measurements, July 2026.
- Speeds: llama.cpp PR #24162, Tech Times, MLX (June), and community reports.
- Hardware prices: NVIDIA ($4,699), laptop and mini-PC market surveys ($2,400–3,200 for Strix Halo 128GB), and resale-market surveys for used Mac Studios.
- Model specs and benchmarks: DeepSeek model card, felloai.com, baseten.co, Artificial Analysis.

*Prepared August 4, 2026; independently re-derived for internal consistency on the same date. All costs in USD. Not investment advice; hardware prices and API tiers change quickly.*