ComfyUI's own API
ComfyUI is already an API. Its server, on port 8188 of your own machine, takes a workflow as JSON and queues it: export the workflow in API format (File, then Export Workflow (API)), POST it to /prompt, and read the results from /history once it has run. A websocket at /ws reports progress while it runs.
# Queue a workflow you exported in API format
curl -s http://127.0.0.1:8188/prompt \
-H "Content-Type: application/json" \
-d "{\"prompt\": $(cat workflow_api.json)}"
# {"prompt_id": "…", "number": 0, "node_errors": {}}
# Once it has run, its outputs are listed here
curl -s http://127.0.0.1:8188/history/<prompt_id>What it does not do is serve anyone else. ComfyUI has no login or API key of its own and listens only on your machine unless you start it with --listen; it runs one queue on one GPU, and that GPU is on all the time. A hosted endpoint adds the key, more GPUs when requests pile up, and none when they stop. That is what the services below sell. ComfyUI's docs list its built-in routes.
Three ways to get an endpoint
Every option here runs your workflow on someone else's GPU. They differ in who packages it: Comfy, a ComfyUI platform, or you.
Comfy's own endpoint
Comfy API turns your ComfyUI, nodes and models into an endpoint; the Cloud API sends jobs to the shared Comfy Cloud.
- Who
- Comfy API, Comfy Cloud API
- Good
- Made by ComfyUI's makers, any node on Comfy API, nothing to maintain.
- Watch
- A plan first (from $20 a month), cards of 80 GB and up only, no spending limits yet, and a region list you see only after signing in.
A ComfyUI platform
Build the workflow in a cloud ComfyUI, then turn it into an endpoint with a click.
- Who
- RunComfy, ViewComfy
- Good
- Any node, no Dockerfile, no plan needed.
- Watch
- Higher hourly rates than serverless GPUs, and cold start and idle time are billed.
Your own container on serverless GPUs
You package ComfyUI, your nodes and your models into an image; the platform runs it by the second.
- Who
- RunPod Serverless, Modal, fal, Replicate
- Good
- The lowest prices per second, and full control.
- Watch
- You write and maintain the image. fal must approve your account first, and Modal no longer has a ComfyUI example.
ComfyDeploy, once a common pick for this, no longer takes new customers: its pricing page says "We are no longer taking new customers." It open-sourced its platform in September 2025, so you can still run it yourself.
What a GPU hour costs
Each service's cheapest card in each size, per hour of GPU time, before tax, read on 20 October 2026. Where a paid plan lowers the rate, the plan rate is shown beside it.
| Service | 24 to 32 GB | 40 to 48 GB | 80 to 96 GB |
|---|---|---|---|
| Comfy APIPlan from $20 a month | - | - | $4.54RTX PRO 6000 |
| Comfy Cloud APIPlan from $20 a month | - | - | $4.54RTX PRO 6000 |
| RunComfyNo plan needed | $1.75 · $1.39 planA10G or A5000 | $2.50 · $1.99 planA6000 | $4.99 · $3.99 planA100 |
| ViewComfyNo plan needed | $1.16L4 | $3.51L40S | $6.15A100 |
| falNo plan needed | - | not published | $4.00RTX PRO 6000 |
| ReplicateNo plan needed | - | $3.51L40S | $5.04A100 |
| RunPod ServerlessNo plan needed | $0.69L4, A5000 or 3090 | $1.22A6000 or A40 | $2.72A100 |
| ModalNo plan needed | $0.80L4 | $1.95L40S | $2.50A100 |
Replicate and Modal publish prices per second; they are shown per hour here. Comfy Cloud prints no hourly rate: its blog gives 0.266 credits a second, which is $4.54 an hour at Comfy's 211 credits to the dollar, and yearly plans make credits 20% cheaper. A faster card finishes the same job sooner, so the cheapest hour is not always the cheapest job. To see which size your workflow needs, run it through the ComfyUI workflow checker.
| Service | How it bills | What you buy first | Free to start |
|---|---|---|---|
| Comfy API | Per GPU-second, plus network storage at $0.20 per GB a month | A paid Comfy plan, from $20 a month; GPU time is billed on top | None: it needs a paid plan |
| Comfy Cloud API | Plan credits, spent per second while a workflow runs | A paid Comfy Cloud plan, from $20 a month; API runs spend the plan's credits | None for the API: the free tier leaves it out |
| RunComfy | Per second the machine is up | None; Pro is $29.99 a month ($19.99 billed yearly) for 20% or more off | None stated for the API |
| ViewComfy | Per active GPU-second, billed monthly | None for one GPU at a time; Team is $30 a month for 2 at once | None found |
| fal | Per second a runner is up, set-up and idle time included | None; prepaid credits, and fal must approve Serverless access first. Lower rates by quote | None found |
| Replicate | Per second of run time on its shared ComfyUI model; private models also bill set-up and idle time | None; prepaid credit | None stated: new accounts buy credit upfront |
| RunPod Serverless | Per second, from when a worker starts until it stops | None; prepaid credit from $10 | None beyond a referral bonus |
| Modal | Per second of GPU time, with CPU and memory billed on top | None; $30 of free credit a month. Team is $250 a month | $30 of credit a month |
What one job costs
A job pays for more than its own seconds. Most services bill a worker from the moment it starts, model loading included, and keep it up for a while after the job in case another arrives. Here is one job that keeps the GPU busy for 60 seconds, on its own, on each service's cheapest card of at least 48 GB, with the idle time each one bills by default.
| Service | Card | Billed | One job | 1,000 jobs |
|---|---|---|---|---|
| RunPod Serverless | A6000 or A4048 GB, $1.22/h | 60 s + 5 s idle+ start-up | $0.022 | $22.03 |
| Replicate | L40S48 GB, $3.51/h | 60 s | $0.059 | $58.50 |
| Modal | L40S48 GB, $1.95/h | 60 s + 60 s idle+ start-up | $0.065 | $65.04 |
| Comfy Cloud APIfrom plan credits | RTX PRO 600096 GB, $4.54/h | 60 s | $0.076 | $75.67 |
| RunComfy | A600048 GB, $2.50/h | 60 s + 60 s idle+ start-up | $0.083 | $83.33 |
| ViewComfy | L40S48 GB, $3.51/h | 60 s + 30 s idle+ start-up | $0.088 | $87.75 |
| Comfy API | RTX PRO 600096 GB, $4.54/h | 60 s + 30 s idle+ start-up | $0.114 | $113.50 |
| fal | RTX PRO 600096 GB, $4.00/h | 60 s + 60 s idle+ start-up | $0.133 | $133.33 |
"+ start-up" means the service also bills the cold start, but none states how long a full ComfyUI cold start takes, model loading included, so it is not in the figure. Comfy Cloud API, Comfy API and fal run the job on cards of 80 GB or more, which are faster, so the same job takes them less time. Jobs that arrive back to back share the idle time, and a worker kept warm to avoid cold starts bills every second it is up. RunComfy's 60 seconds is its suggested keep-warm setting. Modal adds CPU and memory, and ViewComfy lists CPU and memory rates without saying whether API runs pay them. Comfy Cloud runs spend plan credits.
Comfy API and the Cloud API
Comfy Org, the company behind ComfyUI, sells two APIs. Comfy API, live since 30 September 2026, takes your ComfyUI version, custom nodes, models and pinned Python packages as a Build, and deploys a release of it as an endpoint of your own that scales with traffic. The Comfy Cloud API skips the Build: it sends a workflow to the shared Comfy Cloud, with its curated nodes, and spends the credits of your Cloud plan. Both use one API key and one SDK.
| Plan | Monthly | Deployments | Workers each |
|---|---|---|---|
| Standard | $20 | 2 | 2 |
| Creator | $35 | 2 | 2 |
| Pro | $100 | 5 | 10 |
| Team | from $200 | 20 | 20 |
GPU time for a deployment is billed per second on top of the plan: $4.54 an hour for an RTX PRO 6000 (96 GB), $6.23 an hour for an H100 (80 GB), $7.71 an hour for an H200 (141 GB) and $11.23 an hour for a B200 (180 GB), and storage for models is $0.20 per GB a month. A worker bills from the moment it starts, model loading included, through 30 seconds of idle time; set the minimum to 0 and the endpoint costs nothing between jobs, at the price of a cold start, whose length Comfy does not state.
Coding agents can do the deploying: Comfy's docs give a prompt that installs its command-line tool and tells the agent to wait for your approval before it creates a deployment; that step lives in the prompt, not in Comfy's service. What it does not have yet is a spending limit: Comfy says limits per user, project and workspace are being built, and until then a deployment stops when the credits run out. You pick a region for each deployment, but the list shows only after you sign in. Comfy's own advice is fair: if ComfyUI already runs for you on RunPod or Modal and it works, keep it.
Custom nodes, LoRAs and models
| Service | Custom nodes | Your models and LoRAs |
|---|---|---|
| Comfy API | Any nodePublic or private nodes, packaged into a Build from comfy-cli, a Desktop snapshot or a workflow file | Checkpoints and LoRAs go into the Build, on network storage |
| Comfy Cloud API | Curated setA curated set of popular nodes; you cannot add your own | Your own models and LoRAs from the Creator plan ($35), imported from Hugging Face or Civitai |
| RunComfy | Any nodeAny node, installed with ComfyUI Manager in a cloud session, then saved into a container | Upload, or download from Civitai, Hugging Face or Google Drive; 10 GB kept (200 GB on Pro) |
| ViewComfy | Any nodePublic node packs from ComfyUI Manager, private ones from Git; custom environments on Studio ($200 a month) | By download link from Hugging Face, Civitai or your own bucket; storage is free |
| fal | Any nodeAny node, installed in your own Dockerfile; fal has no hosted ComfyUI endpoint | By download link; private Hugging Face repos with a stored token |
| Replicate | A fixed listShared model: a fixed list kept in its GitHub repo; any node in your own Cog model | LoRAs by link from Civitai or Hugging Face; your own weights through a private model or the train tab |
| RunPod Serverless | Any nodeAny node, in your own Docker image built from its ComfyUI worker; the one-click version runs FLUX.1 dev only | In the image, or on a network volume at $0.07 per GB a month |
| Modal | Any nodeAny node, in an image you define in Python; Modal no longer has a ComfyUI example | In a Modal Volume: the first 1 TiB is free, then $0.09 per GiB a month |
The ComfyUI workflow checker lists every custom node and model file a workflow loads, with the memory it needs, so you can check it against a service's list before you pay. It runs in your browser; the workflow is not uploaded.
Cold starts and scaling to zero
An endpoint that scales to zero costs nothing between jobs, and the first job after a pause waits for a GPU to start and load the models. Keeping a worker warm removes the wait and bills every second it is up.
| Service | Scales to zero | Billed around the run | Cold start, as stated |
|---|---|---|---|
| Comfy API | Yes, with minimum workers at 0; warm workers bill all the time | Billed from the moment a worker starts, model loading included, then 30 seconds of idle time | Not stated; the estimate at deploy time covers the deployment coming up, not each cold start |
| Comfy Cloud API | Nothing to scale: a shared service that is always on | Run time only: no start-up or idle charge | Not stated; 1 run at a time on Standard, 3 on Creator, 5 on Pro; runs stop at 30 minutes (1 hour on Pro) |
| RunComfy | Yes, with minimum instances at 0 | Cold start, run and keep-warm time are billed; 60 seconds of keep-warm is its suggested setting | Not stated; after idle the first request "may take a few minutes" |
| ViewComfy | Yes, with minimum GPUs at 0 | Billed from the moment a request arrives until 30 seconds after the last one, by default | ComfyUI starts in 30 seconds to 2 minutes, before models load; under 10 seconds with its memory snapshot (in beta, on request) |
| fal | Yes, by default | Set-up is billed, and a runner stays up 60 seconds after its last job by default | Not stated for ComfyUI |
| Replicate | Yes, by default | Shared model: run time only. A private model or deployment bills set-up and idle time too | Cold boots are rare on a model this popular but "can take several minutes"; it says a run typically takes 24 seconds |
| RunPod Serverless | Yes, by default | Cold start and run are billed, then 5 seconds of idle time by default | Sold as "sub-200ms" with FlashBoot; no figure for ComfyUI |
| Modal | Yes, by default | Loading is billed, and a container stays up 60 seconds after its last job by default | Containers boot "in about one second", before ComfyUI and its models load |
Agents: MCP and spend limits
An agent with an API key can start GPUs as fast as it can send requests. What stops it is a limit the owner sets on the platform, or the balance running out. Comfy Cloud API, RunComfy, fal, Replicate and RunPod Serverless run hosted MCP servers; only Modal and RunPod have a spending limit the platform enforces.
| Service | MCP | Spend limits |
|---|---|---|
| Comfy API | None for deployments; coding agents deploy with its comfy-cli skills, and its prompt asks them to wait for your approval | None yet: Comfy says spending limits are being built; deployments stop when credits run out |
| Comfy Cloud API | Hosted MCP (an early release): runs templates and workflows, checks your balance | None yet; runs fail with an error when credits run out |
| RunComfy | Hosted MCP with 31 tools: creates deployments, submits jobs, reads your balance | None; a prepaid balance and a maximum number of instances |
| ViewComfy | None found | None found; usage and spend charts |
| fal | Two hosted MCPs: one runs gallery models (its approval prompts are not enforced by the server), one reads your serverless apps, logs and spend | None on the API; a maximum number of runners and prepaid credits |
| Replicate | Hosted MCP covering its whole HTTP API | None to set yourself: the monthly spend limit is deprecated (support may still set one); prepaid credit and a maximum number of instances |
| RunPod Serverless | Hosted MCP: creates, runs and deletes endpoints, reads billing | $80 an hour across the account by default; a maximum number of workers per endpoint |
| Modal | No official MCP; agent skills for coding agents | A monthly budget and spend limit that stop work; budgets per environment on Team |
Where it runs, and training
Comfy API, Comfy Cloud API, fal and Modal say in their terms that they will not train on your content, though fal's main terms still let it use anonymised data derived from your input; the others do not promise either way. RunPod, Modal and fal can keep the GPUs in Europe: RunPod by data centre (its storage docs name two in the EU and two elsewhere in Europe), Modal by region, at 1.15 to 1.75 times the price and with Volumes, images and logs still in the United States, and fal by region (eu-north and eu-west). Comfy API asks for a region on every deployment but shows the list only after you sign in.
| Service | Training on your content | Where the GPUs are |
|---|---|---|
| Comfy API | Says it will not train on your contentTerms: will not use inputs or outputs to train generative AI models; may use metadata such as workflow structures | A region you pick for each deployment, from a list shown only after you sign in |
| Comfy Cloud API | Says it will not train on your contentTerms: will not use inputs or outputs to train generative AI models; may use metadata such as workflow structures | Not stated for paid plans (its Enterprise page says the United States, on Google Cloud) |
| RunComfy | Does not sayIts policies do not mention training; it says deployments are isolated and outputs private | The United States, per its terms |
| ViewComfy | Does not sayTerms do not mention training; it may use content to run the service, and keeps every output | Not stated |
| fal | Says it will not train on your contentAPI terms: will not use your content to train its products; its main terms let it use anonymised data derived from your input, AI models included | Regions you choose for an app, eu-north and eu-west included |
| Replicate | Does not sayNo promise either way; its licence covers your own fine-tunes and anonymised totals. API data is deleted after an hour | Not stated (Replicate is part of Cloudflare) |
| RunPod Serverless | Does not sayNo promise: its terms let it use your content, anonymised and in aggregate, to improve the service | Data centres you choose; its storage docs name four in Europe: Czechia and Romania in the EU, Iceland and Norway outside it |
| Modal | Says it will not train on your contentTerms: will not train any AI model on your data without written consent; its security docs keep inputs and outputs up to 7 days | Any region, the EU included, for 1.15 to 1.75 times the price; Volumes, images and logs stay in the United States |
Questions
Does ComfyUI have an API?
Yes. ComfyUI's own server takes a workflow as JSON: export it in API format, POST it to /prompt on port 8188, and read the results from /history once it has run. A websocket at /ws reports progress. It has no login of its own and listens only on your machine unless you start it with --listen, so to serve other people or apps you put it behind a hosted endpoint.
What is Comfy API?
Comfy Org's own way to serve a workflow, live since 30 September 2026. You package your ComfyUI version, custom nodes, models and LoRAs into a Build, cut a release and deploy it as an endpoint that scales with traffic, to zero when idle. It needs a paid Comfy plan from $20 a month, and GPU time is billed per second on top: $4.54 an hour for an RTX PRO 6000, $6.23 an hour for an H100, $7.71 an hour for an H200, $11.23 an hour for a B200. The Comfy Cloud API is different: it sends jobs to the shared Comfy Cloud, with its curated nodes, and spends your plan's credits.
What is a ComfyUI API key?
Your local ComfyUI needs no key. A Comfy API key, made in your Comfy account, is what lets ComfyUI run Partner Nodes (paid hosted models), and it is the same key for the Comfy Cloud API, Comfy API deployments and Comfy's MCP server.
How much does a ComfyUI API cost?
Per GPU hour, before tax, the cheapest card in each size runs from $0.69 for a 24 GB card (L4, A5000 or 3090) on RunPod Serverless to $6.15 for an 80 GB card (A100) on ViewComfy. A job that keeps a card of 48 GB or more busy for a minute costs from $0.022 at RunPod Serverless (A6000 or A40, 48 GB) to $0.133 at fal (RTX PRO 6000, 96 GB, a faster card), once the idle time each one bills is added. Comfy API also needs a plan from $20 a month.
Can I use custom nodes with a ComfyUI API?
Any node on Comfy API, RunComfy, RunPod Serverless, Modal and fal, where you install them yourself; public packs and private ones from Git on ViewComfy. The Comfy Cloud API has a curated set you cannot add to, and Replicate's shared model a fixed list. Check which nodes a workflow uses with the ComfyUI workflow checker before you pick.
What is the cheapest way to run a ComfyUI workflow as an API?
For steady traffic, RunPod Serverless: $0.69 an hour for 24 GB and $1.22 for 48 GB, billed per second with 5 seconds of idle time, if you build the Docker image. For a few runs, Replicate's shared ComfyUI model bills only run time, about $0.023 for a typical run, as long as its node list covers your workflow.
Is there a free ComfyUI API?
ComfyUI's own API is free on your own computer. Hosted, Modal gives $30 of credit a month, which pays for its GPUs; Comfy's free tier leaves out API access, and the others sell prepaid credit or bill monthly.
Can AI agents use a ComfyUI API?
Yes. Comfy Cloud API, RunComfy, fal, Replicate and RunPod Serverless run hosted MCP servers an agent can call. What stops an agent from overspending is rarer: Modal has a monthly budget and spend limit, RunPod an account-wide $80 an hour by default; elsewhere it is the prepaid balance or a worker limit. Comfy says its spending limits are being built.
Which ComfyUI API runs in the EU?
RunPod Serverless, Modal and fal can keep the GPUs in Europe. RunPod lets you hold an endpoint to chosen data centres, and its storage docs name four in Europe, two of them in the EU (Czechia and Romania). Modal can pin GPUs to the EU for 1.15 to 1.75 times the price, though Volumes, images and logs stay in the United States. fal lets you restrict an app to its eu-north and eu-west regions. Comfy API asks for a region on every deployment but lists them only after you sign in; RunComfy is hosted in the United States, and the others do not say.
What happened to ComfyDeploy?
It no longer takes new customers: its pricing page says "We are no longer taking new customers." Existing customers keep their service, and it open-sourced its platform in September 2025, so you can still run it yourself.
Will my workflows be used for training?
Comfy API, Comfy Cloud API, fal and Modal say in their terms they will not, though fal's main terms still let it use anonymised data derived from your input. RunComfy and ViewComfy do not mention training. RunPod's terms let it use your content, anonymised and in aggregate, to improve its service, and Replicate's licence covers your own fine-tunes and anonymised totals; neither promises either way.
Sources, all read on 20 October 2026: Comfy API pricing, Comfy Cloud API pricing, RunComfy pricing, ViewComfy pricing, fal pricing, Replicate pricing, RunPod Serverless pricing, Modal pricing, plus each service's docs and terms, linked in the tables, ComfyDeploy's pricing page, and ComfyUI's server routes. RunPod Serverless and Modal prices are the same as in the cloud GPU guide, read there on 19 October 2026. Prices are before tax: every service here except ViewComfy says tax is added or not included, and ViewComfy does not say.