An A100 second costs about half an H100 second, but the A100 renders the clip 2.6 times slower. Half the price times 2.6 times the seconds gives 1.28 times the cost, so rent the faster GPU.

Which GPU should you rent for Wan 2.2, what does one clip cost, and can it render fast enough for an interactive video product? We answer all three with the Wan team's own measurements and our current GPU prices.

Wan 2.2 VRAM needs: which model needs how much memory

VRAM is the memory on the GPU itself. The model's weights and its working data must fit there while a clip renders.

Wan 2.2 offers two text-to-video models. T2V-A14B is a mixture-of-experts model: it holds two expert networks of about 14 billion parameters each, 27 billion in total. Parameters are the model's learned numbers. Only one expert runs at a time, so 14 billion parameters are active. All 27 billion still have to sit in GPU or system memory. A video starts as random noise. The high-noise expert lays out the scene in the early denoising steps. A denoising step is one pass that removes noise from the video, and the 14B model runs 40 of them by default. The low-noise expert then refines the detail.

TI2V-5B is the small model, with 5 billion parameters. It renders 720p at 24 frames per second on a consumer GPU with 24 GB, the RTX 4090. The previous release, Wan 2.1, had an even smaller 1.3B model that needs 8.19 GB of VRAM.

For the 14B model, the Wan team says its single-GPU 720p command needs a GPU with at least 80 GB of VRAM. That is their stated requirement, and it leaves headroom above the peak they measured. That command switches on two memory savers:

python generate.py --task t2v-A14B --size 1280*720 \
  --ckpt_dir ./Wan2.2-T2V-A14B \
  --offload_model True --convert_model_dtype \
  --prompt "A red fox runs through fresh snow at dawn."

A forward pass is one run of data through the network. The --offload_model flag moves the model to system memory (CPU RAM) after each forward pass. The --convert_model_dtype flag converts the weights to the 16-bit format set in the model's config. If memory still runs out, the --t5_cpu flag runs the text encoder on the CPU instead. The text encoder, a model called T5, reads your prompt.

With those flags, the Wan team measured a peak of 59.8 GB for a 720p clip on one GPU and 41.3 GB at 480p. If you use Diffusers, Hugging Face's Python library for diffusion models, its CPU offload and VAE tiling do a similar job. The VAE (variational autoencoder) turns the model's compressed output into pixels, and tiling decodes one tile at a time.

Which GPU fits Wan 2.2 at 480p and 720p

Our machine types pair each GPU with a fixed amount of system memory. That system memory matters, because the offload flags move parts of the model there.

GPUVRAMSystem memory14B at 480p (41.3 GB peak)14B at 720p (59.8 GB peak)
L40S48 GB128 GBFits, 6.7 GB to spareDoes not fit
A10080 GB120 GBFitsFits
H10080 GB180 GBFitsFits
H200141 GB200 GBFitsFits

The peaks come from the Wan team's runs on A100 and H100 GPUs. They did not test the L40S, so render one 480p clip there before you plan around it.

Both 80 GB GPUs hold the model. They differ in memory bandwidth, the speed at which the GPU reads its own memory. The H100 SXM, the server version of the card, reads 3.35 TB per second, and the A100 80GB SXM reads 2,039 GB per second. In the Wan table, the H100 rendered the 720p clip 2.6 times faster. Part of that gap comes from FlashAttention3, a faster version of the model's core attention computation. The Wan team used it only on Hopper GPUs, the generation that includes the H100.

Cost per clip: the faster GPU is the cheaper one

A clip's cost is the GPU time it holds, times the price of that time. Our GPU virtual machines bill per second, so the formula needs no rounding:

cost per clip = GPU-seconds per clip x price per GPU-second
price per GPU-second = on-demand price per GPU hour / 3,600
H100, 720p, 1 GPU: 1,041.5 s x $0.001303 = $1.36
A100, 720p, 1 GPU: 2,735.7 s x $0.000636 = $1.74

The table repeats the sum for both resolutions and both price types. Spot machines run the same GPUs for about 50% less, but we can reclaim them at any time.

GPU and resolutionRender time per clipOn demandSpot
H100, 720p1,041.5 s$1.36$0.69
A100, 720p2,735.7 s$1.74$0.90
H100, 480p326.9 s$0.43$0.22
A100, 480p785.7 s$0.50$0.26

This is a calculated example. The render times are the Wan team's averages after a warm-up run. A warm-up run is a first run they leave out, because it includes start-up time. The prices are from our compute page, read on 30 October 2026. The example leaves out model loading, failed renders and storage. It also assumes the GPU never waits.

So the H100 renders a clip for less, even though each of its seconds costs more. A batch of 100 clips at 720p takes 28.9 H100 hours and costs $135.68 on demand.

Calculated example. Horizontal bars show the cost of one five-second 720p clip from Wan 2.2's 14B model on one GPU: H100 on demand $1.36, highlighted; A100 on demand $1.74; H100 spot $0.69; A100 spot $0.90. The render times are the Wan team's measurements, multiplied by our GPU prices read on 30 October 2026.
Calculated example: with the Wan team's render times and our prices of 30 October 2026, one 720p clip costs less on our H100 than on our A100, on demand and on spot.

Waiting time changes that sum. A virtual machine bills for its whole uptime, whether it renders or waits for the next prompt. One H100 can finish 3.46 clips of 720p per hour. If it renders only one clip per hour, each clip costs 3.46 times the figure in the table. Our guide to GPU idle cost shows how to measure that waste.

One GPU per clip or eight GPUs per clip

The Wan team also split one clip across eight GPUs. Their multi-GPU runs used FSDP, which spreads the model's weights over the GPUs, and Ulysses. Ulysses cuts the video's long sequence of data into slices, and each GPU works on one slice.

H100, 720p, 1 GPU:   1,041.5 s wall clock = 1,041.5 GPU-seconds
H100, 720p, 8 GPUs:  155.1 s wall clock x 8 = 1,240.8 GPU-seconds
speed-up: 1,041.5 / 155.1 = 6.72x
extra GPU time: 1,240.8 / 1,041.5 - 1 = 19.1%

Wall-clock time is the time you wait for the clip. The clip arrives 6.72 times sooner, but it costs $1.62 instead of $1.36. For a queue of clips, run eight separate single-GPU workers on one eight-GPU machine instead. Each worker renders its own clip, and you pay no extra GPU time. Split one clip across eight GPUs only when one person waits for that clip.

Real-time video agents: can Wan 2.2 keep up with playback?

An interactive video agent answers a user with video while they wait. It works only when each segment renders faster than it plays. Otherwise the user sees the stream stop.

A default clip from the 14B model is 81 frames at 16 frames per second, so it plays for 5.06 seconds. Divide the render time by that playback time:

render time / playback time
720p, 1 H100:   1,041.5 s / 5.06 s = 206x slower than playback
720p, 8 H100s:    155.1 s / 5.06 s = 31x slower
480p, 8 H100s:     51.5 s / 5.06 s = 10x slower

None of the measured setups keeps up. Even the fastest one, 480p on eight H100s, needs 51.5 seconds of a whole eight-GPU machine for 5 seconds of video.

Horizontal bars show the seconds Wan 2.2's 14B model needed to render one clip that plays for 5.06 seconds: 1,041.5 seconds at 720p on one H100, 155.1 seconds at 720p on eight H100s, and 51.5 seconds at 480p on eight H100s. A highlighted dashed line near zero marks the 5.06 seconds of playback, and every bar ends far to its right.
In the Wan team's measurements, even eight H100s at 480p need 51.5 seconds for a clip that plays for 5.06 seconds.

A live session also holds its GPUs while the user reads or types. Loading the model again for each reply would add more delay, so the GPUs stay reserved and billed. Measure your duty cycle: the seconds spent rendering, divided by the length of the session. Then price the session as a whole:

session cost = GPUs held x session seconds x price per GPU-second
Hypothetical 10-minute session on 8 H100s, on demand:
8 x 600 s x $0.001303 = $6.25

Cheaper designs change the product, not the GPU. Rendering at 480p instead of 720p cuts the render time 3.2 times on one H100. Shorter segments and the 5B model cut it further. For most products, the honest design is a short wait: queue the prompt, render the clip, and notify the user.

Running Wan 2.2 on our GPU virtual machines

We are Lyceum, a sovereign European AI inference provider for open-source models. We build and run it in Europe, and our GPUs run in European data centres. On our per-token API, prompts and outputs are processed, not stored, and never used for training. For Wan 2.2, you bring the open weights to one of our GPUs. The Wan team publishes them under the Apache 2.0 license.

Launch an H100 virtual machine with the Lyceum CLI and your SSH public key. You get root access and pay per second while it runs.

lyceum vm start -h h100 -k "$(cat ~/.ssh/id_ed25519.pub)" -g 1
ssh lyceum@<ip-address>

On the machine, install Wan 2.2 and download the 14B model from Hugging Face:

git clone https://github.com/Wan-Video/Wan2.2.git && cd Wan2.2
pip install -r requirements.txt
pip install "huggingface_hub[cli]"
huggingface-cli download Wan-AI/Wan2.2-T2V-A14B --local-dir ./Wan2.2-T2V-A14B

Then run the 720p command from the first section. The machine's disk is wiped when you terminate it, so copy finished clips to your storage bucket first. Stop billing with lyceum vm terminate <vm_id>.

For a fixed queue of clips, package the same command in a Docker container. Our serverless training runs any container once on the GPU you choose, so it can render clips as well as train. It bills only while the job runs, so no machine waits between clips.

lyceum docker run your-team/wan22 -m gpu.h100 \
  -c "python generate.py --task t2v-A14B --size 1280*720 --ckpt_dir ./Wan2.2-T2V-A14B --offload_model True --convert_model_dtype --prompt 'A red fox runs through fresh snow at dawn.'"

Launch one H100, render one clip at your own resolution and prompt length, and multiply its seconds by your monthly volume.

Frequently asked questions

Can I call Wan 2.2 through your API?

Not today. Our per-token API serves the models listed on our models page, and Wan 2.2 is not among them. You run Wan 2.2 yourself on a GPU virtual machine or as a serverless training job.

How long does the smaller Wan 2.2 model take per clip?

The 5B model rendered a 720p clip in 534.7 seconds on one RTX 4090, with a 22.9 GB peak. Its clips run 121 frames at 24 frames per second, about 5 seconds, so it also renders far slower than playback.

Who owns the videos Wan 2.2 generates?

The Wan team licenses the models under Apache 2.0 and claims no rights over the content you generate. You remain responsible for how you use it.

Sources

  1. github.com
  2. github.com
  3. arxiv.org
  4. huggingface.co
  5. github.com
  6. huggingface.co
  7. nvidia.com
  8. nvidia.com
  9. arxiv.org
  10. github.com