ComfyUIFLUXImage generationTutorialRTX 4090RTX 5090

Run ComfyUI and FLUX.1 on a Rented RTX 4090, RTX 5090 or A100 by the Minute, With a Public HTTPS Endpoint

Deploy the ComfyUI template on an RTX 4090, RTX 5090 or A100 80G billed per minute, download FLUX.1 weights on the machine, export an API workflow and call /prompt over HTTPS with curl or Python.

CloudGPU··Updated October 24, 2026·8 min read
Run ComfyUI and FLUX.1 on a Rented RTX 4090, RTX 5090 or A100 by the Minute, 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. VRAM use depends on resolution, precision and workflow. If you only need a bigger card for an afternoon of batch generation, renting it by the minute and destroying it when the queue is empty is the whole idea. This guide goes from Deploy to a Python script that queues FLUX workflows over HTTPS, and shows how to estimate the bill before you start.

The cards

RTX 4090 24G RTX 5090 32G A100 80G
Architecture / VRAM / memory bandwidth Ada, 24 GB, 1008 GB/s Blackwell, 32 GB, 1792 GB/s Ampere, 80 GB, 1935 GB/s
Billing Per minute, 1-minute minimum Per minute, 1-minute minimum Per minute, 1-minute minimum
Current hourly rate On cloudgpu.app/pricing On cloudgpu.app/pricing On cloudgpu.app/pricing

Start with the RTX 4090 (24 GB, Ada, native FP8). The RTX 5090 gives you 32 GB on a Blackwell card, which also runs FP8 natively. Move to the A100 80G (80 GB) when your graph needs more memory, for example several LoRAs, ControlNet or large batches.

See current rates on /pricing.

How billing runs: while an instance runs, each started hour is pre-charged from your balance; unused minutes go back to your balance when you destroy the instance.

Will FLUX fit?

VRAM use depends on resolution, precision and workflow.

Ampere cards such as the RTX 3090 and the A100 have no native FP8. FP8 checkpoints still load on them; speed depends on the card and workflow, so time one image on your own workflow first.

Step 1: add balance

Top up on the billing page with Visa or Mastercard, Alipay (offered in most countries) or Google Pay / Apple Pay in the same checkout, with USDT on TRC-20, or by bank transfer if you are a business customer (payments). The same balance pays for GPU minutes and for API tokens.

Step 2: deploy the ComfyUI template

On cloudgpu.app/deploy, choose the ComfyUI template and the RTX 4090 24G, the RTX 5090 32G, or the A100 80G for the largest graphs, then click Deploy. After about 2 minutes the instance row shows root SSH, JupyterLab and a public HTTPS endpoint.

What the template gives you:

  • ComfyUI itself. It does not include FLUX or any other weights; you download those once the instance is ready.
  • An endpoint of the form https://<16-char-id>-i.cloudgpu.app: a reverse tunnel to ComfyUI’s port 8188 that exists only while the instance runs. The tunnel accepts only the hostname registered for your instance.
  • No authentication on that URL. If it must stay private, install a login or token extension such as ComfyUI-Login.
  • A 3 MB/s cap on the tunnel: fine for JSON and finished images, not for moving model files.

Step 3: download the weights on the machine

Open a JupyterLab terminal or SSH in and download into the matching folders under ComfyUI/models/, so the files arrive on the machine’s own connection rather than through the 3 MB/s tunnel. The Hugging Face CLI is hf (Hugging Face CLI guide):

cd ComfyUI/models   # the ComfyUI folder on the instance
pip install -U huggingface_hub

# FP8 single-file checkpoints, packaged for ComfyUI
hf download Comfy-Org/flux1-schnell flux1-schnell-fp8.safetensors --local-dir checkpoints
hf download Comfy-Org/flux1-dev flux1-dev-fp8.safetensors --local-dir checkpoints

Check the licence before you use the outputs: FLUX.1 schnell is Apache 2.0, while FLUX.1 dev is under Black Forest Labs’ own licence, which you accept on its Hugging Face page. FP8 checkpoints are smaller and download faster than 16-bit ones; download time is machine time, so it is billed. When the files are in place, hit Refresh in the ComfyUI sidebar.

Step 4: export the workflow in API format

ComfyUI’s API takes the same JSON the UI sends. Build the graph in the UI, enable Dev mode and use Save (API format) to export workflow_api.json. A minimal FLUX dev FP8 graph looks like this:

{
  "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.

Step 5: queue it from your own machine

ComfyUI’s server takes a workflow on POST /prompt and returns a prompt_id; GET /history/{prompt_id} returns the result and GET /view serves the image (ComfyUI server routes).

With 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/<prompt_id>" | jq '.[].outputs."6".images[0]'
curl -s "$EP/view?filename=flux_00001_.png&type=output" -o flux_00001.png

With Python, looping over a list of prompts:

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 generate(text, seed):
    wf["2"]["inputs"]["text"] = 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 = h[pid]["outputs"]["6"]["images"][0]
            return requests.get(f"{EP}/view", params={"filename": img["filename"], "type": "output"},
                                headers=HEADERS, timeout=60).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))

Step 6: copy your outputs, then destroy

Stopped instances release their GPU, and persistent storage across restarts is still on the roadmap. Copy images, workflows and anything else you want to keep off the machine, then click Destroy so billing stops and the unused minutes return to your balance.

Estimate the bill before you start

cost ≈ minutes the instance runs × (hourly rate on cloudgpu.app/pricing ÷ 60)

Count three things: download time, generation time and idle time between batches. Seconds per image depend on the model, resolution, steps and card, so time one image on your own workflow first and multiply by the batch size. The fixed part is setup: about 2 minutes to start plus your download time on every fresh instance. If you generate in short bursts, either keep the instance up between them or accept that a small batch is mostly setup.

When the hosted FLUX API is enough

cloudgpu.app also serves FLUX through the OpenAI-compatible images endpoint, on the same balance as the GPUs. flux-1-schnell and flux-1-dev are priced per image on /api:

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

The API gives you no ComfyUI: no LoRAs, ControlNet or custom nodes, and nothing to set up. Use it for occasional images; rent the GPU when you need the node graph or the volume. To compare the two for your own workload, multiply the per-image price on /api by your batch size and set it against the cost estimate above.

FAQ

How long until ComfyUI is reachable? About 2 minutes after you click Deploy.

Is FLUX preinstalled? No. The ComfyUI template installs ComfyUI only; download FLUX or other weights once the instance is ready.

Can I call the ComfyUI API from my own server without SSH? Yes. The template publishes port 8188 at https://<id>-i.cloudgpu.app, so POST /prompt, GET /history and GET /view work from anywhere over HTTPS. The tunnel is capped at 3 MB/s and accepts only the hostname registered for that instance.

Is the endpoint password-protected? No. The tunnel adds no authentication; install a login or token extension if the URL must stay private.

Do my models stay on the machine after I destroy it? No. Persistent storage across restarts is on the roadmap, so plan the download into each session.

Sources

All read on 24 October 2026 (Beijing time, UTC+8).

Share this post
TwitterLinkedInCopy link

Try cloudgpu.app — no credit card required

No credit card required. Per-minute billing, deploy in about 2 minutes.

Deploy a modelSee pricing