Custom Node API Reference

class ComfyNode:
    @classmethod
    def define_schema(cls) -> io.Schema:
        """Define node metadata, inputs, and outputs"""
        pass
    
    @classmethod
    def execute(cls, **inputs) -> io.NodeOutput:
        """Execute the node's processing logic"""
        pass
    
    @classmethod
    def check_lazy_status(cls, **inputs) -> list[str]:
        """Optional: Control lazy input evaluation"""
        pass
    
    @classmethod
    def fingerprint_inputs(cls, **inputs) -> str | int:
        """Optional: Control when the node re-executes"""
        pass

io.Schema(
    node_id: str,
    display_name: str,
    category: str,
    inputs: list[Input],
    outputs: list[Output]
)

io.Image.Input(
    id: str,
    display_name: str = None,
    optional: bool = False,
    tooltip: str = None,
    lazy: bool = None,
    raw_link: bool = None,
    advanced: bool = None
)

io.Image.Output(
    id: str = None,
    display_name: str = None,
    tooltip: str = None
)

io.Int.Input(
    id: str,
    display_name: str = None,
    optional: bool = False,
    tooltip: str = None,
    lazy: bool = None,
    default: int = None,
    min: int = None,
    max: int = None,
    step: int = None,
    control_after_generate: bool | ControlAfterGenerate = None,
    display_mode: NumberDisplay = None,
    socketless: bool = None,
    force_input: bool = None,
    advanced: bool = None
)

io.Float.Input(
    id: str,
    display_name: str = None,
    optional: bool = False,
    tooltip: str = None,
    lazy: bool = None,
    default: float = None,
    min: float = None,
    max: float = None,
    step: float = None,
    round: float = None,
    display_mode: NumberDisplay = None,
    gradient_stops: list[list[float]] = None,
    socketless: bool = None,
    force_input: bool = None,
    advanced: bool = None
)

io.String.Input(
    id: str,
    display_name: str = None,
    optional: bool = False,
    tooltip: str = None,
    lazy: bool = None,
    multiline: bool = False,
    placeholder: str = None,
    default: str = None,
    dynamic_prompts: bool = None,
    socketless: bool = None,
    force_input: bool = None,
    advanced: bool = None
)

io.Combo.Input(
    id: str,
    options: list[str] | list[int] | type[Enum],
    display_name: str = None,
    optional: bool = False,
    tooltip: str = None,
    lazy: bool = None,
    default: str | int | Enum = None,
    control_after_generate: bool | ControlAfterGenerate = None,
    upload: UploadType = None,
    image_folder: FolderType = None,
    remote: RemoteOptions = None,
    socketless: bool = None,
    advanced: bool = None
)

io.Boolean.Input(
    id: str,
    display_name: str = None,
    optional: bool = False,
    tooltip: str = None,
    lazy: bool = None,
    default: bool = None,
    label_on: str = None,
    label_off: str = None,
    socketless: bool = None,
    force_input: bool = None,
    advanced: bool = None
)

from comfy_api.latest import io

io.NumberDisplay.number    # Standard number input
io.NumberDisplay.slider    # Slider control
io.NumberDisplay.gradient_slider  # Gradient slider

io.ControlAfterGenerate.fixed       # Keep value
io.ControlAfterGenerate.increment   # Increment value
io.ControlAfterGenerate.decrement   # Decrement value
io.ControlAfterGenerate.randomize   # Randomize value

io.UploadType.image  # Image upload
io.UploadType.audio  # Audio upload
io.UploadType.video  # Video upload
io.UploadType.model  # Generic file upload

io.FolderType.input   # Input folder
io.FolderType.output  # Output folder
io.FolderType.temp    # Temporary folder

# Single output
return io.NodeOutput(result)

# Multiple outputs
return io.NodeOutput(result1, result2, result3)

# Named outputs
return io.NodeOutput(
    image=processed_image,
    mask=generated_mask
)

from comfy_api.latest import ComfyExtension, io
from typing_extensions import override

class MyExtension(ComfyExtension):
    async def on_load(self) -> None:
        """Called when extension loads"""
        # Initialize resources
        pass
    
    @override
    async def get_node_list(self) -> list[type[io.ComfyNode]]:
        """Return list of nodes"""
        return [
            Node1,
            Node2,
        ]

async def comfy_entrypoint() -> MyExtension:
    """Entry point called by ComfyUI"""
    return MyExtension()

from aiohttp import web
from server import PromptServer

@PromptServer.instance.routes.get("/my_endpoint")
async def my_endpoint(request):
    return web.json_response({"message": "hello"})

@PromptServer.instance.routes.post("/process_data")
async def process_data(request):
    data = await request.json()
    result = process(data)
    return web.json_response(result)

# In your extension file
WEB_DIRECTORY = "./web"

import torch
from typing import TYPE_CHECKING

if TYPE_CHECKING:
    from comfy.model_patcher import ModelPatcher
    from comfy.sd import CLIP, VAE
    from comfy.controlnet import ControlNet

# Image tensor: [B, H, W, C] with values in [0, 1]
ImageTensor = torch.Tensor

# Mask tensor: [B, H, W] with values in [0, 1]
MaskTensor = torch.Tensor

# Latent dict with 'samples' key
Latent = dict[str, torch.Tensor]