ComfyUI Remote API Nodes: Mixing Local and Cloud Models Explained
ComfyUI's remote API nodes let you call closed-source models like Seedance and Grok Imagine from local workflows. Here's how the hybrid setup works.
What are ComfyUI remote API nodes?
Remote API nodes are a category of nodes inside ComfyUI that call closed-source, cloud-hosted models instead of running inference on your own hardware. Instead of only wiring together open-source checkpoints that run locally on your GPU, you can drop a node into your workflow that sends a request out to a platform model (something like Seedance or Grok Imagine), gets the result back, and feeds it into the rest of your node graph like any other output. The practical effect is that a single ComfyUI workflow can now blend fully local generation with paid, API-based generation, without leaving the graph.
TL;DR
- ComfyUI now supports remote API nodes that call closed-source platform models such as Seedance and Grok Imagine directly from inside a local node graph, alongside open-source models running on your own GPU.
- Templates separate local and remote model categories, so you can toggle between “ComfyUI” (local) and “External/Remote APIs” sections to see which cloud models are available as drop-in nodes.
- This turns ComfyUI into a hybrid tool rather than a purely local one: you can generate an image with a local model and then animate it with a paid API model, or vice versa, in one pipeline.
- The tradeoff is cost versus convenience, since local generation on your own hardware is free after setup but slower and hardware-dependent, while API nodes cost money per call but tap into models you couldn’t otherwise run at home.
- ComfyUI’s new MCP (model context protocol) support, released as an official beta, lets LLMs like Claude or Codex build and edit these workflows for you, lowering the barrier to using remote nodes without hand-wiring the graph yourself.
- Hardware still matters for the local half of any hybrid workflow, with ComfyUI running on most modern PCs and Macs but performing best on Nvidia GPUs in the 4090 to 5090 range, or via Comfy Cloud or rented cloud GPUs for those without a strong local rig.
Everyone else built a construction worker.
We built the contractor.
One file at a time.
UI, API, database, deploy.
How does mixing local and cloud models actually work?
ComfyUI is built around a node graph: you place blocks that represent a model, a sampler, an input, or an output, then wire them together to define a pipeline. Historically, every node in that graph pointed at a model file sitting on your machine. Remote API nodes change that by acting as a bridge. The node itself lives in your local graph, but when it executes, it sends your prompt or input data to a hosted model over the internet, waits for the response, and drops the result back into the graph as if it had been generated locally.
This means you can, for example, generate a still image with a local open-source model, pass that image into a remote node that calls a cloud video model to animate it, and then bring the resulting video back into your local graph for further processing; upscaling, compositing, or additional local steps. The node graph doesn’t care whether a given step happened on your GPU or on someone else’s server. It just cares about inputs and outputs.
What models are available through remote API nodes?
Inside ComfyUI’s template browser, models are now split into categories. One section covers standard local, open-source options: things like Wan, LTX, or other checkpoints that ComfyUI is typically quick to add support for whenever a new open-source model releases. A separate “External” or “Remote APIs” section lists closed-source, platform-hosted models you can call the same way. Based on what’s been added to that list, this includes video generation models like Seedance and image or video tools like Grok Imagine, alongside other proprietary models. Because these are paid platform models accessed via API, using them typically requires an account and API credentials with the respective provider, and each call carries a cost set by that provider rather than being free like local inference.
Why would you use a paid API model instead of a local one?
The appeal comes down to capability and convenience. Open-source models are free to run once you have the hardware, but they lag behind the best closed-source platforms on certain tasks, and running large video or image models locally requires a capable GPU and can take real time per generation. Calling a closed-source model through an API node sidesteps both issues: you get access to a model you couldn’t otherwise download or run, and the compute happens on the provider’s infrastructure rather than your own card.
The obvious tradeoff is cost. Local generation, once you’ve paid for the hardware, is essentially free per output. API calls to platform models charge per use, so a workflow that leans heavily on remote nodes will accumulate costs the way any other paid API integration does. For builders, this makes ComfyUI’s remote nodes less about replacing local generation and more about giving you the option to reach for a stronger or different model for a specific step in a larger pipeline, while keeping everything else local and free.
Is ComfyUI worth learning if you’re not technical?
ComfyUI has a reputation for being intimidating. The node graph can look like a tangle of wires even for simple workflows, and building anything nontrivial by hand has historically required understanding samplers, schedulers, latent spaces, and how different node types connect. That reputation is largely earned. Even experienced users describe a steep learning curve, and building complex multi-model workflows from scratch is a skill in itself.
What has changed recently is that ComfyUI now has an official MCP (model context protocol) integration, currently in beta, alongside a community-built MCP that predates it. MCP lets an LLM like Claude or Codex directly interact with ComfyUI: building workflows, running them, and adjusting parameters based on plain-language instructions. In practice, this means you can describe what you want (“make me a workflow that generates an image and then animates it”) and have the LLM assemble the node graph for you, rather than building it manually. You can still open ComfyUI itself to tweak settings like video length, aspect ratio, or sampler steps directly, which is generally faster and cheaper (in LLM token terms) than asking the assistant to make small changes for you.
This doesn’t eliminate the learning curve entirely. Using an LLM to drive ComfyUI still requires being comfortable granting an AI agent computer-use permissions, and getting the most out of the tool still benefits from understanding basic concepts like what a sampler or a scheduler does. But it does lower the barrier significantly for people who want ComfyUI’s flexibility without becoming full-time node engineers.
What hardware do you need to run ComfyUI with remote API nodes?
Local hardware requirements only apply to the local half of a hybrid workflow, since remote API nodes offload their compute to the cloud. ComfyUI itself runs on most modern PCs and Macs, though Windows machines with an Nvidia GPU tend to have fewer compatibility headaches than Mac setups. For heavier local workflows, a GPU in the range of an Nvidia 4090 to 5090 is a reasonable target for smoother performance, though this varies depending on which local models you’re running alongside your remote nodes.
For people without that kind of hardware, ComfyUI also offers Comfy Cloud, which runs the tool in the cloud rather than on your desktop, and renting GPU compute from third-party providers is another common route. Cloud GPU rental pricing varies by provider and hardware tier.
Frequently Asked Questions
What is the difference between a local node and a remote API node in ComfyUI?
A local node runs inference using a model file stored and executed on your own machine. A remote API node sends the request to a cloud-hosted, closed-source model and returns the result into your workflow, meaning the actual computation happens on someone else’s servers rather than your GPU.
Do remote API nodes in ComfyUI cost money?
Yes. Because remote nodes call paid, closed-source platform models, using them typically requires an account and credentials with that provider, and each generation is billed according to that provider’s pricing rather than being free like local inference.
Can I combine a local model and a cloud model in the same ComfyUI workflow?
Yes, that’s the core capability. You can generate an image locally with an open-source model, feed it into a remote node calling a cloud video model for animation, and bring the output back into the same graph for further local processing.
Plans first. Then code.
Remy writes the spec, manages the build, and ships the app.
Do I need to know how to build ComfyUI node graphs manually to use this?
Not necessarily. ComfyUI’s official MCP integration, along with an existing community-built one, lets LLMs like Claude or Codex build and adjust workflows based on plain-language requests, though manually tweaking simple settings inside ComfyUI is usually faster than asking an LLM to do it.
What kind of GPU do I need for ComfyUI?
ComfyUI runs on most modern PCs and Macs, but for smoother performance on local models, an Nvidia GPU in the 4090 to 5090 range is a reasonable benchmark. Remote API nodes don’t add to this requirement since their compute runs in the cloud.