Comparison

DGX Spark vs H100 for LLM inference

By Samuel Seidel · Updated October 11, 2026 · 7 min read

A DGX Spark has 128 GB of memory at 273 GB/s; an H100 SXM has 80 GB at 3.35 TB/s, about 12 times the bandwidth, and rents for $1.99 to $4.29 an hour against the Spark's $0.79. On one Spark, GPUwerk measured 6.0 tok/s single-stream for Llama 3.3 70B AWQ and 80.9 tok/s for Qwen3-Coder 30B-A3B AWQ. I run GPUwerk, which rents Sparks and has no H100 in its fleet, so weigh what follows with that in mind. The Spark is enough when one person or a small team runs a model that needs more memory than 80 GB, or when you want to try a model by the minute before paying H100 rates. It is not enough for a shared endpoint with many concurrent users, and by the bandwidth arithmetic below an H100 should decode any model that fits on it several times faster.

Side by side

 DGX Spark (GB10)H100 SXM 80 GBH100 PCIe 80 GB
Memory128 GB LPDDR5x, unified (advantage)80 GB HBM380 GB (RunPod and Lambda listings)
Memory bandwidth273 GB/s3.35 TB/s (advantage)Not on the NVIDIA page checked
Precision supportFP4 (NVIDIA quotes 1 PFLOP sparse FP4), FP8, FP16FP8, FP16, INT8; no FP4 listedSame Hopper precisions
Single-stream decodeGPUwerk-measured: 80.9 tok/s Qwen3-Coder 30B-A3B AWQ; 6.0 tok/s Llama 3.3 70B AWQNot measured by GPUwerkNot measured by GPUwerk
Price per hour$0.79, GPUwerk (advantage)$2.69 to $3.99 RunPod; $3.99 to $4.29 per GPU-hour Lambda$1.99 to $2.89 RunPod; $3.29 Lambda
BillingPer minute, prepaid creditPer second (RunPod); per minute (Lambda)Per second (RunPod); per minute (Lambda)
Where it winsMemory per dollar; big models for one user; cheap evaluationThroughput per request; batch serving of dense 70BSame GPU class, lower hourly rate than SXM

Checked 2026-10-11. Spark decode: GPUwerk-measured with vLLM 0.27.1 on 2 September 2026, raw logs for Qwen3-Coder and Llama 3.3 70B, method on the benchmarks page. H100 SXM memory (80 GB HBM3) and bandwidth: NVIDIA H100 page, which lists SXM and a 94 GB NVL variant but no 80 GB PCIe bandwidth, so that cell is left open. PCIe memory size comes from the RunPod and Lambda listings. Spark FP4 figure is NVIDIA's; the H100 precision row follows the same NVIDIA page, whose spec table lists FP64, FP16, FP8 and INT8 but no FP4. Prices are in the next section.

H100 rental prices (checked 2026-10-11)

Provider and GPUPrice per hourBilling
RunPod H100 PCIe$1.99 Community Cloud, $2.89 Secure CloudPer second
RunPod H100 SXM$2.69 Community Cloud, $3.49 Secure Cloud; the rendered table showed $3.99Per second
Lambda H100 PCIe$3.29 (1 GPU)Per minute
Lambda H100 SXM$3.99 (8 GPUs) to $4.29 (1 GPU) per GPU-hourPer minute
GPUwerk DGX Spark$0.79 (advantage)Per minute

Sources, all fetched 2026-10-11: RunPod pricing (on-demand Pods; RunPod also lists a 94 GB H100 NVL), Lambda pricing (on-demand instances), Lambda billing docs. RunPod's page is not consistent with itself: the Community and Secure Cloud rates above are from the page's own product data, while its rendered price table showed $2.89 for H100 PCIe and $3.99 for H100 SXM on the same day. Check the tab you would actually deploy from. Other providers and EU options are covered in the RunPod comparison and the Lambda comparison. GPUwerk's rate is on the pricing page.

The hourly gap is about 2.5 times (RunPod Community Cloud PCIe) to 5.4 times (Lambda single SXM GPU), my division. Hourly price is not cost per token. A busy H100 produces far more tokens per hour than a Spark, so for sustained batch load it can cost less per token.

The bandwidth arithmetic

Generating one token means reading the active weights from memory once. So single-stream decode speed is roughly memory bandwidth divided by the bytes of active parameters. On a Spark that is 273 GB/s divided by the active-parameter size, as laid out on the benchmarks page. Real engines land at about 50 to 80 percent of that ceiling.

The H100's 3.35 TB/s is about 12 times 273 GB/s. The H100 can pull weights out of memory 12 times faster, so the same arithmetic gives a ceiling of roughly 90 tok/s for that 37 GB model. That is arithmetic, not a measurement: GPUwerk has not run an H100, and I am not presenting a figure as if it had.

That bandwidth gap decides the trade. The H100 wins on throughput per request and on batch serving of dense 70B models: GPUwerk's measured Llama 3.3 70B aggregate on one Spark peaks at 485 tok/s near concurrency 128 and drops to 300 tok/s at 256, with each request down to 1.4 tok/s at the peak. The Spark wins on memory per dollar. A model like Nemotron-3-Super 120B at NVFP4 (about 67 GB of weights, per GPUwerk's model page) leaves about 54.6 GiB on a Spark but only around 13 GB on an 80 GB card, before runtime overhead (my subtraction). The Spark also wins on the cost of finding out whether a model works for you at all, since you pay by the minute.

When to pick which

GPUwerk has no H100 benchmark and no SLA, and only one two-node run of its own (a 32B model on two Sparks). I have not said the Spark is faster than an H100 because it is not. The previous datacenter generation, still common for rent, is compared in DGX Spark vs A100.

Measured Spark numbers from GPUwerk's fleet

Taken with vllm bench serve on vLLM 0.27.1 on one GB10 node in GPUwerk's fleet, nothing else on its GPU, on 2 September 2026. Context and method are on the benchmarks page.

Concurrency Qwen3-Coder 30B-A3B AWQ
aggregate / per request
Llama 3.3 70B AWQ
aggregate / per request
1 80.9 tok/s / 80.9 6.0 tok/s / 6.0
8 845 tok/s / 35.2 125 tok/s / 5.2
32 1,679 tok/s / 18.4 298 tok/s / 3.9
64 2,421 tok/s / 13.1 466 tok/s / 2.8
128 3,010 tok/s / 8.2 485 tok/s / 1.4 (advantage)
256 3,235 tok/s / 4.5 (advantage) 300 tok/s / 0.4

512 tokens in, 256 out, three requests per concurrency slot, zero failed requests at every level. Raw logs: Qwen3-Coder · Llama 3.3 70B.

FAQ

Can a DGX Spark replace an H100?

No, not for serving many users at once. The H100 has 3.35 TB/s of memory bandwidth against the Spark's 273 GB/s, about 12 times more, and single-stream decode speed tracks bandwidth closely. For a shared endpoint with concurrent traffic, the H100 wins. The Spark fits a narrower job: development, evaluation and single-user or small-team inference on models that need more than 80 GB of memory.

When is the Spark actually enough?

When your model and its cache fit in 128 GB, usage is one person or a small team, and the work is development, evaluation or occasional inference rather than concurrent traffic. GPUwerk measured a 30B-class mixture-of-experts model (Qwen3-Coder 30B-A3B AWQ) at 80.9 tok/s single-stream on a Spark, on 2 September 2026.

How much cheaper is a Spark than renting an H100?

GPUwerk rents a Spark at $0.79/hour, billed per minute. On 11 October 2026 RunPod listed H100 PCIe from $1.99/hour and H100 SXM from $2.69/hour (Community Cloud), and Lambda listed H100 PCIe at $3.29 and H100 SXM at $3.99 to $4.29 per GPU-hour. That is roughly 2.5 to 5.4 times the Spark's hourly rate, but the H100 does far more work per hour, so cost per token can favour the H100 under heavy load.

What does the Spark lose compared to the H100?

Three things: memory bandwidth (273 GB/s vs 3.35 TB/s), single-stream decode speed on dense models, and batch serving, where the H100's bandwidth should sustain much higher aggregate tokens per second under concurrent load (GPUwerk has not measured an H100). GPUwerk's measured Llama 3.3 70B AWQ aggregate peaks at 485 tok/s on one Spark and falls to 300 tok/s at concurrency 256.

Can I test on a Spark before committing to H100 spend?

Yes. Rent a Spark by the minute at $0.79/hour to check that a model fits your use case and quality bar, then move to H100 capacity from any provider once you know you need the throughput.

Does GPUwerk rent H100s?

No. GPUwerk rents DGX Sparks at $0.79/hour for one node or $1.79/hour for a two-node 256 GB cluster. It quotes 8x H100 servers per configuration, but no H100 is installed in its fleet today. The H100 prices on this page come from RunPod and Lambda, cited for comparison, and are not GPUwerk offers.

A first engagement can scope which side of the line your workload lands on. If you would rather own a Spark without running it, GPUwerk's GB10 store sells machines from eight makers, and GPUwerk can host yours and rent it out for you.

First top-up: pay $20, get $30 in credit

Find out which side you are on for $0.79/hour.

Run your real model on a dedicated DGX Spark before you commit to H100 spend anywhere. Billed by the minute from prepaid credit.

Create account See pricing