🔍 Upsampler Smart Upscale

Upsampler Smart Upscale is a paid remote upscaler wearing a ComfyUI costume. It doesn't download a model, it doesn't touch your GPU, and it doesn't run anything locally: you feed it an image, it uploads that image to a public URL, and a server on the other end regenerates it at higher resolution with new detail. That's the whole pitch: reach for it when the free local upscalers aren't an option.

Where it sits in the upscaling world

There are three jobs that all get called "upscaling": adding pixels (ESRGAN, Lanczos), adding detail that was never in the source (SeedVR2, SUPIR, Magnific), and doing either across video frames. Smart is firmly in the second camp - a generative upscaler, same family as the cloud services people benchmarked against SUPIR back when that was a contest. That classification matters more than the brand name, because generative upscaling is generation: it will happily redraw things, and a face it doesn't know gets rebuilt into a face that fits. Treat this as a polish-and-detail pass, not a structural copy.

People do run it in two passes - higher creativity first to add texture, then lower to pull the result back toward the source. A pattern that predates these nodes by a while.

How it works

The mechanism is unglamorous but worth knowing, because it explains every failure mode you'll hit. The node converts your IMAGE tensor to a PIL image, uploads it to a hoster that gives back a public URL (ImgBB if you've provided an imgbb_api_key, otherwise Catbox.moe, 0x0.st, then PostImages), POSTs that URL to https://upsampler.com/api/v1/smart-upscale with your API key, polls the status endpoint roughly every 60 seconds, and downloads the result back into a tensor. The node blocks while it polls - ComfyUI looks frozen, which is normal; the console shows progress and the credit cost.

Inputs that actually matter

• api_key - your upsampler.com API key, pasted right into the node. Without it, nothing happens.
• input_image_type - realism, anime, or universal. Match it to your source; it's the biggest quality lever you own.
• upscale_factor - 1.0 to 4.0, default 2. The multiplier on output size.
• global_creativity - 0–10, default 5. How strongly the service is allowed to reimagine the image. High values drift; low values stay faithful.
• detail - 0–10, default 5. How hard it pushes detail enhancement.
• description - optional prompt that steers the regeneration; a short one like "highly detailed fabric texture" helps aim it, empty works fine.
• should_enhance_faces - switch on for portraits, remembering that "enhance" means "rebuild toward a plausible face."
• max_parallel_jobs - only matters if you feed it a batch of tiles; leave at 1 for a single image.

The single output, upscaled_image, wires straight into SaveImage or the next node in your chain.

Install and setup

ComfyUI Manager can find it if you search for "ComfyUI Upsampler Nodes." Manual install is the same as always:

cd ComfyUI/custom_nodes
git clone https://github.com/cedarconnor/upsampler comfyui-upsampler
cd comfyui-upsampler
pip install -r requirements.txt

Restart ComfyUI. That's the whole dependency story - just requests and Pillow; no model files, no VRAM requirement, nothing to drop in a models folder. The catch is the prerequisites: a upsampler.com account with credits, an API key, and ideally an ImgBB key too - the free-host fallback works but is flaky, and when all three free services fail the node throws "All free hosting services failed."

Common issues and gotchas

The real cost is 1 credit per megapixel of output (minimum 1 credit), and everything your image touches leaves your machine - hoster, then a third-party server. Don't feed it private images. The API is rate-limited at 90 POSTs per minute and 240 status checks, so cranking max_parallel_jobs on a big batch earns 429s; the node retries those, but slow down. It will not retry "invalid API key" or "insufficient credits" - those fail immediately, so check your account before blaming the node. There's also a 50-megapixel output cap enforced client-side; exceed it and the node refuses, telling you the max factor.

Honest verdict: if you've got a GPU that can run SeedVR2 or a decent ESRGAN model, those are free, offline, and the community default for a reason. Smart is the convenience play - no local model, no VRAM, works from a laptop - and it's a small side-project service, so don't wire a production pipeline into it without reading their terms. For occasional hero renders on a weak machine, it's genuinely handy.