Upscale Image By

Upscale Image By is the simplest node in ComfyUI's scaling family, and for most people it's the one they actually want. You feed it an image, tell it "2x", and out comes an image twice as wide and twice as tall. No target resolution to think about, no aspect-ratio arithmetic, no crop option to accidentally flip on. It's the resize node for people who just want the thing bigger.

The family it belongs to

Like its siblings ImageScale, ImageScaleToMaxDimension and ImageScaleToTotalPixels, this node is a pure pixel resampler. It changes how many pixels an image has; it does not add any detail. "Upscaling" in the community actually covers three different jobs - more pixels, more detail, and more pixels over time - and everything in the image/upscaling category handles only the first. That's a feature: it runs in milliseconds, can't hallucinate, and can't rewrite a face. When your source already has the detail you want, this is the right tool, not the cheap one.

How it works

The implementation is about as direct as it gets. It reads the current dimensions, multiplies both by scale_by, rounds, and resamples - always keeping the aspect ratio, with no cropping step at all.

new_w = round(width * scale_by)
new_h = round(height * scale_by)

Note that scale_by applies to both dimensions, so "2x" is 2× on each side - four times the pixels. A 512×512 at 2x becomes 1024×1024, not 1024×512.

The inputs

Three inputs, and only one deserves your attention:

• scale_by - the multiplier, 0.01 to 8, default 1. 2 is the classic hires-fix value, 1.5 the conservative one, and anything below 1 is a downscale, which the node handles fine.
• upscale_method - how the resample happens. lanczos for upscaling, area if you're shrinking, nearest-exact only if you genuinely want pixel-art edges.
• image - the IMAGE tensor in, the same IMAGE tensor out.

The single IMAGE output plugs into a VAE encode, a save node, a ControlNet - anywhere a bigger image is wanted.

When you'd reach for it

Three situations cover most real use. First, the plain "I want a 2x canvas" case: making a preview bigger, or feeding a higher-resolution input to a ControlNet or IPAdapter. Second, as the pixel-side rung of a two-pass workflow, where you upscale, re-encode to latent, and run a low-denoise img2img pass to add the detail the interpolation didn't. Third, and the one people forget: fractional values under 1 make it a clean downscale-by node. Same mechanism, no extra node required.

Where people get burned

The number one complaint is a misunderstanding. Someone runs 2x, sees a soft image, and blames the node. It didn't go wrong - interpolation can't invent detail, and 2x on a 512 image gives you 1024 pixels of the same information. If you want the image to look better rather than just bigger, that's ImageUpscaleWithModel with an ESRGAN checkpoint, or a generative upscaler like SeedVR2. Keep the two jobs separate and most arguments with your own workflow evaporate. Also worth knowing: the 8x cap is per call, and two chained nodes at 4x each are perfectly legal - which is also exactly how people manufacture 16x garbage from a 256px source and blame the tool.