Upscale video with SeedVR2 in ComfyUI on a cloud GPU

SeedVR2 is the open video upscaler I would use when the result has to stay faithful to the source: ByteDance Seed's one-step diffusion restoration model, in 3B and 7B sizes, under Apache-2.0. Since ComfyUI v0.28.0 it runs natively, and the custom node ByteDance's own README credits, numz's ComfyUI-SeedVR2_VideoUpscaler, is at version 2.5.24 from December 2025. That node's own documentation says 24 GB runs the 16-bit models without memory tricks, but 4K output is where the card size starts to show: a 4K frame has four times the pixels of a 1080p one, so on a small card you trade frames per batch, and with them temporal consistency, for memory. I would upscale to 1080p on an RTX A6000 and take 4K with the 7B model to the 96 GB RTX PRO 6000.

What SeedVR2 is#

SeedVR2 restores and upscales video, and single images, in one diffusion step. ByteDance Seed released it in June 2025 and it was accepted at ICLR 2026. Its weights come in three versions, and ByteDance's repositories, Comfy-Org's and the community ones I checked are all Apache-2.0, which allows commercial use.

Every version shares one VAE, 0.50 GB at fp16. ByteDance's own limits are worth reading before you start: the model can fail on heavy degradation or very large motion, and it tends to over-generate detail on inputs with very light degradation, its example being 720p AI-generated video. That last one matters if you upscale clips from a video model, so compare the 3B and 7B results on your own footage.

Native nodes or the custom node#

There are two ways to run SeedVR2 in ComfyUI, and they load different files.

The custom node is the one ByteDance's README credits for the ComfyUI integration, and it has the finer memory controls. Its repository has had no commit since December 2025, while the native nodes ship with every ComfyUI release, so for a new setup on a 48 GB card I would start with the native template and reach for the custom node when I want BlockSwap or its batch controls.

The settings that decide memory#

The rule I follow is that resolution and frames per batch set the memory, and everything else is a way to buy some of it back with time.

The custom node's README is explicit about the order: if batch_size 5 runs out of memory, try offloading, BlockSwap and smaller files before you lower the batch or the resolution, because those two cut quality. It also warns that the VAE's encoding and decoding can be the slowest stages at high resolutions, and suggests a large batch_size to offset that. The native Split SeedVR2 Latent node, in its default auto mode, predicts the largest chunk of frames that fits the free VRAM, so on a bigger card it simply takes longer chunks.

What the node's documentation says about VRAM#

These are the custom node's own figures and example setups, from its README.

ByteDance's own reference code, whose README lists a tiled VAE as future work, sets a higher bar: one H100 80GB handles 100 frames at 720 by 1280, and 1080p and 2K need four H100 80GB cards with sequence parallelism. The ComfyUI nodes reach far lower figures because they tile the VAE and split the frames.

Why 4K is a job for a 48 or 96 GB card#

The honest answer is that SeedVR2 runs on small cards only by giving something up. A 4K frame has 4.0 times the pixels of a 1080p frame, and the memory for the diffusion pass and the VAE grows with pixels and with the frames you process together. On an 8 to 16 GB card the README's recipes lean on GGUF files, BlockSwap and five-frame batches, and five frames is the minimum it gives for temporal consistency.

The 7B model at fp16 with its VAE is 16.98 GB, which is 15.82 GiB (our calculation). On a 48 GB card that leaves 25.6 GiB of the 41.39 GiB budget for activations, and the README's example for 24 GB and more runs 7B sharp at fp16 with 81-frame batches at 1080p, so 1080p needs no BlockSwap there. On the 96 GB RTX PRO 6000 it leaves 72.1 GiB of 87.95 GiB. That is the headroom I want for 4K, where every frame carries four times the pixels, so the batches can stay long without swapping blocks to system RAM. The RAM matters too, because BlockSwap and offloading park weights there: RTX A6000 1x offers had 24 to 64 GB of RAM on 2026-09-27, against 144 GB on the RTX PRO 6000 1x.

The RTX PRO 6000 Blackwell page lists its configurations with RAM and disk. For long videos on two GPUs, the custom node's command-line tool splits the frames across them, with each GPU loading its own copy of the model, and ComfyUI with more than one GPU covers the options inside ComfyUI itself.

FlashVSR, the faster alternative#

FlashVSR is the upscaler to try when time matters more than fidelity. It is an Apache-2.0 one-step streaming model from OpenImagingLab, built for 4x upscaling, and its authors report about 17 frames per second at 768 by 1408 on one A100. ComfyUI's own comparison of 10-second 720p clips put local FlashVSR at about 41 seconds to 1080p, on a GPU the table does not name, against about 312 seconds for SeedVR2 on an RTX 5090, and its docs file SeedVR2 under quality and archival restoration. Two cautions come from FlashVSR's own README. Its fast sparse-attention backend works best on the A100 and A800, gives a limited speedup on the H200, and is of unknown performance on other GPUs. And some ComfyUI ports drop that attention module and lose quality, so use smthemex/ComfyUI_FlashVSR, version 1.2 from October 2026, which the authors describe as closer to the official implementation. ComfyUI runs FlashVSR itself only as a paid API node. RelayVSR, a newer Apache-2.0 model, became native in ComfyUI 0.45 with a 2x template.

Launch ComfyUI and download the files#

The quickest route is QuantaCloud's ComfyUI template. Launch it on the GPU from the table, wait for Running, and connect over SSH as ubuntu. Running ComfyUI on a cloud GPU walks through the template and the install-it-yourself route.

The native nodes need ComfyUI 0.28.0 or later, the minimum ComfyUI's template index gives every SeedVR2 template, and ComfyUI was at v0.45 on 2026-11-12. The version inside QuantaCloud's template is not published yet, so check it first:

curl -s http://127.0.0.1:8188/system_stats | python3 -c 'import json, sys; print(json.load(sys.stdin)["system"]["comfyui_version"])'

On the template, ComfyUI runs in a Docker container. These lines find the container by its published port and ask the running ComfyUI where its models folder is. The /internal route belongs to ComfyUI's own frontend and can change between releases, so check the path it prints:

C=$(sudo docker ps -q --filter publish=8188)
MODELS=$(curl -s http://127.0.0.1:8188/internal/folder_paths | python3 -c 'import json, os, sys; print(os.path.dirname(json.load(sys.stdin)["checkpoints"][0]))')
echo "$MODELS"

Save the file list for the native nodes as models.txt. None of these files is gated:

# The VAE every SeedVR2 version uses, 0.50 GB
vae              https://huggingface.co/Comfy-Org/SeedVR2/resolve/main/vae/seedvr2_ema_vae_fp16.safetensors

# 3B INT8, the native video template's model, 3.46 GB
diffusion_models https://huggingface.co/Comfy-Org/SeedVR2/resolve/main/diffusion_models/seedvr2_3b_int8_convrot.safetensors

# 7B at fp16 for 4K on the 96 GB card, 16.48 GB
diffusion_models https://huggingface.co/Comfy-Org/SeedVR2/resolve/main/diffusion_models/seedvr2_7b_fp16.safetensors
# or the sharp version, the same size:
# diffusion_models https://huggingface.co/Comfy-Org/SeedVR2/resolve/main/diffusion_models/seedvr2_7b_sharp_fp16.safetensors

Then save the download script as get-models.sh. It skips files that are already there:

#!/usr/bin/env bash
# Usage: MODELS=/path/to/ComfyUI/models bash get-models.sh models.txt
set -euo pipefail
MODELS="${MODELS:-$HOME/comfy/ComfyUI/models}"
AUTH=()
if [ -n "${HF_TOKEN:-}" ]; then AUTH=(-H "Authorization: Bearer $HF_TOKEN"); fi

while read -r folder url; do
  case "$folder" in ""|\#*) continue ;; esac
  dest="$MODELS/$folder/$(basename "$url")"
  if [ -s "$dest" ]; then echo "already there: $dest"; continue; fi
  mkdir -p "$MODELS/$folder"
  echo "downloading $dest"
  curl -fL --retry 3 "${AUTH[@]}" -o "$dest.part" "$url"
  mv "$dest.part" "$dest"
done < "${1:-models.txt}"

Run it inside the template's container, or directly on your own install:

sudo docker cp get-models.sh "$C":/tmp/ && sudo docker cp models.txt "$C":/tmp/
sudo docker exec -e MODELS="$MODELS" "$C" bash /tmp/get-models.sh /tmp/models.txt

# on your own install instead:
MODELS=~/comfy/ComfyUI/models bash get-models.sh models.txt

Stopping a QuantaCloud instance deletes it and its disk, and there are no volumes, so this download happens on every launch. Loading models on a new ComfyUI instance covers faster tools for large sets.

Upscale a clip#

The native template is the shortest path. Press r so the loaders see the new files, open the Templates icon in the sidebar and search for SeedVR2.

1. Pick SeedVR2 3B Int8: Upscale Video, and load your clip in the Load Video node.
2. Set the scale multiplier on the subgraph node. It is 2 by default, so a 720p clip comes out at 1440p.
3. For the 7B model, select seedvr2_7b_fp16.safetensors in the subgraph's model loader.
4. Queue with Ctrl+Enter. The Save Video node writes the result under output/video.

The template samples one step at CFG 1 with euler, tiles the VAE at 512 pixels, and lets Split SeedVR2 Latent choose the chunk size. Its own note gives the fix for a clip that runs out of memory: turn on trim_video, upscale shorter segments, and join them. If an INT8 run returns all-black frames, ComfyUI's SeedVR2 tutorial says to start ComfyUI without FlashAttention, then try the fp16 or fp8 file.

For BlockSwap, install the custom node from the Manager by searching for ComfyUI-SeedVR2_VideoUpscaler, or with comfy node install seedvr2_videoupscaler@2.5.24 on your own install, then restart ComfyUI. It downloads its own model files into models/SEEDVR2 the first time a workflow runs, and ComfyUI's Video Upscale: SeedVR2 template is built on it, with resolution set to the output height and batch_size 5. Installing ComfyUI-Manager and custom nodes covers what the Manager allows on a remote server.

Save your clips before you stop#

Copy the videos off the instance before you press Stop, every time, because Stop deletes the disk. On the template, copy them out of the container first, in the same session where you set C and MODELS:

COMFY=$(dirname "$MODELS")
sudo docker cp "$C:$COMFY/output" ~/comfy-output
sudo chown -R ubuntu: ~/comfy-output

Then pull the folder to your own machine with rsync -avP ubuntu@<instance-ip>:comfy-output/ ./comfy-output/. Moving files to and from a GPU server covers the other ways.

SeedVR2 questions#

How much VRAM does SeedVR2 need?

The custom node's README gives 24 GB for the 16-bit models without memory optimizations, and 8 GB or less with GGUF files, BlockSwap and VAE tiling. Output resolution and frames per batch decide the rest, which is why 4K with the 7B model is a job for a 48 or 96 GB card.

Is SeedVR2 free for commercial use?

Yes. ByteDance releases SeedVR2 under Apache-2.0, and the ComfyUI files from Comfy-Org and the custom node are Apache-2.0 as well.

Should I use SeedVR2 3B or 7B?

Start with 3B for speed and drafts, and use 7B, or 7B sharp for soft sources, for the final pass. On a 48 GB card both fit at 16-bit with room for long batches at 1080p.

Is SeedVR2 natively supported in ComfyUI?

Yes, since ComfyUI v0.28.0 in July 2026, with templates for video and single images. The numz custom node still works and adds BlockSwap.

My decision rule for SeedVR2: the native 3B INT8 template on an RTX A6000 for 1080p and 1440p, the 7B model at fp16 on the RTX PRO 6000 Blackwell for 4K, and FlashVSR only when the deadline beats the detail. Test on a short clip first, and copy the results off before you stop. Open-source video generation models covers the models that make the clips, and the ComfyUI page lists every GPU with the template and its live price.