MiniMax H3 Cloud GPU Benchmark: Speed and Cost Per Dollar Across Four Platforms and Four Cards

As text-to-video (T2V) generation moves into practical territory, inference speed and cost have become the most concrete factors developers consider when choosing a stack. One developer who is actively building a service around MiniMax H3 published a self-funded benchmark on Reddit: using identical weights, compute graphs, and random seeds, they ran MiniMax H3 T2V tasks on four GPU types across four cloud platforms, logging the time and cost for every video generated. The total bill came to just $1.67 — but the details are worth a close read.

For full disclosure: the author acknowledges they are a stakeholder (building a related service), but every number comes from real paid runs, and raw CSV data is provided for verification. That transparency makes this comparison genuinely useful.

Methodology: Minimizing Variables

The real value of this benchmark is its rigorous variable control. The task was fixed: MiniMax H3 T2V, 5-second clips, 864×480 resolution (the 0.4 MP tier in the template), 20 sampling steps, using the standard T2V compute graph from ComfyUI v0.35.0 and the official int8_convrot weights.

The model footprint is substantial — a 34 GB DiT backbone, a 27 GB Qwen3-VL encoder, plus the VAE, totaling 67 GB. No LoRA or reference frames were used. Every card ran the same prompt and seed, and everything ran on torch cu130 to ensure the int8 kernels were native rather than emulated.

Each card generated three videos. The author distinguishes between two cost definitions: steady refers to the average of videos 2 and 3, billed at the actual paid rate (including disk and public IP); session covers the full platform bill for the entire workflow — image pull, 67 GB download, first-video cold start, and idle minutes before instance teardown — divided by three. This distinction matters enormously for short workloads.

Four Platforms, Four Cards: Who's Fast, Who's Cheap

Here are the results:

Platform	GPU	vCPU/RAM	Seconds/video	Steady $/video	Session $/video
Vast.ai (spot $0.40/h)	RTX 4090 24GB	32/108GB	93	$0.013	$0.17
Hyperstack (spot $2.00/h)	H100 PCIe 80GB	28/177GB	67	$0.038	$0.13
RunPod Secure ($0.74/h)	RTX 4090 24GB	15/86GB	92	$0.019	$0.07
Nebius (preemptible $0.92/h)	L40S 48GB	24/94GB	89	$0.024	$0.19

On steady-state cost, Vast.ai's spot RTX 4090 leads at $0.013 per video — remarkably cost-efficient. On session cost, however, RunPod comes out on top at $0.07 per video, thanks to tighter control over overall workflow overhead.

This data reveals a counterintuitive pattern: on a pure per-video steady-state basis, a consumer-grade 4090 is nearly three times cheaper than a data-center H100, because the H100's hourly rental rate far outpaces the speed advantage it delivers. For short-clip rendering tasks, the H100's computational edge simply doesn't justify its premium.

Two Surprising Findings

The author highlights two results that defied expectations.

First, the L40S performs closer to the 4090 than to the H100. Per-step latency on both 24 GB cards and the L40S was 3.97 seconds, while the H100 PCIe clocked in at just 2.99 seconds. Despite sitting above the 4090 in the product stack, the L40S showed no meaningful speed advantage on this int8 workload.

Second, the 4090 handled the 34 GB DiT through ComfyUI's dynamic VRAM path. The 24 GB card streamed weights on-the-fly, holding only 23 GB in VRAM at any time — but at the cost of consuming 68 GB of host RAM. This means the "≥ 64 GB RAM" requirement in the official documentation is not a suggestion: three of the four test machines peaked at 68 GB. Host memory is a hard requirement for running this model on consumer GPUs.

Where Does the Money Go on Short Jobs?

For on-demand workloads running just a few videos, the bulk of the cost isn't inference — it's session overhead.

Weight download speeds varied dramatically across platforms: Vast host hit 450 MB/s, Hyperstack 370, RunPod 210, and Nebius only 104 MB/s. Slower downloads mean longer idle billing while the instance sits waiting.

Nebius was the most problematic in this regard — the first video took 11.5 minutes because weights had to be read back from network disk, while cold starts on other platforms took just 1.8 to 2.7 minutes. Additionally, the watchdog process responsible for tearing down the instance adds another 2 to 3 billable minutes on every platform.

One more hidden cost: the steady-state numbers don't include text encoder overhead, since the prompt was identical across runs and ComfyUI cached it. Switch to a new prompt and each video adds 15 to 25 extra seconds — a meaningful hidden cost for production workloads that cycle through prompts frequently.

Practical Takeaways for Platform Selection

This benchmark offers a few clear lessons for developers building video generation services or running their own inference.

For sustained, high-volume batch workloads, steady-state cost dominates, making Vast.ai's spot 4090 the most economical choice. For sporadic short jobs, session overhead is the deciding factor — you want fast image pulls, fast weight loading, and minimal teardown billing, where RunPod performs best.

The broader insight is this: for int8-quantized workloads like T2V generation, throwing expensive flagship datacenter hardware at the problem isn't necessarily the right move. Consumer GPUs paired with sufficient host memory and mature VRAM streaming solutions can hold a genuine cost advantage. Of course, the author's role as a service provider is a reminder that any benchmark like this should be validated against your own workload — fortunately, they've made per-node timing, nvidia-smi traces, and raw CSVs all publicly available.