B200 vs H100: how much faster is Blackwell for training?

In MLPerf Training v6.0, 64 NVIDIA B200 GPUs trained two LLM benchmarks 2.04 to 2.08 times faster than 64 NVIDIA H100s, a little under the 2.27x gap in their dense FP8 specs. Nodus lists the B200 at $5.50/hr and the H100 SXM at $2.60/hr, so a B200 must finish 2.115 times faster to cost less per run, and the two land within a few percent per finished job. Pick the B200 when finishing in half the time matters or its 180 GB per GPU saves a second node; otherwise the H100 costs the same or less at the measured speedups.

That near tie is the useful part. Blackwell is a real generational jump, but the hourly price jumped by about the same amount. This post shows what changed in the silicon, what the published benchmarks measured, and a priced 800 GPU-hour job at several speedups.

What changed from Hopper to Blackwell?

Almost everything a training step touches roughly doubled. Memory, memory bandwidth, dense math and NVLink all went up between 2x and 2.4x, and Blackwell added FP4 Tensor Cores that the H100 does not have.

H100 figures are from NVIDIA's H100 page, which lists BF16 and FP8 with sparsity, so we halved them. NVIDIA lists B200 figures per 8-GPU system on the DGX B200 and HGX pages: 1,440 GB, 64 TB/s, 36 PFLOPS BF16 and 72 PFLOPS FP8 with sparsity, and 72 PFLOPS dense FP4. We divided by 8 and halved the sparse figures. Prices checked November 10, 2026 on the Nodus pricing page.

On paper, then, a B200 is about 2.27 times an H100 for the dense matrix math that dominates LLM training. The price ratio sits just under that, at 2.115x. Per dollar, the B200 buys 7% more peak BF16 math (2,250 / $5.50 against 989.5 / $2.60) and 13% more memory bandwidth. That is a thin edge, and real jobs rarely run at peak.

How much faster is a B200 than an H100 in published benchmarks?

About 2x at equal GPU count. MLPerf Training v6.0 has one pair of results that compares the two cleanly: both in the closed division, both 64 GPUs on 8 nodes, both listed as available systems, same benchmarks.

Times are minutes to reach the benchmark's quality target, from the official MLPerf Training results sheet published by MLCommons. We read the precision settings from each submission's configs in the v6.0 results repository. Both H100 runs trained in FP8. The B200 gpt-oss-20b run used MXFP8, and the B200 Llama 3.1 8B run used NVFP4.

Measured MLPerf speedups land just under the Nodus price ratio, and both sit under the spec ratios.

Three details matter when you apply these numbers to your own job. These are tuned submissions, so they show what a well-optimized stack gets, not what an untouched script gets. The two runs used different batch sizes and software releases, which MLPerf allows as long as both reach the same quality target. And the FP4 run was not further ahead of its H100 counterpart than the 8-bit run was, so do not count on FP4 as a free extra doubling.

NVIDIA's own DGX B200 page claims 3X the training performance of DGX H100. Its footnote describes a projected result on a 32,768 GPU cluster, so treat it as an upper bound for very large runs rather than an estimate for a single node.

Is a B200 cheaper than an H100 for the same training run?

Only if it runs at least 2.115 times faster, the ratio of the two list prices ($5.50 / $2.60). We priced one fixed job: 800 H100-hours, run as 8 x H100 for 100 hours, which costs 8 x $2.60 x 100 = $2,080.

We computed each row as 8 x $5.50 x (100 / speedup), using Nodus list prices checked November 10, 2026; the break-even row uses the exact ratio, 5.50 / 2.60. The 1.5x, 2.0x and 2.5x rows are round numbers for comparison, not measurements.

At the measured MLPerf speedup the B200 run costs $35.38 more and finishes about 52 hours sooner.

Read the middle of the table, not the ends. At the 2.08x MLPerf speedup, the B200 finishes the same job in 48 hours instead of 100 for 2% more money. If your stack only reaches 1.5x on Blackwell, the same job costs 41% more. If it beats the spec ratio, that almost always means memory is doing the work, which the next section covers.

When does 180 GB per GPU make the B200 the cheaper choice?

When it fits a job on one node that needs two H100 nodes. Mixed-precision training with Adam keeps about 16 bytes per parameter, following the ZeRO paper, before activations.

Take a full fine-tune of a 60B model: 60 x 16 = 960 GB of training state. One 8 x H100 node has 640 GB, so it does not fit. One 8 x B200 node has 1,440 GB, so it does, with room left for activations.

The H100 answer is two nodes, 16 GPUs at $41.60/hr. The B200 answer is one node at $44.00/hr, only 5.8% more per hour. That one node also has more peak math: 8 x 2,250 = 18,000 TFLOPS of dense BF16 against 16 x 989.5 = 15,832 TFLOPS. And all its traffic stays on NVLink instead of crossing the network between nodes.

Here the B200 wins on cost, not just time, unless the two H100 nodes run at least 1.058 times faster than the single B200 node ($44.00 / $41.60). With 12% less peak compute and a network hop, they will not. Multi-node training on Nodus is still in Beta, which is one more reason to prefer the single node.

The same logic applies to activation recomputation and CPU offloading. If 80 GB forces either one on your H100 run and 180 GB removes it, your measured speedup can clear 2.115x. Our B300 vs B200 comparison works through the same memory rule one generation further.

Where is the H100 the better choice?

Jobs that already fit comfortably in 80 GB and where cost per run is the deciding number. That covers LoRA and QLoRA fine-tunes, small-model pretraining and most experiments. At the measured 2x speedups they cost the same or slightly less on H100s.

The H100 also wins when your code is not tuned for Blackwell. Hopper-specific kernels built for sm_90a do not run on Blackwell at all, according to NVIDIA's Blackwell compatibility guide, and every hour spent porting them is an hour not training. A job that reaches 1.5x on a B200 costs 41% more there.

Where is the B200 the better choice?

When elapsed time is worth money. At about 2x, a three-day run becomes a day and a half for roughly the same spend, which means more experiments per week and earlier answers.

The B200 is also the better pick for models that do not fit on one H100 node, as worked through above. The same goes for teams already training in FP8 or MXFP8 on a current NVIDIA software stack, the setup behind the MLPerf results.

How do you measure your own B200 speedup on Nodus?

Run the same short job on both GPU types and compare throughput. Nodus Sweeps run one Job once per GPU type and report costUSD, wallSeconds and unitsPerSecond for each cell. This is the documented Python form from the Sweeps guide, with the grid set to the two GPU types:

import nodus

sweep = nodus.Sweep(
    {"image": "nodus/pytorch", "command": ["python", "bench.py"]},
    grid={"gpu": ["H100:8", "B200:8"]},
    repetitions=2, max_parallel=6, max_cost=25,
).run()
report = sweep.wait()
print(report.phase, report.best.by_cost)
for cell in sweep.cells():
    print(cell.index, cell.phase, cell.cost_usd, cell.wall_seconds)

Throughput only shows up if bench.py reports units with nodus.log.unit(id, ms) from the Python SDK, for example once per training step. At list prices the $25 cap covers about 11 minutes per cell, so raise max_cost for longer runs. Divide the B200's unitsPerSecond by the H100's. If the result is above 2.115, the B200 is cheaper per run at today's list prices.

Once you know, request the GPU you picked. The GPU guide shows the request format; this one asks for eight B200s and caps the hourly rate with some headroom over the $44.00 list price:

spec:
  resources:
    gpu: {type: B200, count: 8}
  placement:
    maxRateUSDPerHour: "50.00"

You can check the expected cost before anything starts with nodus apply -f job.yaml --dry-run=server -o estimate. Startup, idle time and redone work also change the per-run total; our post on what an H100 or B200 hour costs per finished job prices those for both GPUs.

Our decision rule: measure the speedup on 10 minutes of steady-state training from your real job. Above 2.115x, or whenever the B200 saves you a second node, use B200s. Between about 1.8x and 2.115x, where the B200 run costs up to about 18% more, use B200s only if finishing sooner is worth the gap shown in the table. Below that, stay on H100s.

FAQ

Is the NVIDIA B200 better than the H100?

It is the faster GPU, with 2.25x the memory and about 2x the measured training throughput at equal GPU count. Whether it is better value depends on the price ratio where you run it; on Nodus that ratio is 2.115x, so the two land close per finished job.

Will my H100 training code run on a B200?

Usually, if its kernels ship as PTX or as native Blackwell code, which needs CUDA 12.8 or later to build. NVIDIA's compatibility guide suggests testing with CUDA_FORCE_PTX_JIT=1; a binary that fails under it needs a rebuild for Blackwell.

Does training in FP4 make the B200 much faster?

Not by itself in the published results. The B200's dense FP4 peak is twice its FP8 peak. Yet the MLPerf B200 run that trained in NVFP4 was 2.04x its FP8 H100 counterpart, close to the 2.08x of the 8-bit run.

Should I skip the B200 and go straight to the B300?

Only if you need more than 180 GB per GPU or plan to train in FP4. NVIDIA lists the same dense BF16 and FP8 math for both, and the B300 is listed at $6.943/hr on the Nodus pricing page.

Originally published on the Nodus blog.