News icon

Batch Inference is now generally available on Runpod Serverless

Wan 2.2 ComfyUI: Run Wan 2.2 on Runpod

Quick answer

To run Wan 2.2 in ComfyUI on Runpod, deploy the official ComfyUI template on a Secure Cloud pod, download the Wan 2.2 files to /workspace/runpod-slim/ComfyUI/models and open the Wan 2.2 template in ComfyUI. The 14B models need 24 GB of VRAM at 640x640 with fp8 weights. With the Lightning LoRA, a 5-second clip takes about 71 seconds instead of about 513.

Runpod, the AI developer cloud, gives you three ways to run Wan 2.2. A Public Endpoint returns a clip from a prompt and an image with nothing to deploy. A pod running ComfyUI gives you full control of the workflow. A Serverless endpoint running worker-comfyui turns that workflow into an API that scales to zero. This guide covers all three, starting with the pod, because that is where you build and tune the workflow. A 24 GB RTX A5000 pod costs $0.27/hr on Secure Cloud, billed per second, and current rates for every card are on the Runpod pricing page.

Key facts

ItemCurrent state (October 2026)Source
Open-weight Wan 2.2 modelsT2V-A14B, I2V-A14B, TI2V-5B, S2V-14B, Animate-14B and Animate-2-14BWan2.2 repository
LicenseApache 2.0Wan2.2 repository
14B architectureMixture of experts: two 14B experts, 27B parameters total, 14B active per stepWan2.2 repository
Native frame rate16 fps for the 14B models, 24 fps for TI2V-5BWan2.2 configs
Default clip length81 frames (about 5 seconds) for 14B, 121 frames for TI2V-5B; frame counts follow 4n+1generate.py
ComfyUI default for 14B20 steps at CFG 3.5, with an optional 4-step Lightning LoRA path at CFG 1ComfyUI workflow templates
Wan 2.2 Animate in ComfyUIOne 14B model (18.4 GB in fp8), Move and Mix modes, 77-frame segments at 16 fpsComfyUI Animate docs
Smallest practical GPU24 GB for 14B with fp8 weights at 640x640; TI2V-5B fits 8 GB with ComfyUI offloadingComfyUI docs, template notes
Official Runpod ComfyUI templateComfyUI with CUDA 12.8, ComfyUI-Manager, ComfyUI-KJNodes, Civicomfy and ComfyUI-RunpodDirect; installs to /workspace/runpod-slim/ComfyUIcomfyui-base
Pod billingPer second while the pod runsPod pricing docs
Wan 2.2 I2V 720p Public Endpoint$0.30 per 5 seconds of output as of October 2026Endpoint docs
Newer Wan versionsWan 2.5, 2.6 and 2.7 are API-only, with no open weightsAlibaba Cloud Model Studio

Choose how you will run Wan 2.2

Pick the Runpod product before you pick a model variant, because the product decides what you pay for and how much of the pipeline you control.

Decision diagram. If you do not need your own workflow or LoRAs, use a Wan Public Endpoint. If you will iterate by hand, run the ComfyUI template on a pod. If an application sends the requests, deploy worker-comfyui on Serverless.
Figure 1. Choose the product by who sends the request and how much of the pipeline you need to control.

What Wan 2.2 is

Wan 2.2 is Alibaba's open-weight video generation family, released on July 28, 2025 under the Apache 2.0 license. It generates video from text, from a start image, from speech and from a reference performance. ComfyUI supported it natively on release day, and its official templates are the most direct way to run it.

ModelTaskNative outputReleased
T2V-A14BText to video480p or 720p, 16 fpsJuly 28, 2025
I2V-A14BImage to video480p or 720p, 16 fpsJuly 28, 2025
TI2V-5BText or image to video in one model1280x704 or 704x1280, 24 fpsJuly 28, 2025
S2V-14BSpeech to video480p or 720pAugust 26, 2025
Animate-14BCharacter animation and replacement from a reference video720pSeptember 19, 2025
Animate-2-14BEnd-to-end character animation with text-driven viewpoint controlSee model cardAugust 7, 2026

Two corrections to what circulates about Wan 2.2. First, Wan 2.5, 2.6 and 2.7 are not newer open models you can download into ComfyUI. Alibaba serves them through its Model Studio API, and as of October 2026 none has public weights, so Wan 2.2 remains the newest Wan family you can run on your own GPU. Second, Wan 2.2 14B is not a single 14B network. It is two.

The 14B models are two experts that take turns

The A14B models use a mixture-of-experts (MoE) design with two experts of about 14B parameters each, 27B in total. The high-noise expert handles the early denoising steps, where the latent is mostly noise and the model is deciding layout and motion. The low-noise expert takes over for the later steps and refines texture and detail. Only one expert runs at each step, so compute per step stays at 14B parameters.

Bar diagram of denoising steps. In the default template the high-noise expert runs steps 0 to 10 and the low-noise expert runs steps 10 to 20. With the Lightning LoRA enabled the split is steps 0 to 2 and 2 to 4.
Figure 2. The split step decides when the low-noise expert takes over. The template exposes it as a number you can change.

This design has three practical consequences. You download two diffusion model files for every 14B task, and the text-to-video pair does not work for image-to-video. The ComfyUI workflow needs two model loaders and two KSampler (Advanced) nodes, one per expert. And memory planning works per expert: ComfyUI's model manager can keep the active expert on the GPU and move the idle one to system RAM, so a card that holds one expert can run the pair, at the cost of a transfer at the hand-off.

Alibaba's reference script switches experts at a signal-to-noise ratio (SNR) boundary, which falls at a timestep of 0.875 for text-to-video and 0.900 for image-to-video. ComfyUI's template approximates the boundary with a fixed split at the midpoint of the step count. If clips come out with good motion but soft detail, move the split one or two steps earlier so the low-noise expert gets more steps.

TI2V-5B trades quality for a much smaller footprint

TI2V-5B is a single dense 5B model that handles both text-to-video and image-to-video. It pairs with a new Wan 2.2 VAE (variational autoencoder) that compresses 4x16x16 across time, height and width, and with its patchify layer the total compression reaches 4x32x32. That compression is how it produces 720p at 24 fps from a 10 GB checkpoint. It is the right model for fast iteration on a small card. The 14B pair produces stronger motion and detail, and it is the model to use for final renders.

Wan 2.2 GPU requirements

VRAM decides the card. The weights of the expert that is running must fit in GPU memory alongside the activations for every frame in the clip, and activations grow with both resolution and frame count. Figure 3 shows the weights alone.

Horizontal bar chart of Wan 2.2 file sizes. TI2V-5B fp16 is 10.0 GB, one 14B expert in GGUF Q4_K_M is 9.7 GB, in fp8_scaled 14.3 GB and in fp16 28.6 GB. The umT5-XXL fp8 text encoder is 6.7 GB. Reference lines mark 24, 32 and 48 GB.
Figure 3. File sizes from the Comfy-Org and QuantStack repositories on Hugging Face. Each 14B model needs two expert files of the size shown.

The arithmetic follows from the file sizes. One 14B expert in fp8 is 14.3 GB, so it fits on a 24 GB card with about 10 GB left for activations at 640x640, which is the configuration ComfyUI's template authors measured at 83% to 89% VRAM use on a 24 GB GPU. The same expert in fp16 is 28.6 GB, so fp16 weights need a 48 GB card at 640x640 or 480p. A 1280x720 frame has 2.3 times the pixels of an 832x480 frame, and Alibaba's own script peaked at 59.8 GB on a single GPU at 720p versus 41.3 GB at 480p. That 59.8 GB peak is why 720p without offloading belongs on an 80 GB card. These GPU recommendations are derived from those figures rather than measured on each card, so treat the boundaries as starting points.

WorkloadVRAM guidanceSuggested GPUSecure Cloud rate
TI2V-5B at 1280x70424 GB (8 GB with ComfyUI offloading)RTX A5000 (24 GB)$0.27/hr
TI2V-5B on an inference-focused card24 GBL4 (24 GB)$0.69/hr
14B fp8 at 640x640 or 480p, 20 steps or Lightning24 GBRTX A5000 (24 GB)$0.27/hr
14B fp8 with headroom for longer clips or LoRAs48 GBRTX A6000 (48 GB)$0.69/hr
14B fp8 at 720p48 GBL40S (48 GB)$1.09/hr
14B fp16 weights at 640x640 or 480p48 GBL40S (48 GB)$1.09/hr
14B at 720p without offloading (59.8 GB peak in Alibaba's script)80 GBH100 SXM (80 GB) or RTX PRO 6000 (96 GB)$4.39/hr or $2.69/hr

Speed is the second axis. Alibaba's published benchmark for the 14B text-to-video model shows the H100 finishing a clip 2.4x faster than the A100 at 480p and 2.6x faster at 720p. Because pods bill per second, a faster card can cost less per clip even at a higher hourly rate, so compare cards on cost per finished clip, not on rate per hour.

Bar chart from the Wan 2.2 repository. On one GPU, T2V-A14B takes 13.1 minutes at 480p on A100 and 5.4 minutes on H100, and 45.6 minutes at 720p on A100 and 17.4 minutes on H100. Peak memory is 41.3 GB at 480p and 59.8 GB at 720p.
Figure 4. Single-GPU times from the computational efficiency table in the Wan 2.2 repository, measured with Alibaba's reference script at its default settings.

The two figures are not interchangeable with ComfyUI timings. Alibaba's script runs 40 steps by default and the ComfyUI template runs 20, so expect ComfyUI to finish faster on the same card. Use Figure 4 for the ratio between GPUs, not for an absolute time.

Run Wan 2.2 in ComfyUI on a Runpod pod

A pod is a container running on a dedicated GPU that you rent by the second and reach through your browser. The setup takes six steps.

1. Create an account and add credits

Sign up at runpod.io and add credits. Deploying a pod requires at least one hour of credit for the GPU you choose, and the pod bills per second from then on, as the pod pricing docs explain.

2. Create a network volume

A network volume is persistent storage that exists independently of any pod. Wan 2.2 makes it close to mandatory, because the 14B text-to-video files alone total 38 GB, and downloading them again every session wastes both time and GPU billing. Network volumes are available on Secure Cloud, and you attach one when you create the pod. It cannot be attached later. The network volume docs cover the details.

File tree of the ComfyUI models folder on the Runpod template, with four 14B fp8 experts at 14.29 GB each, the 5B model at 10.00 GB, four Lightning LoRAs totaling 4.92 GB, the umT5 text encoder at 6.74 GB and two VAEs. Totals are 38.0 GB for 14B text-to-video, 18.2 GB for the 5B model and 80.5 GB for everything.
Figure 5. A full Wan 2.2 setup needs about 80 GB. A 100 GB volume holds it with room for outputs.

Size the volume from Figure 5. A 100 GB volume holds every Wan 2.2 file the official templates use, and at the standard tier's $0.07/GB/month for the first 1 TB as of October 2026 it costs about $7 a month. The volume bills whether or not a pod is attached. You can increase its size later but never decrease it. Create it in a Secure Cloud datacenter that offers the GPU you plan to use, because later pods must deploy in the same datacenter to mount it.

3. Deploy the official ComfyUI template

In the Runpod console, start a new pod, choose your GPU and select the ComfyUI template, which Runpod maintains. Attach the network volume, which mounts at /workspace, and deploy on Secure Cloud. The template ships the current ComfyUI build on CUDA 12.8 with ComfyUI-Manager, ComfyUI-KJNodes, Civicomfy and ComfyUI-RunpodDirect installed. For Blackwell GPUs such as the B200, Runpod's documentation points to a separate ComfyUI template for Blackwell GPUs.

If you want the models downloaded for you, use the One Click - ComfyUI Wan2.1 - Wan 2.2 template on the Runpod Hub, published by HearmemanAI. It downloads models and workflows on first boot according to flags you set under Edit Template before you deploy, and every flag defaults to false. Set download_wan22 to true for Wan 2.2, and add download_wan21 or download_wan_animate if you want those workflows too. A pod with no flag set boots an empty ComfyUI whose workflows show blank model dropdowns. Three more settings matter before you deploy:

  • As of October 19, 2026 the template is built for CUDA 13.0 and above, so filter for GPUs whose host supports CUDA 13 when you choose the card. A host on an older driver may fail to start the container.
  • The template defaults to a 300 GB volume and a 300 GB container disk. Both bill at $0.10/GB/month while the pod runs, so the pair costs about $60 a month before any GPU time. Lower both if you only need Wan 2.2.
  • First boot takes 5 to 20 minutes depending on the flags. ComfyUI opens on port 8188 while models are still downloading, and the boot log is at /workspace/comfyui.log.

The author supports the template through a Discord server rather than Runpod support, so check its description for changes before you rely on these settings.

On first boot the official template copies ComfyUI into your workspace, which can take several minutes, and Runpod's documentation allows up to 30 minutes for a first start. ComfyUI is ready when the pod logs show this line:

[ComfyUI-Manager] All startup tasks have been completed.

4. Download the Wan 2.2 model files

Download models directly on the pod, because a datacenter connection is far faster than uploading from your machine. Open JupyterLab on port 8888 or the web terminal from the Connect panel and run the block below. It downloads the umT5 text encoder and the Wan 2.1 VAE that every 14B workflow shares, then both experts and both Lightning LoRAs for text-to-video and for image-to-video. Delete the two i2v lines if you only need text-to-video. The URLs point at the Comfy-Org repackaged files that ComfyUI's official templates load. The Wan 2.1 repository name ends in a lowercase repackaged and the Wan 2.2 repository name in a capitalized Repackaged, and both spellings are correct.

cd /workspace/runpod-slim/ComfyUI/models
HF=https://huggingface.co/Comfy-Org
wget -P text_encoders $HF/Wan_2.1_ComfyUI_repackaged/resolve/main/split_files/text_encoders/umt5_xxl_fp8_e4m3fn_scaled.safetensors
wget -P vae $HF/Wan_2.1_ComfyUI_repackaged/resolve/main/split_files/vae/wan_2.1_vae.safetensors
for f in high low; do
wget -P diffusion_models $HF/Wan_2.2_ComfyUI_Repackaged/resolve/main/split_files/diffusion_models/wan2.2_t2v_${f}_noise_14B_fp8_scaled.safetensors
wget -P loras $HF/Wan_2.2_ComfyUI_Repackaged/resolve/main/split_files/loras/wan2.2_t2v_lightx2v_4steps_lora_v1.1_${f}_noise.safetensors
wget -P diffusion_models $HF/Wan_2.2_ComfyUI_Repackaged/resolve/main/split_files/diffusion_models/wan2.2_i2v_${f}_noise_14B_fp8_scaled.safetensors
wget -P loras $HF/Wan_2.2_ComfyUI_Repackaged/resolve/main/split_files/loras/wan2.2_i2v_lightx2v_4steps_lora_v1_${f}_noise.safetensors
done

For TI2V-5B, download wan2.2_ti2v_5B_fp16.safetensors into diffusion_models and wan2.2_vae.safetensors into vae from the same Wan 2.2 repository. It uses the same text encoder. Each template also lists its files, with links and target folders, in a note on the canvas, so you can check names there.

5. Open ComfyUI and load the Wan 2.2 template

Open the pod's Connect panel and select the HTTP service on port 8188. Runpod serves it through a proxy URL of the form https://<pod-id>-8188.proxy.runpod.net. If the page returns a Bad Gateway error, ComfyUI is still starting, so wait two or three minutes and refresh. In ComfyUI, open Templates in the left sidebar and search for Wan 2.2, then select the 14B text-to-video or 14B image-to-video template.

Annotated screenshot of the Wan 2.2 14B image-to-video template in ComfyUI. Callouts mark the Load Image node, the prompt, width, height and duration, the high-noise and low-noise expert and LoRA selectors, the enable_turbo_mode toggle, the Save Video node, the model links note, the reference timing note and the Run button.
Figure 6. The template wraps the pipeline in one node, so the controls you need are all on its face.

The template collapses the pipeline into a single subgraph node. Its face exposes the prompt, width, height, duration, the four model and LoRA selectors and one toggle, enable_turbo_mode, which switches between the 20-step path and the 4-step Lightning path. Double-click the node to see the pipeline inside.

Annotated screenshot of the inside of the Wan 2.2 text-to-video subgraph in ComfyUI. Callouts mark the model loaders, the default 20-step settings, the Lightning LoRA group with 4-step settings, the Enable Lightning LoRA switch, the high-noise and low-noise KSampler Advanced nodes, the frame-count math and the Create Video node.
Figure 7. Inside the subgraph. One boolean routes the models, step count, split step and CFG through either the default or the Lightning path.

6. Generate a clip and retrieve it

Write the prompt, keep 640x640 and 5 seconds for the first run, and click Run. The first run is slower because ComfyUI reads both experts from disk. Save Video writes an MP4 under /workspace/runpod-slim/ComfyUI/output/video and previews it on the canvas.

Set FILEBROWSER_PASSWORD in the template's environment variables before you deploy. The pod's proxy URL is reachable by anyone who has it, and the default credentials are public.

To download outputs, open FileBrowser on port 8080 or JupyterLab on port 8888 from the Connect panel. The FileBrowser user is admin, and the password is the value of FILEBROWSER_PASSWORD, which defaults to adminadmin12 if you did not set it.

Stop the pod when you finish a session. Stopping halts GPU billing and keeps everything on the network volume. Terminate the pod when you no longer need that machine, and the volume remains for the next one.

Settings that change the result

Steps, CFG and the Lightning LoRA

The Lightning LoRAs from the LightX2V project are distilled adapters, one for each expert, that let Wan 2.2 14B generate in 4 steps without classifier-free guidance (CFG). The template authors measured the effect on a 24 GB GPU at 640x640.

Bar chart of seconds per 5-second clip on a 24 GB GPU at 640x640. 20 steps takes about 536 seconds on the first run and 513 on the second. 4 steps with the Lightning LoRA takes about 108 seconds on the first run and 71 on the second.
Figure 8. Timings published in ComfyUI's official Wan 2.2 templates.

The trade is control for speed. With CFG fixed at 1 the negative prompt has no effect, and a distilled 4-step run gives you less control over prompt detail than the full 20-step run, so compare both on your own prompts. Use Lightning to explore prompts, seeds and framing, then re-render the keepers with the 20-step path. The arithmetic makes the case: at about 71 seconds a clip, the template authors' 24 GB GPU renders about 50 Lightning clips per GPU-hour, against about seven clips per hour on the 20-step path. Those clip rates are derived from the template timings, not measured on Runpod, and a slower card renders fewer.

The LightX2V project has not released a 4-step LoRA for TI2V-5B, and the 4-step LoRA was not trained for S2V. ComfyUI's documentation warns that using it with S2V causes significant loss of motion and quality.

Resolution, frame count and frame rate

Wan 2.2 14B is trained at 832x480 and 1280x720 in landscape and portrait, and the official template defaults to 640x640. Width and height should be multiples of 16. Frame counts must take the form 4n+1, and the template enforces this by computing frames as duration multiplied by frame rate, plus one, so 5 seconds at 16 fps gives 81 frames. Keep the 14B models at 16 fps and TI2V-5B at 24 fps, the rates they were trained at.

Frame count and resolution both scale the latent the model denoises. Linear activations scale with the total token count either way, but attention cost grows faster than linearly, so cutting frames and cutting resolution are not exactly interchangeable once you are near the memory limit. Measure both on your own clip. If you downloaded fp16 experts instead of the fp8_scaled files in step 4, switch to fp8 first, because it halves each expert's footprint without changing the output size.

Prompts

Alibaba's prompt guide for Wan describes a prompt as subject, scene and motion, extended with aesthetic control and style. For image-to-video, the image already fixes the subject and scene, so the prompt should describe motion and camera movement. Wan 2.2 was trained with labels for lighting, composition, lens, shot size, camera angle and color tone, so terms such as rim light, golden hour, low angle, close-up, push in, orbit and tilt up steer it reliably. Keep orbits under about 45 degrees of arc, which Alibaba's guide recommends.

Low-angle close-up of a cyclist cresting a hill at golden hour, warm rim light,
shallow depth of field. The camera pushes in slowly as dust drifts across the frame.

Run Wan 2.2 Animate in ComfyUI

Wan 2.2 Animate-14B takes a reference image of a character and a driving video of a performer. It runs in two modes. Move transfers the performer's body movement and facial expressions onto the character in your image. Mix replaces the performer in the video with your character and keeps the video's background, with a relighting LoRA that matches the character to the scene's light and color tone. Unlike the text-to-video and image-to-video models, Animate is a single 14B network rather than an expert pair, so it loads one diffusion model file.

Animate model files and custom nodes

ComfyUI's official Wan 2.2 Animate template loads these files. The fp8 model from Kijai's repository is the template default, and the bf16 file is the full-precision alternative.

Folder under models/FileSizeSource
diffusion_modelsWan2_2-Animate-14B_fp8_e4m3fn_scaled_KJ.safetensors18.4 GBKijai/WanVideo_comfy_fp8_scaled
diffusion_models (alternative)wan2.2_animate_14B_bf16.safetensors34.6 GBComfy-Org Wan 2.2 repackaged
loraslightx2v_I2V_14B_480p_cfg_step_distill_rank64_bf16.safetensors0.74 GBKijai/WanVideo_comfy
lorasWanAnimate_relight_lora_fp16.safetensors1.44 GBKijai/WanVideo_comfy
clip_visionclip_vision_h.safetensors1.26 GBComfy-Org Wan 2.1 repackaged
text_encodersumt5_xxl_fp8_e4m3fn_scaled.safetensors6.74 GBShared with the 14B workflows
vaewan_2.1_vae.safetensors0.25 GBShared with the 14B workflows

The fp8 set totals about 28.8 GB on disk, so it fits on the same 100 GB network volume as the rest of Wan 2.2. The template also needs three custom node packs. ComfyUI-KJNodes, which provides the Points Editor, is preinstalled on the official Runpod template. Install comfyui_controlnet_aux, which provides the DWPose Estimator, and ComfyUI-segment-anything-2 through ComfyUI-Manager, then restart ComfyUI. If you deploy the HearmemanAI template instead, set download_wan_animate to true and it fetches the Animate workflows and models for you.

Generate an Animate clip

  1. Open Templates, search for Wan 2.2 Animate and load it. Replace the sample reference image and driving video with your own.
  2. Run the workflow once with the defaults. The DWPose Estimator converts the driving video into pose and face control videos, and the first run also loads the video's first frame into the Points Editor.
  3. For Mix, mark the performer in the Points Editor. Shift and left-click adds green points on the area to detect, and shift and right-click adds red points on areas to exclude. Segment Anything 2 turns those points into the character mask.
  4. For Move, disconnect the background_video and character_mask inputs from the WanAnimateToVideo node. Bypassing those nodes is not enough, because a bypassed node still passes the driving video through.
  5. Generate. The template renders 640x640 at 16 fps in 6 steps at CFG 1, using the Wan 2.1 LightX2V distillation LoRA. Each segment is 77 frames, about 4.8 seconds, and each copy of the Video Extend group adds another 77 frames.

Width and height must be multiples of 16, and the template defaults to a small size because Animate runs out of memory faster than the other 14B workflows. The fp8 model alone is 18.4 GB, which leaves about 5.6 GB on a 24 GB card for the CLIP vision encoder, the pose videos and activations. That estimate is derived from file sizes rather than measured, and it makes a 48 GB L40S at $1.09/hr or RTX A6000 at $0.69/hr on Secure Cloud the practical starting point for Animate. Keep driving videos short and downscaled, because preprocessing a large video takes a long time before sampling even starts.

Wan2.2-Animate-2-14B, released on August 7, 2026, replaces the separate motion extractor with end-to-end animation and adds text-driven viewpoint control. It ships as Base and Distilled versions, and the Distilled version runs in 10 steps without CFG. As of October 19, 2026, ComfyUI's official Animate template still loads Animate-14B, so check the Animate-2 model card for its ComfyUI workflow before you switch.

Use your own LoRAs

Style and character LoRAs for Wan 2.2 14B usually come in pairs, one for each expert, because each expert is a separate network. Load the high-noise LoRA on the high-noise model path and the low-noise LoRA on the low-noise path with LoraLoaderModelOnly nodes, and place the files in models/loras. LoRAs trained for Wan 2.1 were trained against a single network, so how well they transfer to either Wan 2.2 expert varies by LoRA. Test them on a fixed seed before you rely on them.

Civicomfy, preinstalled in the official Runpod template, downloads models and LoRAs from Civitai into the right ComfyUI folders from inside the interface.

Fit Wan 2.2 on a smaller card with GGUF

GGUF is a quantized weight format that ComfyUI loads through the ComfyUI-GGUF custom nodes. QuantStack publishes GGUF builds of the T2V, I2V, TI2V-5B, S2V and Animate models. The Q4_K_M build of one 14B expert is 9.7 GB, against 14.3 GB for fp8, which leaves more room for activations on a 24 GB card. Install ComfyUI-GGUF through ComfyUI-Manager, put the .gguf files in models/unet as the ComfyUI-GGUF README instructs, and replace each Load Diffusion Model node with Unet Loader (GGUF). Lower quantization levels cost detail, so compare Q4 and Q8 output on the same seed before you commit to one. Current ComfyUI treats unet as an alias of diffusion_models, so either folder works.

Run Wan 2.2 locally or on Runpod

Wan 2.2 runs locally if your GPU can hold the variant you want. TI2V-5B fits on 8 GB with ComfyUI's offloading, and Alibaba's reference script runs it on a single 24 GB GPU. The 14B models run in ComfyUI on 24 GB with fp8 weights and need system RAM to hold the idle expert. Without ComfyUI's offloading, Alibaba's script needs a GPU with at least 80 GB for the 14B models.

The local installation follows the same steps as the pod: install ComfyUI, download the files in step 4 into its models folders and load the template. Run locally when your card has the memory and you generate often enough that the hardware pays for itself. Rent a pod when you need more than 24 GB, want the faster H100 class for 720p, or generate in bursts. A Runpod pod also saves the setup itself, because the official template arrives with ComfyUI, its Manager and a matching CUDA build already installed.

Generate without setup through Public Endpoints

Public Endpoints are models that Runpod hosts and operates. You call them with an API key and pay per output, with no pod or worker to manage, and the Public Endpoints overview states that failed generations are not charged. The Wan 2.2 I2V 720p endpoint takes a prompt and a start image URL.

curl -X POST https://api.runpod.ai/v2/wan-2-2-i2v-720/runsync \
-H "Authorization: Bearer $RUNPOD_API_KEY" \
-H "Content-Type: application/json" \
-d '{"input": {
"prompt": "The camera slowly orbits the lighthouse as waves break below",
"image": "https://example.com/lighthouse.jpg",
"size": "1280*720",
"duration": 5,
"seed": -1}}'

The response returns output.video_url, which expires after seven days, and output.cost in US dollars. As of October 2026 the endpoint costs $0.06 per second of output, from $0.30 at 5 seconds to $0.90 at 15 seconds, so you can price any duration.

Public EndpointInputPrice as of October 2026
Wan 2.2 I2V 720pPrompt and start image$0.30 per 5 seconds
Wan 2.2 I2V 720p LoRA (the endpoint path reads wan-2-2-t2v-720-lora, which is correct)Prompt, start image and high-noise and low-noise LoRA lists$0.35 for 5 seconds, $0.56 for 8 seconds
Wan 2.5Prompt and start image, 480p to 1080p$0.25 to $0.75 per 5 seconds by resolution
Wan 2.6 T2VPrompt, 720p or 1080p, single or multi-shot$0.50 or $0.75 per 5 seconds by resolution
Wan 2.6 I2VPrompt, start image and optional audio, 720p or 1080p, 5 to 15 seconds$0.50 or $0.75 per 5 seconds by resolution

Public Endpoints suit prototyping and low volume. Once you need your own workflow, a fine-tuned LoRA outside the endpoint's inputs or a cost per clip below the per-output price, move to a pod or Serverless. Current prices for every model are on the Public Endpoints page.

Serve your workflow through Runpod Serverless

Runpod Serverless runs your container as workers that start when requests arrive and scale back to zero when the queue empties. The worker-comfyui image runs any ComfyUI workflow as an API, so the Wan 2.2 workflow you tuned on a pod becomes the request body.

Flow diagram. An application posts a workflow and optional base64 images to the endpoint's run route. Jobs queue at the endpoint, a worker runs the ComfyUI graph with models from the network volume, and the output returns as base64 or an S3 URL.
Figure 9. worker-comfyui accepts the workflow in the request and returns the saved video.
  1. Export the workflow from ComfyUI with Workflow, then Export (API). The worker accepts only the API format.
  2. Attach a network volume that holds the models. On Serverless it mounts at /runpod-volume, and the worker's path map uses the older ComfyUI folder names: put the experts in /runpod-volume/models/unet, the text encoder in models/clip, and the VAE and LoRAs in models/vae and models/loras. A volume laid out for the pod template, with diffusion_models and text_encoders under /workspace/runpod-slim/ComfyUI/models, will not be found.
  3. Build an image from runpod/worker-comfyui:<version>-base if the workflow uses custom nodes, because custom nodes cannot load from the volume. Install them in the Dockerfile with comfy-node-install.
  4. Send the workflow in input.workflow and any start image as base64 in input.images, then read the result from output.images.
{
"input": {
"workflow": { "...": "API-format export of your Wan 2.2 workflow" },
"images": [{ "name": "start.png", "image": "" }]
}
}

Two details decide whether the video comes back. The worker collects outputs that ComfyUI reports under images, and the core Save Video node reports there, so keep it as the output node. Video Helper Suite's Video Combine node reports under a different key, and the worker skips it with a warning. Request payloads cap at about 10 MB on /run and 20 MB on /runsync, and results come back base64-encoded by default, so configure an S3-compatible bucket through the worker's BUCKET_ENDPOINT_URL, BUCKET_ACCESS_KEY_ID and BUCKET_SECRET_ACCESS_KEY variables before you serve 720p clips.

Flex workers scale to zero, so an idle endpoint costs nothing, and FlashBoot delivers sub-200ms cold starts by reviving a worker's retained state. A worker starting fresh still has to read both 14 GB experts from the volume before its first job, so the first request after a long idle period waits for that load. Keep a minimum of one active worker only if your application cannot tolerate that delay, because an active worker bills around the clock. On the 24 GB card group that covers the L4 and RTX A5000, Flex workers run $0.75/hr. The 14B workflow at 720p needs a 48 GB or 80 GB group, which the Serverless pricing docs list.

Fix common Wan 2.2 problems

SymptomLikely causeFix
Model files show as missing when the template loadsFiles are in the wrong folder or under a different nameCompare names against the template's model note and place them under /workspace/runpod-slim/ComfyUI/models
CUDA out-of-memory at the start of samplingfp16 experts, or resolution and frame count too high for the cardSwitch to fp8_scaled or GGUF experts, cut frames or resolution, or move to a 48 GB card
Bad Gateway when opening port 8188ComfyUI is still copying or startingWatch the logs for the startup-complete line, then refresh
Image-to-video errors or ignores the start imageThe text-to-video experts are loaded in the image-to-video workflowLoad the wan2.2_i2v expert pair and its matching LoRAs
Good motion but soft, smeared detailThe low-noise expert gets too few stepsMove the split step earlier, or render the final clip on the 20-step path
Negative prompt has no effectThe Lightning path runs at CFG 1Turn off enable_turbo_mode for that render
HearmemanAI template opens with blank model dropdownsNo download flag was set before deploying, so no models were fetchedSet download_wan22 to true under Edit Template and redeploy
Serverless worker cannot find the Wan modelsModels are in diffusion_models or text_encoders, which the worker does not mapMove experts to models/unet and the text encoder to models/clip on the volume
Serverless job succeeds with no videoThe output node is Video Combine, not Save VideoSave with the core Save Video node
Models gone after terminating the podFiles were on the pod's volume disk, not a network volumeAttach a network volume at deployment and keep models on it

Get started

Pick the path that matches Figure 1:

  • To try Wan 2.2 with no setup, open the Wan 2.2 I2V 720p Public Endpoint in the Runpod console and send a prompt and a start image.
  • To build a workflow, create a 100 GB network volume on Secure Cloud, deploy the official ComfyUI template on an RTX A5000 with the volume attached, download the files from step 4 and load the Wan 2.2 template.
  • To serve the workflow, export it in API format and deploy worker-comfyui on a Serverless endpoint with the same volume attached.

The Runpod ComfyUI tutorial and network volume documentation cover the platform steps in more detail.

FAQs

What is Wan 2.2?

Wan 2.2 is Alibaba's open-weight video generation model family, released in July 2025 under the Apache 2.0 license. It includes 14B mixture-of-experts models for text-to-video and image-to-video, a 5B model that handles both, and later speech-to-video and character animation models.

What GPU do I need for Wan 2.2?

TI2V-5B fits on 8 GB with ComfyUI's offloading and runs comfortably on 24 GB. The 14B models need 24 GB with fp8 weights at 640x640 or 480p, 48 GB for fp8 at 720p or fp16 weights at 640x640, and 80 GB for 720p without offloading. An RTX A5000 on Runpod Secure Cloud costs $0.27/hr.

How much VRAM does Wan 2.2 14B use?

One 14B expert is 14.3 GB in fp8 and 28.6 GB in fp16, and each model has two experts. ComfyUI keeps only the active expert on the GPU when memory is tight, so a 24 GB card runs the fp8 pair at 640x640 at about 83% to 89% VRAM use according to the template authors' measurements.

Can I run Wan 2.2 locally?

Yes, if your GPU holds the variant you choose. Install ComfyUI, download the model files into its models folders and load the Wan 2.2 template. TI2V-5B runs on 8 GB to 24 GB cards, and the 14B models need 24 GB with fp8 weights plus enough system RAM for the idle expert.

How long does Wan 2.2 take to generate a video?

On the template authors' 24 GB GPU at 640x640, the 14B template takes about 513 seconds for a 5-second clip at 20 steps and about 71 seconds with the 4-step Lightning LoRA, after the first run. Alibaba's benchmark puts a 720p clip at 17.4 minutes on one H100 with its reference script.

What is the Wan 2.2 Lightning LoRA?

It is a pair of distilled LoRAs from the LightX2V project, one per expert, that let Wan 2.2 14B generate in 4 steps without classifier-free guidance. The official ComfyUI templates include it behind the enable_turbo_mode toggle. It cuts generation time by 5x to 7x, and with CFG at 1 the negative prompt stops having an effect.

What is the difference between Wan 2.1 and Wan 2.2?

Wan 2.2 splits the 14B model into a high-noise and a low-noise expert, trains on 65.6% more images and 83.2% more videos than Wan 2.1, and adds aesthetic labels for lighting, composition and color. The 14B models reuse the Wan 2.1 VAE, while the new 5B model uses a higher-compression Wan 2.2 VAE. Wan 2.2 14B workflows need two model loaders and two samplers, so Wan 2.1 workflows do not load it unchanged.

What is Wan 2.2 Animate?

Wan 2.2 Animate-14B, released in September 2025, animates a character image with the movement and expressions of a performer in a driving video, or replaces the performer with your character. ComfyUI ships an official Animate template that needs about 28.8 GB of model files with fp8 weights and a 48 GB GPU in practice. Animate-2-14B followed in August 2026 with end-to-end animation and text-driven viewpoint control.

Is Wan 2.5 or Wan 2.6 available as open weights?

No. As of October 2026, Wan 2.5, 2.6 and 2.7 are available only through Alibaba's Model Studio API, and Wan 2.2 is the newest open-weight Wan release. Runpod offers Wan 2.5 and Wan 2.6 as Public Endpoints.

Is Wan 2.2 or Wan 2.5 better?

They answer different needs. Wan 2.2 has open weights, so you run it on your own GPU with your own LoRAs, workflow and settings, and you pay only for GPU time. Wan 2.5 is API-only: on Runpod's Public Endpoint it renders 480p to 1080p clips of 5 or 10 seconds per call with nothing to deploy, and you pay per output. Choose Wan 2.2 for control and volume, and Wan 2.5 for higher resolution without managing a pod.

Is Wan 2.2 free?

The model weights are free. Wan 2.2 is released under the Apache 2.0 license, which permits commercial use. The GPU that runs it is not free: on Runpod you pay per second for a pod, or per 5 seconds of output on a Public Endpoint.

How much does it cost to run Wan 2.2 on Runpod?

On a pod you pay for GPU time per second, such as $0.27/hr for an RTX A5000 on Secure Cloud, plus network volume storage at the standard tier's $0.07/GB/month for the first 1 TB as of October 2026. The Wan 2.2 I2V 720p Public Endpoint costs $0.30 per 5 seconds of output.

Where does ComfyUI save Wan 2.2 videos on Runpod?

On the official Runpod ComfyUI template, Save Video writes MP4 files under /workspace/runpod-slim/ComfyUI/output/video. Download them through FileBrowser on port 8080 or JupyterLab on port 8888.

What is the Runpod FileBrowser login?

On the official ComfyUI template, the FileBrowser user is admin and the password is the value of the FILEBROWSER_PASSWORD environment variable, which defaults to adminadmin12. Change it before you deploy.

Can I use Wan 2.2 as an API?

Yes. For hosted models with no setup, call the Wan 2.2 Public Endpoints. For your own workflow, export it from ComfyUI in API format and deploy worker-comfyui on Runpod Serverless, where workers scale to zero when idle.

Related guides

Purple glow background

Build what’s next.

Build, train, and scale AI workloads on Runpod with cloud GPUs, Serverless, and Clusters.

Star field background