Comfyui Node Outputs

Define ComfyUI node outputs with proper typing, previews, and save behavior

Category: development Source: jtydhr88/comfyui-custom-node-skills

ComfyUI Node Outputs is a development skill for defining custom node outputs in ComfyUI, covering output typing, preview generation, and save behavior configuration

What Is This?

Overview

ComfyUI Node Outputs provides a structured approach to defining how custom nodes return data in ComfyUI workflows. It handles output type declarations, preview rendering, and file persistence settings. This skill ensures your custom nodes integrate seamlessly with ComfyUI's execution pipeline and UI rendering system.

ComfyUI processes node outputs through a standardized system that requires proper configuration for data to flow correctly through workflows. This skill abstracts the complexity of output definition, allowing developers to focus on node logic rather than infrastructure details. By using this skill, developers can ensure that their nodes interact predictably with the rest of the workflow, supporting both simple and advanced use cases.

Node outputs in ComfyUI are not just about returning values—they define how data is exposed to other nodes, how users interact with results, and how outputs are visualized or saved. Proper output configuration is essential for building robust, reusable, and user-friendly nodes that fit naturally into the ComfyUI ecosystem.

Who Should Use This

Custom node developers building ComfyUI extensions need this skill to properly expose node results. Anyone creating reusable ComfyUI components should understand output configuration to ensure compatibility with downstream nodes. This includes developers working on image processing, model management, data transformation, or utility nodes. Even advanced users who want to customize or extend existing nodes will benefit from understanding output definitions.

Why Use It?

Problems It Solves

Improperly configured outputs cause workflow failures, missing previews, and data loss. Without proper typing, nodes cannot validate connections or pass data correctly. This skill eliminates configuration errors and ensures outputs work reliably across different ComfyUI setups. It also helps prevent subtle bugs that can arise when outputs are ambiguous or misconfigured, such as type mismatches or missing data in complex workflows.

Core Highlights

Output type declarations prevent incompatible node connections and catch errors early. Preview configuration enables users to see results directly in the UI without external viewers. Save behavior settings control whether outputs persist to disk or remain in memory. Proper output definition makes nodes discoverable and usable in complex workflows. Additionally, well-defined outputs improve documentation, make workflows easier to debug, and enhance the overall user experience by providing clear feedback and visual cues.

How to Use It?

Basic Usage

To define outputs in a custom node, specify the types and names of each output:

RETURN_TYPES = ("IMAGE", "STRING")
RETURN_NAMES = ("output_image", "metadata")

def execute(self):
    image = process_image()
    text = "Processing complete"
    return (image, text)

This configuration tells ComfyUI what data types to expect and how to label each output in the UI and workflow editor.

Real-World Examples

Image processing node with preview enabled:

RETURN_TYPES = ("IMAGE",)
OUTPUT_NODE = True

def execute(self, input_image):
    processed = apply_filter(input_image)
    return (processed,)

Model output node with multiple return types:

RETURN_TYPES = ("MODEL", "CLIP", "VAE")
RETURN_NAMES = ("model", "clip", "vae")

def execute(self, model_path):
    model = load_model(model_path)
    return (model.model, model.clip, model.vae)

You can also define nodes that output data for logging or configuration:

RETURN_TYPES = ("STRING",)
RETURN_NAMES = ("log_message",)

def execute(self, data):
    log = f"Processed {len(data)} items"
    return (log,)

Advanced Tips

Use OUTPUT_NODE = True for nodes that should trigger execution and display results prominently in the UI. Configure RETURN_TYPES with specific data types like IMAGE, STRING, INT, FLOAT, or LATENT to enable proper workflow validation and connection checking. For nodes with multiple outputs, always match the order of RETURN_TYPES and RETURN_NAMES to the returned tuple. Consider implementing custom preview logic for complex data types to enhance user feedback.

When to Use It?

Use Cases

Creating image generation nodes that output processed images with preview thumbnails in the workflow editor. Building model loader nodes that return multiple components like models, tokenizers, and VAE encoders. Developing data transformation nodes that output structured information for downstream processing. Implementing utility nodes that generate metadata, logs, or configuration data for workflow documentation. Any scenario where node outputs need to be consumed by other nodes or visualized by users requires careful output definition.