Run ComfyUI and FLUX.1 on a Rented GPU With a Public HTTPS Endpoint (2026)

ComfyUI is the tool most people reach for when they want FLUX.1 with control over the pipeline rather than a text box, and a 24 GB card at home is the usual bottleneck. This post walks through renting a GPU on cloudgpu.app with the ComfyUI template, loading FLUX.1 dev or schnell, driving it through the ComfyUI HTTP API from your own machine, what a 200-image batch costs, and when to call the hosted FLUX API instead.

All prices were read on 10 September 2026: ours from the live inventory behind the pricing page, RunPod’s from their public pricing page the same day.

Which card

Card on cloudgpu.app	VRAM	Price, 10 Sep 2026	FLUX.1 dev FP16 (about 24 GB)	FLUX.1 dev FP8 (12 to 16 GB)
RTX 4090D	24 GB	$0.32/h	tight; expect offloading of the text encoder	comfortable
RTX 5090	32 GB	$0.59/h	comfortable, with room for LoRAs and ControlNet	comfortable, faster
RTX 3090	24 GB	$0.21/h (Spot $0.15/h)	tight, and no native FP8	works, slower

Two honest notes. The 24 GB card in stock today is the RTX 4090D, the China-market 4090 with about 10 percent fewer CUDA cores: same memory, slightly slower. And the whole inventory is in mainland China today (region Asia-China on every row); see the latency section.

For comparison, RunPod’s pricing page on 10 September 2026 lists the RTX 4090 at $0.34/h on Community Cloud and $0.74/h on Secure Cloud, and the RTX 5090 at $0.69 and $0.99. RunPod’s ComfyUI template has no separate price; you pay the pod rate for the card you pick. So we are two cents under their community 4090 and 10 to 40 cents under on the 5090. If you need an A100, we have none in stock today, and when we do list it, it has not been cheaper than RunPod’s community A100.

Deploy the ComfyUI template

1. Sign up at cloudgpu.app with email or Google and top up: USDT on TRC-20 (minimum 1 USDT), bank transfer for businesses; card payments are coming soon.
2. Open Deploy, pick RTX 4090D or RTX 5090 and the ComfyUI template, click Deploy.
3. Wait. We measured 105 to 121 seconds from click to a reachable endpoint on 6 September 2026, not the 60 seconds some of our older copy promised; about 20 seconds of that is the watchdog and tunnel install.

The instance row then shows three addresses: SSH and JupyterLab on the supplier’s own network, and the API endpoint at https://<16-char-id>-i.cloudgpu.app. That last one is ComfyUI’s port 8188, published through a reverse tunnel our backend installs at boot. The tunnel server only accepts the exact hostname registered for that instance, and each tunnel is capped at 3 MB/s: plenty for JSON and finished PNGs, too small to serve as a file mirror. The mechanism is described in the Ollama guide.

Load the FLUX.1 weights

Download on the machine over SSH or a JupyterLab terminal, so the files arrive on the supplier’s connection rather than through the tunnel. FLUX.1 dev requires accepting Black Forest Labs’ licence on Hugging Face (non-commercial weights); schnell is Apache 2.0.

cd /workspace/ComfyUI/models
pip install -U "huggingface_hub[cli]"
huggingface-cli login   # only needed for dev

# FP8, single file with text encoders and VAE bundled (~17 GB each)
huggingface-cli download Comfy-Org/flux1-dev flux1-dev-fp8.safetensors --local-dir checkpoints
huggingface-cli download Comfy-Org/flux1-schnell flux1-schnell-fp8.safetensors --local-dir checkpoints

# FP16 (RTX 5090): transformer + VAE from Black Forest Labs (~23.8 GB + 335 MB)
huggingface-cli download black-forest-labs/FLUX.1-dev flux1-dev.safetensors --local-dir unet
huggingface-cli download black-forest-labs/FLUX.1-dev ae.safetensors --local-dir vae
# plus clip_l.safetensors and a t5xxl encoder into models/clip, linked from ComfyUI's FLUX examples page

Budget five to fifteen minutes for downloads, billed; start with FP8 if you are in a hurry, then hit Refresh in the ComfyUI sidebar.

Call it over HTTPS

ComfyUI’s API is the same JSON the UI sends. Build a workflow in the UI, enable Dev mode, click Save (API format), and you have the object /prompt expects. A minimal FLUX dev FP8 graph:

{
  "1": {"class_type": "CheckpointLoaderSimple", "inputs": {"ckpt_name": "flux1-dev-fp8.safetensors"}},
  "2": {"class_type": "CLIPTextEncode", "inputs": {"clip": ["1", 1], "text": "a lighthouse at dusk, 35mm film"}},
  "3": {"class_type": "EmptySD3LatentImage", "inputs": {"width": 1024, "height": 1024, "batch_size": 1}},
  "4": {"class_type": "KSampler", "inputs": {"model": ["1", 0], "positive": ["2", 0], "negative": ["2", 0],
        "latent_image": ["3", 0], "seed": 42, "steps": 20, "cfg": 1.0, "sampler_name": "euler", "scheduler": "simple", "denoise": 1.0}},
  "5": {"class_type": "VAEDecode", "inputs": {"samples": ["4", 0], "vae": ["1", 2]}},
  "6": {"class_type": "SaveImage", "inputs": {"images": ["5", 0], "filename_prefix": "flux"}}
}

FLUX ignores the negative prompt and wants cfg at 1.0. For schnell set steps to 4.

curl:

EP=https://<your-id>-i.cloudgpu.app
curl -s $EP/prompt -H 'Content-Type: application/json' \
  -d "{\"prompt\": $(cat workflow_api.json)}"
# -> {"prompt_id":"6f1c...","number":0,"node_errors":{}}
curl -s $EP/history/6f1c... | jq '.[].outputs."6".images[0]'
curl -s "$EP/view?filename=flux_00001_.png&type=output" -o flux_00001.png

Python, looping over a list of prompts and waiting for each result:

import json, time, requests

EP = "https://<your-id>-i.cloudgpu.app"
wf = json.load(open("workflow_api.json"))

def generate(text, seed):
    wf["2"]["inputs"]["text"] = text
    wf["4"]["inputs"]["seed"] = seed
    pid = requests.post(f"{EP}/prompt", json={"prompt": wf}, timeout=30).json()["prompt_id"]
    while True:
        h = requests.get(f"{EP}/history/{pid}", timeout=30).json()
        if pid in h:
            img = h[pid]["outputs"]["6"]["images"][0]
            return requests.get(f"{EP}/view", params={"filename": img["filename"], "type": "output"}).content
        time.sleep(1)

for i, p in enumerate(open("prompts.txt")):
    open(f"out_{i:03d}.png", "wb").write(generate(p.strip(), seed=i))

The tunnel adds no authentication. If the URL must not be usable by anyone who finds it, put ComfyUI behind a token with a login extension such as ComfyUI-Login.

What a 200-image batch costs

Timings below are estimates, not guarantees; measure with one image before committing a batch. Prices are live from 10 September 2026, billed per minute; the one-hour pre-authorisation is refunded for unused minutes.

	RTX 4090D, dev FP8	RTX 5090, dev FP16
Hourly price	$0.32	$0.59
Boot + weight download	~12 min	~12 min
1024×1024, 20 steps, per image	~20 s (estimate)	~12 s (estimate)
200 images	~67 min	~40 min
Total billed time	~79 min = $0.42	~52 min = $0.51
Per image, warm machine	$0.0018	$0.0020
Fetching 200 PNGs (~1.2 MB each) through the 3 MB/s tunnel	~80 s	~80 s

Two hundred images for well under a dollar is the case for renting. The overhead is the twelve minutes of boot and downloads you pay every fresh start, so if you generate in bursts, keep the instance up between them or accept that a 20-image batch is mostly setup.

The latency caveat

Machines are in mainland China. From the US or Europe, expect 150 to 250 ms per round trip. In ComfyUI that shows up where you would expect: dragging nodes, the live preview during sampling and the image gallery all feel sluggish. Generation runs on the GPU and takes as long as it would from Shanghai. If your workflow is “build the graph interactively, then batch”, build the graph locally on a CPU with the same node set, export API JSON, and run only the batch remotely. If you need a snappy UI from the US, RunPod’s US regions are the better choice.

When to use the hosted FLUX API instead

cloudgpu.app also serves FLUX behind the OpenAI-compatible images endpoint, on the same balance as the GPUs. From our pricing feed on 10 September 2026:

Model id	Per image
flux-1-schnell	$0.0015
flux-1-dev	$0.0125

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

The break-even is simple. A 200-image dev batch is $2.50 on the API against roughly $0.42 on a rented 4090D: the GPU wins by a factor of six. At 30 images it is $0.38 on the API against twelve minutes of boot and downloads ($0.06 plus your time). The API also gives you no ComfyUI: no LoRAs, ControlNet or custom nodes. Use the API for sporadic generations and anything under a few hundred dev images a week; rent the GPU when you need the node graph or the volume.

If a number in this post is wrong, email support@cloudgpu.app and we will fix it. Prices here are a snapshot from 10 September 2026; the pricing page is live.