ComfyStream Quickstart

Run ComfyStream on RunPod, Docker, or local install. First real-time AI effect on a webcam in fifteen minutes.

---

By the end of this quickstart you’ll have a ComfyStream instance running with a StreamDiffusion workflow applied to your webcam in near real-time. The final section covers how to connect that instance to the Livepeer network as a BYOC capability.

Three deployment paths fit different starting points. Pick one.

Path	Best for	Requires
RunPod	Fastest start, no local GPU	RunPod account
Docker	Local GPU or owned cloud server	Docker + NVIDIA GPU, Linux
Local install	Existing ComfyUI setup	Miniconda, NVIDIA GPU, Linux

Required Tools

ComfyStream requires an NVIDIA GPU with 12 GB VRAM minimum (16 GB recommended). The server component is Linux-only; Windows and macOS host the browser client only.

VRAM source: the . CUDA 12.0+ required; current releases target CUDA 12.8 with NVIDIA driver 570.124.06 or later.

Browser: Chrome or Firefox for the ComfyStream UI.

RunPod Path

The fastest start. RunPod hosts the GPU; the browser does the rest.

1. Deploy the ComfyStream template

   Open the livepeer-comfystream template in the RunPod marketplace and select a GPU pod. An RTX A4000 or A40 is a reasonable starting point for StreamDiffusion workflows.

   Click Deploy and wait for the pod status to show Running.

2. Connect to the pod

   Click Connect in the RunPod panel. ComfyStream exposes two HTTP services on the pod:

   • Port 8188: ComfyUI interface
   • Port 8889: ComfyStream WebRTC server

   Open the HTTP service on port 8889. The ComfyStream browser UI loads with a camera input selector and a workflow panel.

Skip to .

Docker Path

For a local GPU or a cloud server you control.

1. Pull the image

   docker pull livepeer/comfystream
   
2. Run the container

   docker run --gpus all \
     -p 8188:8188 \
     -p 8889:8889 \
     livepeer/comfystream
   

   The minimum flags above start the server. Production deployments add workspace and model volume mounts; the full options are in the ComfyStream Docker reference at docs.comfystream.org.

3. Open WebRTC ports

   On a remote server, allow inbound and outbound UDP traffic on ports 1024-65535. WebRTC peer connections fail without this.

   For environments where only a subset of UDP ports is available, pass --media-ports 1024,1025,... to the server command to restrict the range.

4. Open the UI

   Open http://localhost:8889 (local) or your server’s public IP on port 8889. The ComfyStream UI loads.

Skip to .

Local Install Path

For an existing ComfyUI setup or anyone wanting a Python environment to inspect.

1. Create a conda environment

   conda create -n comfystream python=3.12
   conda activate comfystream
   
2. Install ComfyStream

   pip install git+https://github.com/livepeer/comfystream.git
   
3. Install auxiliary custom nodes

   For standalone ComfyStream (not inside an existing ComfyUI install), copy the auxiliary custom nodes into your ComfyUI custom_nodes folder. The exact list is in the livepeer/comfystream README.

4. Download models

   python src/comfystream/scripts/setup_models.py --workspace /path/to/ComfyUI
   
5. Start the server

   python server/app.py --workspace /path/to/ComfyUI
   

   The server starts on port 8889. Open http://localhost:8889 in a browser.

Workflow Loading

1. Pick a starter workflow

   In the ComfyStream UI, open the workflow panel and choose a StreamDiffusion SD 1.5 starter from the selector. The repository ships a set of pre-configured starters in the workflows/ directory; the StreamDiffusion SD 1.5 path is the lightest and compiles fastest.

2. Select the camera input

   Choose your webcam from the camera input dropdown. The browser will request camera permission.

3. Run the pipeline

   Click Run. First run triggers TensorRT compilation, which takes between two and five minutes for SD 1.5. Subsequent runs load immediately. Compilation progress streams to the terminal where the server is running.

Pipeline Verification

After compilation completes, the ComfyStream UI shows your webcam feed with the workflow effect applied in near real-time. Expected result: a transformed webcam input (style transfer, depth-mapped effects, or other visual processing depending on the loaded workflow).

If only the raw webcam feed appears without transformation, check:

• GPU VRAM is not exhausted (nvidia-smi)
• The workflow compiled without error (server logs)
• The workflow nodes reference models that have been downloaded

Common Errors

WebRTC negotiation fails

UDP port range blocked. On a remote server, allow UDP 1024-65535 inbound and outbound. For restricted environments, pass --media-ports to constrain the range.

TensorRT compilation hangs past ten minutes

The first compilation can take up to ten minutes for StreamDiffusion. Past that, check nvidia-smi for OOM, server logs for compilation errors, and confirm the GPU has at least 12 GB VRAM available.

Workflow fails to load with format error

The workflow was saved in default ComfyUI format. Re-export in API format: enable Developer Mode in ComfyUI settings, then use Save (API Format).

Frame rate below 5 fps

Common causes: ControlNet stack too heavy, resolution too high, or model not TensorRT-compiled. Try a Lightning or LCM variant of the base model, drop to 512x512 input, and confirm TensorRT compilation completed.

Camera permission denied

The browser blocked camera access. Check site permissions in browser settings. ComfyStream needs getUserMedia access; HTTP works on localhost but requires HTTPS for remote IPs.

Network Connection

A local ComfyStream instance is a working real-time AI pipeline. Deploying it on the Livepeer network, so other applications can call it and the operator earns fees, takes one of two paths.

Path	What it does	When to use
Daydream API	Use the hosted ComfyStream infrastructure	You want a managed surface without operating compute
BYOC worker	Register your ComfyStream instance as a network capability	You want to operate the compute and earn fees

For the Daydream path, see the Daydream documentation under .

For the BYOC path, ComfyStream is already PyTrickle-integrated (Phase 4). The livepeer/comfystream image registers directly as a BYOC capability on an orchestrator. The full setup is in .

Production-Ready Pipelines

ComfyStream supports the following pipeline types in production (Phase 4, January 2026):

• StreamDiffusion: real-time style transfer and image-to-image on live video
• StreamDiffusion V2: second-generation diffusion pipeline; supports video-to-video and image-to-image
• SuperResolution: real-time video upscaling
• AudioTranscription + SRT: real-time captions embedded in video output
• Text data-channel output: structured text output (e.g. transcription) alongside video

You have a working ComfyStream pipeline processing live video. The workflow authoring page covers building custom workflows, and ComfyStream as BYOC covers registering your pipeline on the network.

Next Steps

Workflow Authoring

Build a custom workflow, configure StreamDiffusion, tune for latency.

ComfyStream as BYOC

Register your instance as a BYOC capability on the network.

BYOC Quickstart

The general BYOC path for non-ComfyUI workloads.

docs.comfystream.org

Canonical install reference and hardware deep-dive.