Images and video: ComfyUI on a rented GPU

How images differ from text

With language models everything comes down to one model and one engine. Images and video are different: the result comes from a chain of several models. A text encoder turns the prompt into vectors, a diffusion model draws, a VAE turns the result into pixels, and alongside them there may be LoRA adapters for a style or character, control networks that set pose or composition, an upscaler, background removal.

So instead of an engine like vLLM, people use a pipeline builder. The most common is ComfyUI: you assemble a pipeline from nodes in the browser, and then call the same pipeline over an API. There are thousands of ready-made nodes and pipelines for ComfyUI, and almost every new model gets support in it within days of release.

One more difference: images and video don't benefit from batching as much as text does. A single generation usually occupies the whole GPU for seconds or minutes. So here it is more convenient to count seconds per generation rather than tokens.

Which models to use now

Memory figures are approximate, as of early November 2026. They depend heavily on resolution, video length and weight format.

Images

For your own product with commercial use, the simplest start is Qwen-Image or Z-Image Turbo: both are Apache 2.0, both handle complex prompts and text in images well, and there are already plenty of LoRAs and accelerated versions for them.

Video

Video is many times heavier than images: a few seconds of footage take minutes to generate even on an H100. If your product needs video often, count the money especially carefully; more on that in the next part.

Generation models change even faster than language models. New versions and accelerated variants appear in the feed above, and almost every such release comes with a ready-made ComfyUI pipeline.

Which GPU

Compute matters more for generation than for text, so the Blackwell RTX 5090 and RTX PRO 6000 are especially good value here. If a pipeline doesn't fit in memory, ComfyUI can offload parts to system RAM: the text encoder, for example, runs fine on the CPU. It is slower, but lets you get by with a smaller GPU.

Bringing up ComfyUI

RunPod and Vast.ai have ready-made ComfyUI templates. The order is the same as with vLLM in part five:

1. A network volume of 100 to 300 GB. Image models, and video models especially, are large, and LoRAs and nodes pile up. ComfyUI and everything downloaded should live on the volume.
2. A pod from the ComfyUI template with the volume attached. The web interface port is usually 8188.
3. Models go into folders inside ComfyUI/models: diffusion models, text encoders, VAE, LoRAs. The ready-made pipelines for new models in ComfyUI's templates tell you which files to download.
4. Build the pipeline in the browser and check that it gives the result you need.

The pipeline as an API

A finished pipeline can be exported in API format: JSON where each node and its parameters are spelled out. Your product then works with ComfyUI like this:

Your service takes the exported JSON, fills in the prompt, seed and size in the right nodes, sends it to /prompt and gets a job id. Progress can be followed over a websocket or by polling /history. When generation finishes, the file is fetched via /view and put into your storage.

A few practical tips:

• Keep the pipeline JSON in the repository next to the code. It is your "model": a change to the pipeline should go through like a code change.
• Pin versions of ComfyUI and third-party nodes. Updating a node can quietly change the result or break the pipeline.
• ComfyUI has its own queue, but a simple one. If there are many generations, keep your own job queue in the service, as in the core of the automations series, and send ComfyUI one or two jobs per GPU at a time.
• There is serverless for uneven load. RunPod has a ready-made serverless worker for ComfyUI: you send the pipeline JSON, the platform starts a worker, generates and returns the result. The cold start is longer than for text because there are several models.

What one generation costs

The formula is the same as for tokens, only the unit differs:

price per generation = hourly rental price / 3600 × seconds per generation

An image in 5 seconds on an RTX 5090 at 1.2 dollars an hour costs about 0.17 cents. A thousand such images cost less than two dollars, provided the GPU doesn't sit idle between them. A five-second clip that takes 4 minutes to generate on an H100 at 3 dollars an hour costs about 20 cents. Your numbers will differ: measure the generation time of your pipeline on the chosen GPU and compare it with API providers' prices for the same resolution and length.

What's next

In the final part we bring everything about money together: how to calculate the real cost of your own model including idle time, when it pays to keep the GPU on permanently, when to shut it down when idle, and when to move to serverless.