11 November 2026 · VRAMfarm team

ComfyUI on a rented GPU: your own models, LoRAs, custom nodes and the 502 page

You clicked Open ComfyUI a minute after launch and got a 502 error or a white page. Nothing is broken: on a fresh server ComfyUI installs itself first (about 5 minutes on the first launch), and a ready-made app then downloads 7 to 70 GB of models in the background. The dashboard tells you when it is really ready; until then, a couple of terminal commands show how far it has got.

Ready-made app or empty ComfyUI

Both are free; you pay only for GPU time, from €0.59 an hour on an RTX 4090, and the traffic of what the server downloads. The difference is what gets downloaded for you.

Pick a ready-made app when your model is in the list: the files land in the right folders and the matching built-in workflow runs straight away. Pick the empty ComfyUI when you bring your own stack, for example an SD 1.5 or Pony checkpoint from Civitai. If your checkpoint is SDXL-based (Pony, Illustrious and most SDXL fine-tunes), the SDXL app is a good starting point too, because the VAE and the base workflow are already there.

For a comparison of cards, see which GPU to pick for Flux, SDXL and ComfyUI or the ComfyUI template page.

When is ComfyUI ready? 502, blank page and missing models

A launch goes through three stages, and each one has its own symptom if you open the page too early.

1. The machine starts (usually 2–5 minutes). SSH and Jupyter come up. The ComfyUI address does not answer yet.
2. ComfyUI installs and starts (a few minutes more). The address returns 502 or a blank page until the ComfyUI process is listening.
3. Models download, one file at a time. The interface already works, and models appear in the lists as they arrive. If you run a workflow now, you get “missing model”, “Value not in list” or a list of problems, because the file is not there yet. Wan 2.2 14B is the slow one: about 70 GB, up to 10–15 minutes.

The dashboard shows when the app is ready and sends you a notification, so the simplest way is to wait for it. If you want to see for yourself, open Jupyter → File → New → Terminal and run:

tail -n 20 /workspace/comfyui.log            # "To see the GUI go to: http://0.0.0.0:8188" means the interface is up
find /workspace/ComfyUI/models -name "*.part"  # files still downloading end in .part
du -sh /workspace/ComfyUI/models              # compare with the app size in the table above
tail -n 30 /workspace/gf-install.log          # install errors, if ComfyUI never starts

If the log ends with a Python error rather than the “To see the GUI” line, ComfyUI did not start; send the last lines of both logs to support. If the log shows the GUI line but the page still says 502, ComfyUI has only just come up: wait a minute and reload.

Waiting costs money, so it is worth knowing how much. Stage 1 is free: billing starts when the server is ready, so the install and the model download in stages 2 and 3 are billed per minute. A 15-minute wait for Wan 14B on an RTX A6000 costs about €0.18, plus the traffic for 70 GB of models at the machine’s rate.

Start from a built-in workflow template

In ComfyUI open Workflow → Browse Templates. Templates are grouped by task: text to image, image editing, video, upscaling and more. With a ready-made app, the template for that model (Flux schnell, SDXL, Qwen-Image, Wan 2.2 and so on) uses exactly the files we downloaded, so you can press Run as soon as the download finishes.

Other templates may need models you do not have. ComfyUI then shows a dialog listing each missing file and the folder it belongs in. In the browser version, the download button in that dialog saves the file to your computer, not to the server. Copy the link instead and download it on the server, as shown in the next section.

Workflows you save in the left sidebar are stored in /workspace/ComfyUI/user/default/workflows, so they travel with the saved folder.

Add your own checkpoints and LoRAs

Everything lives under /workspace/ComfyUI/models/. The folder decides which node can see the file:

Download straight to the server from the Jupyter terminal. On Hugging Face, copy the resolve link of the file, not the blob link: the blob link is a web page, and wget would save 50 KB of HTML with a .safetensors name.

cd /workspace/ComfyUI/models/loras
wget -O my-style.safetensors "https://huggingface.co/<user>/<repo>/resolve/main/<file>.safetensors"

For whole repos or gated models, the Hugging Face command-line tool is easier:

pip install -U huggingface_hub
hf download <user>/<repo> <file>.safetensors --local-dir /workspace/ComfyUI/models/checkpoints
# gated models (Flux dev and others): accept the licence on the website first, then
export HF_TOKEN=<your read token>

Civitai links usually need your own API token at the end of the URL (?token=...) and a file name, because the download URL has none: wget -O model.safetensors "https://civitai.com/api/download/models/<id>?token=<token>".

Files from your laptop go up through Jupyter’s upload button or with scp, using the host and port from the SSH command in My servers (SSH key guide). For multi-gigabyte files, downloading from the source is usually far faster than uploading from home.

When the file is in place, press R in ComfyUI or reload the page, and it appears in the node’s drop-down. Downloads count as traffic at the machine’s per-GB rate shown before launch.

Custom nodes without a preinstalled ComfyUI Manager

ComfyUI Manager is not installed on our servers. You can add it yourself in a minute, or skip it and install nodes directly. Both are done in the Jupyter terminal.

Install ComfyUI Manager:

cd /workspace/ComfyUI/custom_nodes
git clone https://github.com/Comfy-Org/ComfyUI-Manager comfyui-manager
pip install -r comfyui-manager/requirements.txt

Or install a single node directly:

cd /workspace/ComfyUI/custom_nodes
git clone https://github.com/<author>/<node-repo>
pip install -r <node-repo>/requirements.txt   # if the repo has one

ComfyUI only loads new nodes on start, so restart it:

pkill -f "main.py --listen"
cd /workspace/ComfyUI && nohup python main.py --listen 0.0.0.0 --port 8188 > /workspace/comfyui.log 2>&1 &

Reload the browser tab after about 30 seconds. With the Manager in place you get a Manager button; its Install Missing Custom Nodes is the quickest fix when someone else’s workflow opens with red nodes. Manager has security levels, and because ComfyUI here listens on the network, it may refuse some riskier actions such as installing from an arbitrary Git URL. Installing from its own list works; for anything else, use git clone as above.

Recent ComfyUI releases also include a built-in manager that is switched on with a start flag. If you see manager_requirements.txt in /workspace/ComfyUI, you can run pip install -r manager_requirements.txt and add --enable-manager to the start command instead of cloning.

One warning: a custom node is ordinary Python code with full access to the server, including your models and outputs. Install nodes from repositories you trust, and prefer well-known ones with recent activity.

Keep models, LoRAs and nodes between sessions

The server disk is deleted when the server stops. To keep your work, use Save and stop in My servers. It saves /workspace: your own checkpoints and LoRAs, custom_nodes, saved workflows and the output folder. On the next launch the folder is restored before ComfyUI starts, even on a different card, so your models are in the lists right away. Storage costs €0.03 per GB per month; a 20 GB folder of LoRAs and checkpoints is twenty times that, well under a euro.

Three things to know:

• The base models of a ready-made app are not stored. They download again by themselves on the next launch, so you do not pay storage for 17–70 GB of public weights.
• Python packages are not in /workspace. Custom node folders come back, but the libraries you installed for them with pip do not. After a restore, reinstall them and restart ComfyUI:

for d in /workspace/ComfyUI/custom_nodes/*/; do [ -f "$d/requirements.txt" ] && pip install -r "$d/requirements.txt"; done

• Restoring is a download. The saved folder comes to the new machine as traffic at that machine’s rate. It saves your time and your own files, not traffic.

If you stop without saving, the files are gone. An idle server (2 hours with no SSH, Jupyter or GPU load, then an email, then one more hour) saves the folder before it stops. More on this in what happens to your files when you stop a GPU.

Batch generation through the ComfyUI API

For 200 product shots or a prompt list, you do not have to click Run 200 times. Every ComfyUI accepts jobs over HTTP.

1. Build and test the workflow in the browser.
2. Save it with Workflow → Export (API) and upload workflow_api.json to /workspace.
3. Open the JSON and note the IDs of the nodes you want to change, for example the CLIPTextEncode node with your prompt and the KSampler with the seed.
4. Put one prompt per line in /workspace/prompts.txt and run this on the server:

import json, random, time, urllib.request

URL = "http://127.0.0.1:8188"
PROMPT_NODE, SAMPLER_NODE = "6", "3"   # the IDs from your own export
wf = json.load(open("/workspace/workflow_api.json"))

def call(path, data=None):
    req = urllib.request.Request(URL + path, data=data, headers={"Content-Type": "application/json"})
    return json.load(urllib.request.urlopen(req))

for text in [l.strip() for l in open("/workspace/prompts.txt") if l.strip()]:
    wf[PROMPT_NODE]["inputs"]["text"] = text
    wf[SAMPLER_NODE]["inputs"]["seed"] = random.randint(0, 2**32 - 1)
    pid = call("/prompt", json.dumps({"prompt": wf}).encode())["prompt_id"]
    print("queued", pid, text[:50])

while call("/queue")["queue_running"] or call("/queue")["queue_pending"]:
    time.sleep(10)
print("done, images are in /workspace/ComfyUI/output")

Start it with nohup python batch.py > batch.log 2>&1 & so it keeps running when you close the browser. ComfyUI queues the jobs and works through them one by one; results go to /workspace/ComfyUI/output, which you can zip and download from Jupyter.

A rough budget: with a full queue, Flux schnell (4 steps) renders a 1024×1024 image in roughly 2.5–5 seconds on an RTX 4090, depending on the workflow. Two hundred images at about 4 seconds each is under 15 minutes of work; with the model download and setting up the script, plan on half an hour, about €0.30 of GPU time.

You can also send the same requests from your own computer to the ComfyUI address shown in My servers. To start a server for the batch and stop it afterwards from a script, use the VRAMfarm API: stopping the moment the queue is empty is what keeps a batch job cheap.