Rent a GPU for ComfyUI: per-minute billing and a public HTTPS endpoint

CloudGPU rents GPUs for ComfyUI by the minute: pick a card and the ComfyUI template, and in about 2 minutes you get SSH, JupyterLab and a public HTTPS endpoint for ComfyUI’s API. Billing starts when the GPU is ready and runs per minute at the card’s rate on pricing; destroy the instance when the batch is done.

This page is for choosing the card and estimating the cost. For a full FLUX.1 walk-through with a ready workflow, see the full FLUX.1 walk-through.

What you get with the ComfyUI template

Item	Detail
Access	Root SSH and JupyterLab on the supplier’s address
API endpoint	`https://<16-char-id>-i.cloudgpu.app`, a reverse tunnel to ComfyUI’s port 8188, live only while the instance runs
Tunnel limits	Accepts only the hostname registered for your instance; capped at 3 MB/s per tunnel (fine for JSON and finished images, not for moving model files)
Authentication	The tunnel adds none. Add a login/token extension such as ComfyUI-Login if the URL must stay private
Billing	Per minute, 1-minute minimum; billing starts when the GPU is ready; 1 hour pre-authorised and unused minutes go back to your balance when you destroy the instance. Rates: pricing

Model weights: the template gives you ComfyUI itself, not FLUX weights. Download the checkpoints, text encoders, VAE and LoRAs your workflow needs over SSH or a JupyterLab terminal, into the matching folders under ComfyUI/models/, so files arrive on the supplier’s connection, not through the 3 MB/s tunnel. FP8 checkpoints are smaller and download faster than 16-bit ones. FLUX.1 dev requires accepting Black Forest Labs’ licence on Hugging Face; FLUX.1 schnell is Apache 2.0.

Which card for which workflow

VRAM figures come from our model pages (FLUX.1 dev, SDXL), checked 2026-09-08. Current rates for every card are on pricing. The Deploy page shows what you can start now.

Workflow	VRAM needed (approx.)	VRAM class	Example cards
SDXL, SD 1.5, light LoRA stacks	about 7 GB at FP16	24 GB	RTX 3090, RTX 4090D, RTX 4090
FLUX.1 dev / schnell at FP8	VRAM use depends on resolution and precision	24 GB	RTX 4090, RTX 4090D
FLUX.1 dev at FP16	VRAM use depends on resolution and precision	32 GB or more	RTX 5090, RTX 4090 48G
FLUX + several LoRAs + ControlNet, large batches	VRAM use depends on resolution and precision	48 GB	RTX 4090 48G, RTX A6000

Two practical notes:

FP8 and older cards. Ampere cards such as the RTX 3090 have no native FP8; FP8 checkpoints still load, but expect slower runs than on Ada or Blackwell cards.
RTX 4090D is a variant of the RTX 4090 with the same 24 GB of memory and slightly fewer CUDA cores.

Start in four steps

Top up. Alipay, Google Pay, Apple Pay, Visa/Mastercard, or USDT on TRC-20 (payments).
Deploy. On Deploy, choose the ComfyUI template and a card from the table above, then click Deploy.
Wait about 2 minutes. The instance row shows SSH, JupyterLab and the API endpoint.
Download weights and build your graph. FLUX is not preloaded: download the models you need over SSH, open ComfyUI, enable Dev mode and use Save (API format) to export the workflow JSON.

Call it from code

ComfyUI’s HTTP API is the same one the UI uses. Queue a workflow with POST /prompt, poll GET /history/{prompt_id}, download with GET /view.

import json, time, requests

EP = "https://<your-id>-i.cloudgpu.app"      # from the instance row
HEADERS = {}                                  # add your auth header if you installed a login extension
wf = json.load(open("workflow_api.json"))     # exported with "Save (API format)"

def run(prompt_text: str, seed: int) -> bytes:
    wf["2"]["inputs"]["text"] = prompt_text   # node ids depend on your graph
    wf["4"]["inputs"]["seed"] = seed
    pid = requests.post(f"{EP}/prompt", json={"prompt": wf}, headers=HEADERS, timeout=30).json()["prompt_id"]
    while True:
        h = requests.get(f"{EP}/history/{pid}", headers=HEADERS, timeout=30).json()
        if pid in h:
            img = next(iter(h[pid]["outputs"].values()))["images"][0]
            return requests.get(f"{EP}/view", params={"filename": img["filename"], "type": "output"},
                                headers=HEADERS, timeout=60).content
        time.sleep(1)

open("out_000.png", "wb").write(run("a lighthouse at dusk, 35mm film", seed=1))

Estimate the cost before you start

total_minutes = weight downloads + (images × seconds_per_image / 60) + idle
# billing starts when the GPU is ready
cost          = ceil(total_minutes) × hourly_rate / 60
# hourly_rate: the card's current rate on cloudgpu.app/pricing

seconds_per_image depends on the model, resolution, steps and card, so measure it: run one image, note the time, then multiply. We do not publish a speed table here because a number measured on one workflow rarely holds for another.

Illustrative arithmetic (the inputs are assumptions, not measurements; the 20 s per image is the estimate used in our FLUX walk-through, so replace it with your own number): if setup and downloads take 12 minutes once the instance is running and each image takes 20 s for a 200-image batch, the run is 12 + 66.7 + 2 idle ≈ 81 minutes. Multiply 81 by the card’s hourly rate on pricing and divide by 60.

When the hosted FLUX API is the better fit

If you only need occasional images and no custom nodes, the same balance pays for FLUX through the OpenAI-compatible images endpoint. The API page lists flux-1-schnell and flux-1-dev with their current per-image rates. Rent the GPU when you need the node graph, LoRAs, ControlNet or volume; use the API for sporadic generations.

from openai import OpenAI
client = OpenAI(base_url="https://cloudgpu.app/v1", api_key="YOUR_CLOUDGPU_KEY")
r = client.images.generate(model="flux-1-schnell", prompt="a lighthouse at dusk", size="1024x1024")
print(r.data[0].url)

Good fit, poor fit

Situation	Verdict
No local GPU or not enough VRAM, occasional batch generation	Good fit: rent by the minute, destroy when done
You need FLUX with LoRAs, ControlNet or custom nodes	Good fit: the hosted API cannot run a node graph
ComfyUI as a backend for your own app	Good fit: public HTTPS endpoint plus a login extension

FAQ

Can I run ComfyUI on a rented GPU billed by the minute? Yes. Choose the ComfyUI template on the Deploy page. Billing is per minute with a 1-minute minimum; one hour is pre-authorised, and unused minutes go back to your balance when you destroy the instance.

How do I call ComfyUI from my own code? Use the instance’s https://<id>-i.cloudgpu.app endpoint: POST /prompt with a workflow exported via “Save (API format)”, poll /history/{prompt_id}, then download from /view.

Is the ComfyUI endpoint protected by a password? No. The tunnel only accepts your instance’s hostname but adds no authentication. Install a login or token extension if the URL must stay private.

How much VRAM does ComfyUI need for FLUX.1 dev? VRAM use depends on resolution and precision.

Does the ComfyUI template include FLUX weights? No. The template runs ComfyUI; you download FLUX or any other weights yourself over SSH or JupyterLab. FLUX.1 dev requires accepting the licence on Hugging Face first.

Current rates are on pricing; what you can start now is on Deploy. Eligibility: see the Terms and Acceptable Use Policy.

Deploy the ComfyUI template Check live prices