Advanced ComfyUI Workflows: 5 Complete Builds, Step by Step (2026)

Checked against ComfyUI's documentation, official templates and example workflows on October 1, 2026, when v0.38.0 was the latest ComfyUI release. Settings quoted below come from those examples. This page gives complete builds; our advanced ComfyUI techniques explainer covers what each technique does. This update replaces the January 2026 version, whose refiner settings, LoRA strength charts and model recommendations were not sourced.

Before you start

• Update ComfyUI. Every build starts from an official template or example. Templates check for missing model files and link to them (templates guide).
• Enable ComfyUI-Manager for the one custom node used here, Ultimate SD Upscale. See our ComfyUI-Manager guide if it is missing.
• Check disk space and licenses. File sizes below come from each file's Hugging Face page, and licenses from each model card.

Build 1: SDXL base plus refiner

Goal: a 1024-pixel SDXL image where the refiner model finishes the last steps. Load it by dragging the refiner example image from ComfyUI's SDXL examples page onto the canvas; the workflow is embedded in the image.

• sd_xl_base_1.0.safetensors (6.94 GB) and sd_xl_refiner_1.0.safetensors (6.08 GB) in models/checkpoints, both under CreativeML Open RAIL++-M (base, refiner).

1. Base stage: Load Checkpoint (base), positive and negative CLIP Text Encode, and Empty Latent Image at 1024 by 1024.
2. Base sampler: KSamplerAdvanced with add_noise enabled, 25 steps, start_at_step 0, end_at_step 20 and return_with_leftover_noise enabled.
3. Refiner stage: Load Checkpoint (refiner) with its own positive and negative CLIP Text Encode nodes, because the refiner uses its own text encoder.
4. Refiner sampler: KSamplerAdvanced with add_noise disabled, the same 25 steps, start_at_step 20, end_at_step 10000 (run to the end) and return_with_leftover_noise disabled, fed with the base sampler's latent.
5. Output: VAE Decode with the refiner's VAE, then Save Image.

Both samplers in the official example use cfg 8, the euler sampler and the normal scheduler. The examples page recommends 1024 by 1024 or another size with the same pixel count, such as 896 by 1152 or 1536 by 640.

Why it works: the base sampler stops at step 20 and passes on a latent that still holds noise, and the refiner finishes the same schedule instead of starting a new one. That is why the refiner has no denoise setting to tune. To change the split, move both handoff numbers together. If you use an SDXL fine-tune instead of the base model, check its model card before adding the refiner, and compare with and without it at a fixed seed.

Build 2: A posed character with a LoRA and a two-pass ControlNet

Goal: your character in a chosen pose, refined at a higher resolution. Start from Comfy's pose ControlNet two-pass example, built on SD1.5 models, and add your character LoRA.

• control_v11p_sd15_openpose_fp16.safetensors (0.72 GB) in models/controlnet.
• vae-ft-mse-840000-ema-pruned.safetensors (0.33 GB, MIT) in models/vae.
• Two SD1.5 checkpoints in models/checkpoints. The example uses community checkpoints from Civitai, so check each one's license.
• Your SD1.5 character LoRA in models/loras. Our LoRA training guide covers training one.

1. Load the example by dragging its image into ComfyUI and let it prompt for the models.
2. Upload your pose as an OpenPose skeleton image, or extract one from a photo with the DWPose or OpenPose preprocessor in comfyui_controlnet_aux.
3. Add Load LoRA after the first Load Checkpoint and route its MODEL and CLIP outputs onward, so the text encoders and first sampler use the LoRA. Keep strength_model and strength_clip between 0 and 1, the range Comfy's Load LoRA docs call typical, and put the trigger word in the prompt.
4. First pass: the example applies the ControlNet at strength 1.0 for the whole schedule (start 0, end 1) and samples 20 steps at cfg 7 with dpmpp_2m and the karras scheduler.
5. Second pass: the latent is upscaled to 1536 by 1536, and a second checkpoint samples 10 steps at denoise 0.5. The tutorial gives 0.4 to 0.6 as the typical range, low enough to keep the pose from the first pass.
6. Protect the face. The second checkpoint does not see your LoRA, so if the refine pass changes the face, add a Load LoRA there too or lower the denoise.

For SDXL characters the graph is the same with SDXL parts: an SDXL checkpoint and LoRA, and an SDXL pose ControlNet, such as a union model set to openpose with the Set Union ControlNet Type node. Every model in the chain must be from the same family.

Build 3: A reference edit with Qwen-Image-Edit-2511

Goal: change one thing in an image using a second image as the reference, such as a material, a garment or a product. Qwen-Image-Edit-2511 is Apache 2.0 licensed, and Comfy's guide notes better character and multi-person consistency than the 2509 release.

• qwen_image_edit_2511_fp8mixed.safetensors (20.5 GB), which the template's loader selects, in models/diffusion_models. The BF16 file is 40.9 GB.
• qwen_2.5_vl_7b_fp8_scaled.safetensors (9.4 GB) in models/text_encoders.
• qwen_image_vae.safetensors (0.25 GB) in models/vae.
• Optional: Qwen-Image-Edit-2511-Lightning-4steps-V1.0-bf16.safetensors (0.85 GB) in models/loras for 4-step sampling.

1. Open the template: search "Qwen-Image-Edit-2511" in Templates. Its example is a material replacement.
2. Load the image to edit as image 1 and the reference, such as a texture, garment or product photo, as image 2.
3. Write the instruction by image number. The template's example asks it to change the leather of the sofa in image 1 to the fur material in image 2.
4. Choose the sampling path. The template's note lists 40 steps at CFG 4.0 as Qwen's reference and 20 steps at CFG 4.0 as Comfy's, and the Lightning LoRA is built for 4 steps.
5. Run and compare the result with the original, checking faces, text and anything you did not ask to change.

A lighter option is FLUX.2 [klein] 4B, also Apache 2.0, whose image-edit templates take two reference images; Comfy lists 8.4 GB of VRAM for the distilled model (Klein guide). Our Qwen image edit guide covers prompts in more depth.

Build 4: Finish and upscale

Fix artifacts before this step; Comfy's upscaling guide warns against relying on upscaling to repair them. Then pick one of two paths.

Option A: SeedVR2, a faithful one-step upscale

1. Open the "SeedVR2 3B Int8: Upscale Image" template.
2. Put seedvr2_3b_int8_convrot.safetensors (3.46 GB) in models/diffusion_models and seedvr2_ema_vae_fp16.safetensors (0.50 GB) in models/vae. The 7B INT8 file (8.33 GB) is the higher-quality option. Both sizes are Apache 2.0.
3. Comfy's tip: downscale the image to 0.35 megapixels with ImageScaleToTotalPixels first.
4. Select your image in Load Image and run.

If the output is all black, the SeedVR2 guide suggests, in order: run without FlashAttention, switch to the FP16 or FP8 file, check that both files downloaded completely, and turn off the live preview.

Option B: Ultimate SD Upscale, adding detail with your checkpoint

1. Install ComfyUI_UltimateSDUpscale (GPL-3.0) from ComfyUI-Manager. Its example workflows appear under Templates, in the Extensions section.
2. Download an upscale model, such as 4x-ESRGAN from OpenModelDB as in Comfy's upscale tutorial, into models/upscale_models.
3. Connect Load Image to the UltimateSDUpscale node, together with your checkpoint's model and VAE, your prompts and a Load Upscale Model node, then to Save Image.
4. The node defaults to upscale_by 2, denoise 0.2 and 512 by 512 tiles with 32 pixels of padding. Set the tile size near the size your checkpoint works at, such as 1024 by 1024 for SDXL, and enable a seam-fix mode if tile edges show.

Build 5: Batch-render a prompt list through the API

1. Finish and test a workflow in the UI.
2. Export it with File, then Export Workflow (API), to workflow_api.json (API format).
3. Find the IDs of your positive prompt node and your sampler in that file and set them at the top of the script.
4. Put one prompt per line in prompts.txt.
5. Run the script on the machine where ComfyUI is running.

"""Batch-render prompts through a local ComfyUI server (standard library only)."""
import json
import time
import urllib.parse
import urllib.request
from pathlib import Path

SERVER = "http://127.0.0.1:8188"
PROMPT_NODE = "6"   # positive CLIP Text Encode in your API export
SAMPLER_NODE = "3"  # KSampler in your API export


def call(path, payload=None):
    data = json.dumps(payload).encode("utf-8") if payload is not None else None
    req = urllib.request.Request(SERVER + path, data=data, headers={"Content-Type": "application/json"})
    with urllib.request.urlopen(req) as resp:
        return resp.read()


workflow = json.loads(Path("workflow_api.json").read_text(encoding="utf-8"))
prompts = [line.strip() for line in Path("prompts.txt").read_text(encoding="utf-8").splitlines() if line.strip()]
out_dir = Path("batch_out")
out_dir.mkdir(exist_ok=True)

for n, text in enumerate(prompts, start=1):
    workflow[PROMPT_NODE]["inputs"]["text"] = text
    workflow[SAMPLER_NODE]["inputs"]["seed"] = n  # same line, same seed, same image
    prompt_id = json.loads(call("/prompt", {"prompt": workflow}))["prompt_id"]
    while True:  # a prompt appears in /history once its run has finished
        history = json.loads(call(f"/history/{prompt_id}"))
        if prompt_id in history:
            break
        time.sleep(2)
    for node_output in history[prompt_id]["outputs"].values():
        for image in node_output.get("images", []):
            query = urllib.parse.urlencode({"filename": image["filename"], "subfolder": image["subfolder"], "type": image["type"]})
            (out_dir / f"{n:03d}_{image['filename']}").write_bytes(call(f"/view?{query}"))
    print(f"{n}/{len(prompts)} done: {text}")

The routes and the /view parameters follow ComfyUI's API examples. A failed run still lands in the history, marked as an error with only the outputs that finished, so the script moves on; the server console shows why it failed. Keep the server on its default 127.0.0.1 address: these routes have no login, and ComfyUI's security policy leaves securing an exposed server to you.

Taking a build to video

A finished still can become the first frame of a clip with the Wan 2.2 14B image-to-video template, or drive a character from a performance video with Wan Animate. Our Wan 2.2 Animate tutorial covers models, VRAM and licenses.

Adapting a build without breaking it

• Change one thing at a time at a fixed seed, and keep the outputs you compared.
• Save each working version. Built-in save nodes embed the workflow in PNG images and in animated WebP, MP4 and WebM files, so dragging a result back in restores its graph (workflow metadata). The embedded graph does not include models or custom nodes.
• Collapse finished stages into subgraphs so they are not rewired by accident.
• Keep a restore point. Comfy Desktop snapshots record the ComfyUI version, custom nodes and Python packages, so you can roll back a bad update.

Advanced ComfyUI Workflows FAQ

Related Reads

• Advanced ComfyUI techniques explained
• Where to find ComfyUI workflows and use them safely
• ControlNet guide
• LoRA training for consistent faces
• Wan 2.2 Animate tutorial