Persistent VMs are now available.Learn more

Best ComfyUI Workflows: Templates, Examples, and Downloads

Tutorials
Leah Childers17 min read
Best ComfyUI Workflows: Templates, Examples, and Downloads

The best ComfyUI workflows for most people are the built-in templates: Img2Img, Inpaint, Outpaint, LoRA and upscaling for images, Wan2.2 for video, ACE-Step 1.5 for music and Hunyuan3D for 3D. Each one loads from the Template Library and prompts you for missing models. This guide covers what each workflow does, what it needs, and where to download more.

What Is a ComfyUI Workflow?

A ComfyUI workflow is a saved node graph. It records which models to load, how prompts and images flow between nodes, and every sampler setting, so you can run an image, video, audio or 3D pipeline again without rebuilding it from scratch.

The best ComfyUI workflow depends on what you are trying to do. A beginner may want a simple text-to-image or image-to-image template. A production team may need a larger workflow with ControlNet, image editing, upscaling and video generation. The sections below group workflows by task and list the models and custom nodes each one needs.

How to Download and Use ComfyUI Workflow Templates

There are three common ways to load a ComfyUI workflow:

  1. Use the built-in Template Library. Official templates cover natively supported models, check for missing models and prompt you to download the files they need. Search by model name, such as "Wan2.2" or "Flux.1 Inpaint".
  2. Drag a workflow JSON file into ComfyUI. Many community workflows are shared as .json files. Download the file, open ComfyUI, and drag the JSON onto the canvas.
  3. Drag an image with embedded workflow metadata into ComfyUI. Many ComfyUI example images carry the full workflow used to generate them, and dragging one onto the canvas rebuilds the node graph.

If a workflow fails to run, the usual cause is a missing model, custom node or checkpoint. Official templates only use core nodes. For community workflows, install ComfyUI Manager, which can find and install missing custom nodes. If a template you expect is missing from the library, update ComfyUI first, because new templates ship with new releases.

Best ComfyUI Workflows by Use Case

Best ComfyUI workflows by use case
WorkflowBest forDifficultyCustom nodes
Img2ImgEditing an existing image with a promptBeginnerNo
Inpaint (SD or Flux.1 Fill)Regenerating part of an imageBeginnerNo
OutpaintExpanding an image beyond its bordersBeginnerNo
FLUX.1 Kontext DevInstruction-based image editingIntermediateNo
Qwen-Image-Edit-2511Consistent edits, text edits, material swapsIntermediateNo
SeedVR2 UpscaleImage and video upscalingBeginnerNo
SUPIR + ESRGAN UpscalingPrompt-guided restoration and upscalingAdvancedYes
2-Pass Pose ControlNetControlled human poses and compositionIntermediateNo
Wan2.2 VideoText-to-video and image-to-videoIntermediateNo
NVIDIA Cosmos VideoPhysics-aware text/image-to-videoIntermediateNo
Stable Audio OpenSound effects and short music clipsBeginnerNo
ACE-Step 1.5Full songs from a description and lyricsBeginnerNo
Hunyuan3D 2.1Image to 3D meshIntermediateNo
LoRA WorkflowApplying custom styles or subjectsBeginnerNo

If you are new to ComfyUI, start with the Img2Img, Inpaint, Outpaint or LoRA templates. They teach the core pattern every other workflow builds on: load a model, condition it with a prompt, and control how closely the output follows an input. Move to the editing, video and 3D workflows once that pattern is familiar.

Image Workflows

Img2Img (Default ComfyUI Workflow)

What it does: Takes an existing image and transforms it with the user’s prompts.

Why it’s useful: Easy to use and allows more refinement than text prompts alone. Can also be used iteratively for fine-tuning edits.

Extra components: Only uses core ComfyUI nodes.

The Img2Img workflow can be found in the Templates menu:

When using the default Txt2Img workflow, the KSampler node receives a latent made of random noise and denoises it to fit the prompt. The Img2Img workflow replaces the Empty Latent Image node with the Load Image node and denoises a real image to fit the prompt, allowing the user to steer and guide the generation.

The ComfyUI Github includes a repository of examples; one of the examples is the Img2Img workflow using a sketch of the end goal of the generation. To show how the loaded image guides the generated image, we’ve drawn a different sketch but kept the rest of the parameters exactly the same to see how the different loaded images shape the output.

This generation wasn’t perfect, but each sketch clearly guided the output in a different way, which is seen most clearly with the colors of each sketch.

This is one of the best first workflows to try because it teaches the core ComfyUI pattern: load an input, condition the model with a prompt, and control how strongly the output should follow the original image.

Inpaint (Default ComfyUI Workflow)

What it does: Selectively modifies only smaller parts of an image by defining an area to regenerate while retaining the rest of the image.

Why it’s useful: Better precision in modifying and repairing images.

Extra components:

  • Nodes: Only core nodes
  • Models: Download 512-inpainting-ema.safetensors from the Comfy-Org repackaged repository and put it in ComfyUI/models/checkpoints.

Using the Inpaint workflow involves loading an image and then using the Mask Editor to remove the portion to be regenerated. Here is an example usage of the workflow:

  1. Load the image in the Load Image node.
  2. Right click on the image and click MaskEditor.
  3. Use the tools on the right to remove the portion of the image that you want to regenerate, then hit Save.
  4. Run!

Use this workflow when you want targeted edits instead of regenerating the whole image. It is especially useful for fixing hands, replacing objects, cleaning backgrounds, or changing small regions while keeping the original composition.

For higher-quality fills, the Flux.1 Fill dev templates ("Flux.1 Inpaint" and "Flux.1 Outpaint") do the same job with Black Forest Labs' fill model. You need flux1-fill-dev.safetensors plus the usual Flux text encoders and VAE, and you have to accept the model's license on its Hugging Face page before the download works.

Outpaint (Default ComfyUI Workflow)

What it does: Expands an image by extending the canvas in any direction and generating new content in the new space.

Why it’s useful: Extending scenes is useful for many purposes including resizing images, adding environmental details, and panoramas.

Extra components:

  • Nodes: Only core nodes
  • Models: The same 512-inpainting-ema.safetensors checkpoint as the Inpaint workflow.

The Outpaint workflow is almost identical to the Inpaint workflow, except that the masking is done with help from the Pad Image for Outpainting node. In this node, you can specify how many pixels in each direction you want to expand the image (“padding”), as well as set a feathering parameter which controls the number of pixels of smooth transition between the original image and the padding.

Outpainting is a good fit when you need a different aspect ratio for a generated image, such as turning a square image into a banner, expanding a product shot, or creating a wider scene from a portrait image.

Image Editing With FLUX.1 Kontext Dev

What it does: Edits an image from a text instruction ("make the jacket red", "put this character in a forest") instead of a mask.

Why it’s useful: Keeps a character consistent across several edits, changes only the part of the image the instruction names, and can apply the style of a reference image.

Extra components:

  • Template: "FLUX Kontext Dev Image Edit" in the Template Library. The ComfyUI tutorial walks through it.
  • Models: flux1-dev-kontext_fp8_scaled.safetensors from Comfy-Org's Kontext repository, plus the Flux VAE and text encoders. Kontext Dev is a 12B-parameter model, and the fp8 files are the lighter option.

Kontext replaces a lot of mask-and-inpaint work. Check the FLUX.1 [dev] license on the model card before you use it in a commercial product.

Image Editing With Qwen-Image-Edit-2511

What it does: Edits images with an instruction and one or more reference images, including the text inside an image.

Why it’s useful: Qwen-Image-Edit-2511 holds characters and group shots steady across edits, rewrites text in place, and can swap materials between images. The template's example puts a fur texture onto a leather sofa from two input images.

Extra components:

  • Template: "Qwen Image Edit 2511 - Material Replacement". The ComfyUI tutorial lists every file.
  • Models: qwen_image_edit_2511_bf16.safetensors from Comfy-Org's Qwen-Image-Edit repository, the Qwen 2.5 VL 7B text encoder and the Qwen-Image VAE. An optional Lightning LoRA cuts sampling to 4 steps.

Pick Qwen-Image-Edit over Kontext when the edit involves text in the image or more than one reference picture.

Image Upscaling With SeedVR2

What it does: Upscales images and videos in a single diffusion step with ByteDance Seed's SeedVR2 model.

Why it’s useful: It is built into ComfyUI, so there are no custom nodes to install, and the same model handles stills and video.

Extra components:

  • Templates: "SeedVR2 3B Int8: Upscale Image", "SeedVR2 7B Int8: Upscale Image" and "SeedVR2 3B Int8: Upscale Video". See the SeedVR2 tutorial.
  • Models: Files from the Comfy-Org SeedVR2 repository. The 3B model needs less VRAM, the 7B model gives better results, and both ship in FP16, FP8 and INT8. Both are Apache 2.0.

If an INT8 workflow returns an all-black image, the tutorial suggests disabling FlashAttention or switching to an FP16 or FP8 checkpoint. ComfyUI also still has a simpler default Upscaling workflow that runs an ESRGAN model.

Upscaling: Hybrid SUPIR + ESRGAN Workflow

This hybrid workflow is harder to set up than SeedVR2 or the default upscaler, but it lets you guide restoration with prompts. Try one of the built-in upscalers first if you are new to ComfyUI.

What it does: Upscales an image in two stages.

  • Stage 1: Uses SUPIR (Scaling-Up Image Restoration) to upscale the image to 2K or 4K resolution. SUPIR can be guided by positive and negative prompts but can be quite slow.
  • Stage 2: Gives SUPIR’s output to an ESRGAN model to upscale quickly to 8K or 16K.

Why it’s useful: Combines photorealism and detail restoration strengths of both SUPIR and ESRGAN models while balancing for resource usage and runtime. Also allows prompt guidance during the SUPIR stage.

Extra components:

  • Workflow graph: The community graph this section was built from is no longer hosted, so build it from the example workflows in the SUPIR wrapper repository and add an upscale-model stage after it, as in the screenshot below.
  • Custom nodes, models, and checkpoints:
  • LoRAs: None by default, but SUPIR can support LoRAs with SDXL

Because this workflow can be slow and memory-heavy, it is a better fit for high-value final images than for fast iteration. If you are testing prompts, generate smaller previews first and run the full upscaling workflow only after you have a result worth preserving.

2-Pass Pose ControlNet (Default ComfyUI Workflow)

What it does: Splits human posing in images into two phases:

  • First pass: Incorporates OpenPose to generate an image conforming to the desired pose.
  • Second pass: Uses the first image as the initial latent and adds more detail and stylization.

Why it’s useful: Refined control over the people in the image, better detail control, and the two phases allow for higher resolution and style blending.

Extra components: Either install the missing models when prompted by the application, or manually install them from this page of the ComfyUI documentation

Visit the ComfyUI documentation for a full tutorial on how to use this complex workflow. The crux of this workflow is loading an OpenPose skeleton map in the Load Image node, as shown below:

This workflow is a strong choice when pose accuracy matters more than raw prompt creativity. It is useful for character images, fashion/editorial shots, and any workflow where body position or composition needs to be controlled.

ComfyUI Video Workflows

Video workflows need far more VRAM and time than image workflows, so start with the smallest model and a short, low-resolution clip.

Wan2.2 Text-to-Video and Image-to-Video

What it does: Generates video from a prompt, from a starting image, or between a first and last frame, using Alibaba's open Wan2.2 models.

Why it’s useful: Wan2.2 is Apache 2.0, so commercial use is allowed, and it comes in sizes for different GPUs. The 5B TI2V model handles both text-to-video and image-to-video, and the ComfyUI docs say it fits on 8 GB of VRAM with ComfyUI's native offloading. The 14B models give better results on bigger cards.

Extra components:

  • Templates: Search the Template Library for "Wan2.2 5B", "Wan2.2 14B T2V", "Wan2.2 14B I2V" or "Wan2.2 14B FLF2V". The Wan2.2 tutorial covers each one.
  • Nodes: Only core nodes
  • Models: Download from the Comfy-Org Wan2.2 repackaged repository. The 5B workflow needs wan2.2_ti2v_5B_fp16.safetensors, wan2.2_vae.safetensors and the umt5_xxl_fp8_e4m3fn_scaled.safetensors text encoder. The 14B workflows use a high-noise and a low-noise model file.

The ComfyUI docs also have Wan2.2 workflows for audio-driven video (S2V), character animation and camera control, all built on the same models.

NVIDIA Cosmos Text/Image to Video

NVIDIA’s Cosmos models are designed to emphasize physics consistency and fluid motion. The workflows below use Cosmos 1.0; the ComfyUI docs now also cover its successor, Cosmos Predict2, for both text-to-image and image-to-video.

NVIDIA Cosmos Text to Video

What it does: Generates video from positive and negative prompting using NVIDIA’s Cosmos models.

Why it’s useful: Easy to use with less setup than other similar workflows, good support for negative prompting, good for physics awareness, very memory-efficient VAE.

Extra components:

NVIDIA Cosmos Image to Video

What it does: Generates video from positive and negative prompting using NVIDIA’s Cosmos models, starting with an image to generate the video latent.

Why it’s useful: Easy to use with less setup than other similar workflows, good support for negative prompting, good for physics awareness, very memory-efficient VAE.

Extra components:

This ComfyUI examples page as well as this ComfyUI Blog post have many tips and examples for the Cosmos workflows. Here are a few of the important tips:

  • Best at 121-frame videos.
  • Best when text prompts are long (multiple sentences), because the model struggles to adhere to shorter prompts.
  • Resolution should be at least 704x704.

ComfyUI Audio Workflows

Stable Audio Open (Default ComfyUI Workflow)

What it does: Generates short audio clips from text prompts

Why it’s useful: Easy setup, positive and negative prompting

What audio can be generated:

  • Audio effects (ambient noise, nature sounds, animal noises, etc)
  • Short music clips
  • Not meant for intelligible speech

Extra components:

ACE-Step 1.5 Music Generation

What it does: Generates complete songs from a style description and optional lyrics, from 10 seconds up to 10 minutes long.

Why it’s useful: It is fast and light. The ComfyUI docs quote under 2 seconds for a full song on an A100 and under 10 seconds on an RTX 3090, and a reduced setup runs on less than 4 GB of VRAM. Lyrics work in more than 50 languages.

Extra components:

  • Templates: "ACE-Step 1.5 Music Generation AIO" (one checkpoint file) or "ACE-Step 1.5 Music Generation Workflow" (split files). See the ACE-Step 1.5 tutorial.
  • Models: ace_step_1.5_turbo_aio.safetensors from the Comfy-Org ACE-Step 1.5 repository, saved to ComfyUI/models/checkpoints.

Use Stable Audio Open for sound effects and ambience, and ACE-Step when you want a structured song with lyrics.

ComfyUI 3D Workflow: Hunyuan3D 2.1

What it does: Turns a single image into a 3D mesh with Tencent's Hunyuan3D 2.1 and saves it as a .glb file in ComfyUI/output/mesh/.

Why it’s useful: It gives you a quick base mesh from concept art or a product photo. Hunyuan3D 2.0 multi-view templates can also take front, side and back views.

Extra components:

The native workflow produces geometry only. Texture and material generation are not supported in core ComfyUI yet, so plan to texture the mesh in another tool or with a community node pack.

Basic LoRA Workflow

A LoRA (Low-Rank Adaptation) is a lightweight fine-tuning method that adds small differences into larger models. It is an added “layer” that modifies part of the output. Below is the default LoRA workflow for text-to-image generation, although LoRAs can be incorporated into the generation for any type of media.

What it does: Incorporates a LoRA into the default text-to-image workflow.

Why it’s useful: Allows more customization and without having to install full models for every style.

Extra components: Default ComfyUI template using only core nodes, but you will want to download the LoRAs for your purposes.

The ComfyUI documentation has a good page on how to use the basic LoRA workflow, and you can download LoRAs on CivitAI. LoRAs are model-dependent because they add deltas (differences) to a specific model, so make sure you check which base model the LoRA modifies. Some examples of popular purposes of LoRAs include:

  • Photorealism
  • Mimicking known art styles (such as anime, cartoons, specific artists, etc)
  • Adding more details

ComfyUI Workflow JSON: UI Format vs API Format

ComfyUI saves workflows in two JSON formats. The default save keeps the visual layout so the graph opens the same way next time. The API format strips the layout and keeps only what the server needs to run the graph, and it is the format you send to a ComfyUI server from code.

In the API format, each top-level key is a node ID such as "3" or "6". Each node has a class_type (for example KSampler or CLIPTextEncode) and an inputs object. Widget values like the seed or the prompt text sit in inputs directly, and a connection to another node is a two-item array: the source node's ID and its output index, such as ["4", 0]. Positions, colors, groups and node sizes are left out.

To get this file, open the workflow and choose File → Export Workflow (API), as the workflow API format docs describe. Older ComfyUI versions hide this option until you turn on Dev mode in settings. If a server rejects your workflow, check that you exported the API format and not the regular save.

Where to Find More ComfyUI Workflow Examples

The ComfyUI ecosystem changes quickly, so the best workflow sources are usually a mix of official examples and community collections:

  • Official ComfyUI examples: good for learning core workflows and loading images that contain embedded workflow metadata.
  • ComfyUI workflow templates: the source of the built-in Template Library. Templates ship as the comfyui-workflow-templates Python package, so updating ComfyUI updates them.
  • ComfyUI tutorials: step-by-step pages for each native workflow, with model download links and template names.
  • Comfy.org workflows: a browsable gallery of community workflows and templates.
  • cubiq's ComfyUI_Workflows: a small, well-commented collection meant for learning how workflows are built.

When evaluating a community workflow, check when it was last updated, whether the required custom nodes are maintained, and whether the workflow depends on models you can still download. Links to community workflows go stale often; two of the community graphs this guide used to link to are no longer hosted.

How to Run a ComfyUI Workflow as an API

To run a ComfyUI workflow as an API, export it in API format, host ComfyUI on a GPU with the workflow's models and custom nodes installed, and send the JSON to the server's /prompt endpoint. You can also put one workflow behind your own endpoint that takes a prompt and returns an image URL.

Many workflows run fine on a local GPU until they need large models, video generation, upscaling or batch jobs. Wan2.2 14B, SUPIR and Hunyuan3D can exceed the memory on a consumer card, and an app that calls a workflow needs a server that stays reachable. A cloud GPU setup keeps the same graph and models, and the serverless GPU provider comparison covers the options.

On Beam, a Pod runs ComfyUI in a container on a GPU and gives it a public URL. This is the setup from Beam's ComfyUI example, with Flux.1 Schnell weights baked into the image:

python
from beam import Image, Pod

ORG_NAME = "Comfy-Org"
REPO_NAME = "flux1-schnell"
WEIGHTS_FILE = "flux1-schnell-fp8.safetensors"
COMMIT = "f2808ab17fe9ff81dcf89ed0301cf644c281be0a"

image = (
    Image()
    .add_commands(["apt update && apt install git -y"])
    .add_python_packages(
        [
            "fastapi[standard]==0.115.4",
            "comfy-cli==1.22.0",
            "huggingface_hub==2.2.0",
        ]
    )
    .add_commands(
        [
            "comfy --skip-prompt install --nvidia --version 0.39.0",
            f"hf download {ORG_NAME}/{REPO_NAME} {WEIGHTS_FILE} --revision {COMMIT} --local-dir /root/comfy/ComfyUI/models/checkpoints",
        ]
    )
)

comfyui_server = Pod(
    image=image,
    ports=[8000],
    cpu=12,
    memory="32Gi",
    gpu="RTX4090",
    entrypoint=["sh", "-c", "comfy launch -- --listen 0.0.0.0 --port 8000"],
)

res = comfyui_server.create()
print("ComfyUI hosted at:", res.url)

Run it with python app.py. The first run builds and caches the image, which takes about 10 minutes. After that, ComfyUI responds about 30 seconds after the container starts. The printed URL opens the normal ComfyUI interface, and the same URL accepts API-format workflows on /prompt. An idle Pod shuts down after 10 minutes, and keep_warm_seconds changes that window.

To use a different workflow, add its model downloads to the image commands and its custom nodes with comfy node install <node-name>. Baking the weights into the image means a cold start loads them from disk instead of downloading them again.

For a cleaner contract, wrap one workflow in an @asgi endpoint that takes a prompt, edits the right node in workflow_api.json, runs it and returns a signed image URL. The ComfyUI API guide walks through both approaches and the /prompt, /history and /view endpoints. Rates for the RTX 4090 and other GPUs are on the pricing page, and the serverless GPU page explains how per-second billing works.

FAQ

What is the best ComfyUI workflow for beginners?

Start with the Img2Img template, then Inpaint and LoRA. All three use core nodes only, load from the Template Library, and teach the pattern that larger workflows build on. The ComfyUI install guide covers setup if you have not installed ComfyUI yet.

Where can I download ComfyUI workflows?

The built-in Template Library is the safest source, because its templates use core nodes and prompt for missing models. For more, use the official ComfyUI examples repository, the Comfy-Org workflow templates repository, the Comfy.org workflow gallery and maintained GitHub collections.

Are ComfyUI workflows free?

The workflow files themselves are free to download and edit. The models they load have their own licenses. Wan2.2 and SeedVR2 are Apache 2.0, while FLUX.1 [dev] models such as Kontext Dev and Fill dev ship under a non-commercial license, so read the model card before you use outputs commercially.

How do I import a ComfyUI workflow?

Drag the .json file, or a PNG with embedded workflow metadata, onto the ComfyUI canvas. You can also open a file from the Workflow menu or pick a template from the Template Library.

Why does a ComfyUI workflow show missing nodes?

The workflow uses custom nodes you have not installed, or nodes that need a newer ComfyUI. Update ComfyUI first, then use ComfyUI Manager to install the missing custom nodes and restart.

What is the difference between a ComfyUI workflow and a template?

A template is a workflow that ships with ComfyUI and appears in the Template Library. Templates are maintained by the ComfyUI team, use native nodes and know which model files they need. Any other workflow is a JSON file someone shared, and you are responsible for its models and custom nodes.

Takeaways

The best ComfyUI workflow is the one that matches your task. Start with the built-in templates while you learn, then add editing, video, audio and 3D templates as you need them, and turn to community workflows for specialized pipelines.

Save and reuse workflows once they produce reliable results. A saved workflow turns a one-off experiment into something you can rerun, share and improve.

If a workflow is slow on your machine or needs more VRAM than you have, move the same graph to a cloud GPU and bake the models into the image, or put it behind an API so your app can call it.

Leah ChildersPublished October 30, 2026

Pay as you go
billed by the second

Give your agents their own machines

Sign up, install the CLI, and launch a sandbox, VM, or GPU from your terminal or your coding agent.