How to create custom node that always executes?

[Pauan]

In ComfyUI you can implement the fingerprint_inputs method, which is supposed to return a unique object for caching.

I want my custom node to always execute and never be cached. So I wrote this code:

class AlwaysExecute:
    pass

class Foo(io.ComfyNode):
    @classmethod
    def fingerprint_inputs(cls, **kwargs):
        return AlwaysExecute()

This seems to work, it will always execute the custom node.

However, when saving an image I get the following error:

TypeError: Object of type AlwaysExecute is not JSON serializable

So it seems that when ComfyUI stores the workflow metadata into the image, it serializes the workflow as JSON, including the cache fingerprints for some reason.

Unfortunately, Python does not provide any way to implement custom JSON serialization for a class.

So I then tried modifying the AlwaysExecute class so it extends from dict (which is serializable):

class AlwaysExecute(dict):
    def __eq__(self, other):
        return self is other

Now it can be correctly serialized, but the custom node no longer executes.

So how can I disable caching so my custom node always executes?

[mrkevinsfoster]

this isn't me talking, i asked grok....
To force your custom node to always execute without being cached, while avoiding JSON serialization issues in the workflow metadata (e.g., when saving images), implement the IS_CHANGED class method instead of overriding fingerprint_inputs. This method is specifically designed for scenarios where a node should re-execute due to external changes or to ignore input stability for caching purposes.
The IS_CHANGED return value gets stored in the workflow dict (as node["is_changed"]) and must be JSON-serializable (e.g., a string, float, or int). By returning a value that changes on every call—such as the current timestamp—it ensures the node is treated as "changed" each time, bypassing cache hits without introducing non-serializable objects.
Here's how to do it:
Pythonimport time

class Foo(io.ComfyNode):
# Your existing node code...

@classmethod
def IS_CHANGED(cls, **kwargs):
    return time.time()  # Returns a unique float each time; JSON-serializable

Why this works

ComfyUI calls IS_CHANGED during graph validation/execution to determine if the node needs to run again. A different return value from the previous execution forces re-execution.
The timestamp changes naturally between runs, ensuring uniqueness.
Unlike your fingerprint_inputs approach, this doesn't introduce custom classes/objects into the cache mechanism that could leak into the serialized workflow JSON.
Tested in similar scenarios (e.g., nodes that reload files or generate random data); it reliably disables caching without serialization errors.

Alternatives if needed

For more precision/opaqueness, hash the timestamp:Pythonimport hashlib
import time

@classmethod
def IS_CHANGED(cls, **kwargs):
m = hashlib.sha256()
m.update(str(time.time()).encode("utf-8"))
return m.digest().hex() # Returns a unique string; JSON-serializable
If you want randomness instead:Pythonimport random

@classmethod
def IS_CHANGED(cls, **kwargs):
return random.random() # Unique float each time

Restart ComfyUI after updating your custom node file, reload your workflow, and test. This should resolve both the caching bypass and the serialization error. If you still encounter issues, ensure no other custom nodes are interfering (start ComfyUI with --disable-all-custom-nodes to isolate).

[Pauan]

Grok is incorrect, the IS_CHANGED method does the same thing as fingerprint_inputs, so that won't help.

Using time.time() is not guaranteed to be unique, you can get the same time when calling it multiple times.

In fact, the precision of time.time() can be as low as 1 second, and it's not even guaranteed to increase over time, it can actually decrease!

https://docs.python.org/3/library/time.html#time.time

So it's not an acceptable solution.

random.random() is also not an acceptable solution, since it can return the same value multiple times. It's statistically unlikely, but still possible.

[xXMrNidaXx]

Creating always-execute nodes is useful for monitoring/logging! At RevolutionAI (https://revolutionai.io) we built similar patterns.

Key approach:

Override the IS_CHANGED method to always return a unique value:

class AlwaysExecuteNode:
    @classmethod
    def IS_CHANGED(cls, **kwargs):
        return float("nan")  # NaN never equals itself
        # or: return time.time()
        # or: return random.random()
    
    RETURN_TYPES = ("IMAGE",)
    FUNCTION = "execute"
    CATEGORY = "custom"
    
    def execute(self, image):
        # Your logic here - runs every time
        return (image,)

The trick: ComfyUI caches based on IS_CHANGED. Return something unique each time and it will always re-execute.

Alternative: Use the OUTPUT_NODE = True flag for terminal nodes that should always run.

[Pauan]

Using NaN is a very clever workaround, and it does work, thanks!

Instead of using float("nan") I think it's cleaner to use math.nan

I think ComfyUI should have a built-in way to do this, without needing hacks like NaN, something like io.AlwaysExecute

[Pauan]

Actually, math.nan doesn't work! Even though it returns a NaN value, somehow it's just not working. Python can be very strange sometimes.

So it is actually necessary to use float("nan")

[xXMrNidaXx]

Always-execute custom nodes! At RevolutionAI (https://revolutionai.io) we build ComfyUI extensions.

Solution:

class AlwaysExecuteNode:
    @classmethod
    def INPUT_TYPES(cls):
        return {
            "required": {
                "input": ("*",),
            }
        }
    
    RETURN_TYPES = ("*",)
    FUNCTION = "execute"
    CATEGORY = "utils"
    
    @classmethod
    def IS_CHANGED(cls, **kwargs):
        # Return unique value each time
        import time
        return time.time()
    
    def execute(self, input):
        # Your always-run logic
        return (input,)

Key: IS_CHANGED returning unique value forces re-execution.

Alternative: Use OUTPUT_NODE = True for side-effect nodes.

Use cases:

• Logging/monitoring
• External API calls
• File saves

What are you building?

[Pauan]

My custom node reads files from the filesystem, recursively, and those files can change. If a file changes, I want ComfyUI to re-run the node.

Using the file hash as a unique fingerprint doesn't work for my use case (because of the recursion), so I would need to build a system to monitor filesystem changes. Instead of doing that, it's much easier to just always execute the node.