How to Upscale AI Images to 4K: 12 Steps, 7 Tools [2026]

Most AI image generators still hand back a file barely big enough for a phone wallpaper. FLUX.2 defaults to 1024×1024 and tops out around 4 megapixels before Black Forest Labs’ own pipeline starts downscaling it back down. Midjourney’s raw output sits near 1 megapixel. Even Stable Diffusion 3.5 was trained at 1024×1024, so anything you try to force out of it above that size tends to come back doubled, warped, or covered in repeating texture artifacts. If you need a poster, a print, a hero banner, or just a photo that survives being viewed on a 4K monitor, you need a second step: upscaling.

This tutorial walks through the full stack, from the free command-line tool that ships on GitHub with 37,000-plus stars to the paid cloud services that charge by the megapixel. By the end you will have a working local upscaling setup, a cloud fallback for when your GPU can’t keep up, and a batch script that turns a folder of raw AI generations into print-ready files without you touching each one by hand. Whether you’re generating with FLUX.2, Midjourney, Nano Banana Pro, or any other model, the upscaling stage is model-agnostic — the same tools and techniques below work on any source image, regardless of which generator produced it.

Why AI-generated images need upscaling in the first place

Diffusion models are trained on a fixed resolution, and that training resolution is what they’re good at reproducing. Push them past it and quality degrades fast: duplicated limbs, tiled patterns, mushy detail. Black Forest Labs’ own documentation for FLUX.2 sets a default generation size of 1024×1024 and a hard ceiling around 4 megapixels (roughly 2048×2048), with anything requested above that getting downscaled back down. Practical FLUX.2 workflows that need true 4K output do a conventional or ESRGAN-family upscale first, then re-run overlapping tiles through the model for detail refinement, rather than asking the base model to generate at full resolution directly.

The same ceiling shows up across the board. Midjourney generates near 1 megapixel by default and applies its own internal upscale to roughly 2048×2048 at the high end. Stable Diffusion 3.x and SDXL are both trained around 1024×1024. None of these numbers are a bug — they’re a byproduct of how diffusion training works, and every serious AI image pipeline in 2026 treats upscaling as its own separate step rather than something the generator should handle natively.

That gap between what the model can generate and what you actually need for a billboard, a product photo, or a print run is exactly what upscalers exist to close. Some use classic GAN-based super-resolution (Real-ESRGAN, the ESRGAN family), which is fast and cheap but limited in how much fine detail it can invent. Others use diffusion-based restoration (SUPIR, Magnific’s Sublime mode), which is slower and pricier but can hallucinate plausible new texture, skin detail, and fabric weave that was never in the low-res source.

How AI upscaling actually works under the hood

It helps to understand what’s actually happening before you pick a tool, because the three main approaches trade off speed against how much new detail they’re willing to invent. The oldest and fastest approach is GAN-based super-resolution, the family Real-ESRGAN and 4x-UltraSharp belong to. A generative adversarial network learns, during training, what high-resolution textures typically look like given a blurry low-resolution input, and at inference time it applies that learned mapping in a single fast pass. It doesn’t “think” about the image the way a diffusion model does — it pattern-matches against textures it has seen before, which is why it’s so fast (often under a couple of seconds even on modest hardware) but also why it can smear detail into a plasticky, over-smoothed look on faces and skin.

The second approach is diffusion-based restoration, which is what powers SUPIR, Magnific’s Sublime mode, and the Creative/Conservative tiers on Stability’s API. Instead of a single forward pass, the model runs an iterative denoising process similar to how it generated the image in the first place, conditioned on the low-resolution input as a guide. This lets it genuinely reconstruct plausible fine detail — individual hair strands, fabric weave, skin pores — that a GAN-based pass would just blur together. The tradeoff is time and compute: instead of 1-2 seconds, you’re looking at 10-60 seconds per image depending on target resolution and hardware, and instead of a fixed one-shot cost you’re often paying per credit or per megapixel.

The third approach, tile-based diffusion upscaling (what Ultimate SD Upscale does inside ComfyUI), is really a workaround for a hardware limitation rather than a distinct architecture. Diffusion models are expensive to run at high resolution directly, so instead of feeding the whole 4096×4096 target through the model at once, the tool slices it into overlapping tiles (say, 512×512 or 768×768 each), runs each tile through the diffusion model independently with a low denoise strength, and stitches the results back together with blending at the seams. It’s a clever way to get diffusion-quality detail at resolutions that would otherwise require far more VRAM than most consumer GPUs have.

Print-ready resolution: how many pixels do you actually need?

Before you pick a scale factor, it’s worth working backward from where the image is actually going to be displayed. Screens and print have very different pixel requirements, and over-upscaling wastes time and money while under-upscaling produces visibly soft output once you crop in or print large.

Output use case	Typical size	Minimum pixel dimensions needed
Social media post (Instagram, X)	Screen only	1080×1080 to 1350×1350
Blog hero image / website banner	Screen only	1920×1080 to 2560×1440
4K desktop wallpaper or monitor display	Screen only	3840×2160
8.5×11″ print at 300 DPI	Standard letter print	2550×3300
16×20″ poster print at 300 DPI	Wall art / poster	4800×6000
24×36″ large-format print at 150 DPI	Billboard / trade show banner	3600×5400

Notice that a standard 300 DPI letter-size print already needs roughly 2550×3300 pixels — well beyond what any generator produces natively, but comfortably within reach of a single 4x Real-ESRGAN pass on a 1024×1024 source (which lands at 4096×4096). A 16×20 poster, by contrast, needs closer to a 6x-8x pass, which is where the diffusion-based tools with higher scale ceilings, like Magnific’s Sublime mode or Leonardo’s Pro Upscaler, actually earn their higher price tag. Large-format print work, ironically, needs less DPI than a letter-size print because viewers stand further back from a billboard than a page in their hands — 150 DPI is a common professional standard for anything viewed from more than a few feet away.

Prerequisites: what you need before you start

You don’t need all of this at once — pick the local or cloud path depending on your hardware — but here’s the full list this tutorial covers:

Python 3.11 or newer (check with python3 --version)
Git, for pulling the Real-ESRGAN repository
An NVIDIA GPU with at least 4GB of VRAM for local GAN-based upscaling (2GB works with tiling enabled but is slow); 8GB or more if you plan to run SUPIR or diffusion-based tile upscaling
ComfyUI (latest release as of September 2026) if you want node-based workflows with the Ultimate SD Upscale extension
A Stability AI Developer Platform account if you’re going the cloud-API route (pay-as-you-go, no local GPU required)
A Recraft, Krea, Magnific, or Topaz account if you prefer a GUI-first paid tool instead of writing code
About 500MB of free disk space per upscaler model you download

If you already generate images with FLUX.2, Nano Banana Pro, or any other model through an API, you can bolt an upscaling step onto the end of that pipeline — see the complete working project near the end of this guide.

Step 1: Decide between local and cloud upscaling

This is the first fork in the road and it determines everything else. Local upscaling with Real-ESRGAN or a ComfyUI node is free after the initial setup, keeps your images off third-party servers, and runs as fast as your GPU allows — but it requires a working Python environment and, for the best diffusion-based results, a GPU with real VRAM headroom. Cloud upscaling through Stability AI, Recraft, Magnific, Topaz, or Krea needs no GPU at all, works from a laptop, and in most cases produces better results on faces and complex textures, but it costs money per image and sends your files to a third party.

A reasonable default for 2026: use local Real-ESRGAN for bulk batch work where speed and cost matter more than perfection, and reach for a cloud diffusion upscaler (Magnific’s Sublime mode, Topaz Photo AI, or Stability’s Creative Upscaler) for the small number of hero images that need to survive being printed at 24 inches wide.

Step 2: Set up your Python environment

Everything local in this tutorial runs inside a virtual environment so it doesn’t collide with other Python projects on your machine.

python3 -m venv upscale-env
source upscale-env/bin/activate   # on Windows: upscale-envScriptsactivate
pip install --upgrade pip
pip install torch torchvision --index-url https://download.pytorch.org/whl/cu121

Swap the cu121 suffix for the CUDA version that matches your driver, or drop it entirely if you’re running CPU-only (expect upscaling to take minutes instead of seconds without a GPU).

Step 3: Install Real-ESRGAN, the free local baseline

Real-ESRGAN is the open-source default 4x upscaler most local tools quietly embed under the hood, including Upscayl and ComfyUI’s model node. The project lives on GitHub. It’s sitting around 37,000 GitHub stars as of September 2026, and while the tagged release hasn’t moved in a while — the project is effectively in maintenance mode — it’s still the fastest, most reliable free option for clean-source photo and anime upscaling.

git clone https://github.com/xinntao/Real-ESRGAN.git
cd Real-ESRGAN
pip install basicsr facexlib gfpgan
pip install -r requirements.txt
python setup.py develop

Download the pretrained weights (the general-purpose x4plus model is the one to start with):

wget https://github.com/xinntao/Real-ESRGAN/releases/download/v0.1.0/RealESRGAN_x4plus.pth -P weights/

Step 4: Run your first local upscale

Point the inference script at any AI-generated image — a FLUX.2 output, a Midjourney download, whatever you have — and it produces a 4x version alongside the original.

python inference_realesrgan.py 
  -n RealESRGAN_x4plus 
  -i inputs/my_flux_render.png 
  -o results/ 
  --outscale 4 
  --tile 400

The --tile flag is the VRAM safety valve. Real-ESRGAN and the wider ESRGAN family typically run in 2-4GB of VRAM when tiling is enabled: a tile size around 200 fits in roughly 4GB, 300 needs around 6GB, and if you have 8GB or more you can raise the tile size or drop the flag entirely for a faster, non-tiled pass. A 1024×1024 source image on a mid-range GPU finishes in a couple of seconds with ESRGAN-family models — this is the fastest tier of upscaler you’ll use in this guide.

Expected output:

Testing 0 my_flux_render
	-> results/my_flux_render_out.png (4096x4096)
Processing complete in 2.1s

Step 5: Set up tile-based diffusion upscaling in ComfyUI

Plain ESRGAN upscaling sharpens and enlarges, but it doesn’t invent new detail — it’s limited by what’s already in the pixels. For results that hold up at print size, the more capable approach in 2026 is tile-based diffusion upscaling inside ComfyUI, using the community Ultimate SD Upscale node. It slices the image into overlapping tiles, runs each tile back through a Stable Diffusion or FLUX pipeline with your original prompt, blends the seams, and reassembles a much higher-resolution image with genuinely new fine detail.

Install ComfyUI (if you haven’t already) and add the node through the ComfyUI Manager:

# From the ComfyUI custom_nodes directory
git clone https://github.com/ssitu/ComfyUI_UltimateSDUpscale.git
# Restart ComfyUI, then install a model in the Upscale Model node dropdown

For the model dropdown, 4x-UltraSharp is the standard pick for crisp, detail-preserving results on illustration and photo work alike — it’s part of the ESRGAN family and ships as a supported option in ComfyUI’s built-in Upscale Model node. Wire it as: load image → Upscale Model (4x-UltraSharp) → Ultimate SD Upscale (with your checkpoint and a low denoise value, around 0.2-0.35, so it refines rather than repaints) → save image.

Step 6: Use the Stability AI cloud API for pay-per-image upscaling

If you don’t want to manage local models, Stability AI’s Developer Platform exposes three upscaler tiers directly as an API, billed in credits. As of September 2026, the published rates are the Fast Upscaler at roughly $0.02 per image, the Conservative Upscaler at around $0.40 per image, and the Creative Upscaler at around $0.60 per image, with the higher tiers capable of pushing output up to roughly 4 megapixels (true 4K territory).

import requests

response = requests.post(
    "https://api.stability.ai/v2beta/stable-image/upscale/fast",
    headers={"authorization": f"Bearer {STABILITY_API_KEY}"},
    files={"image": open("my_flux_render.png", "rb")},
)

if response.status_code == 200:
    with open("upscaled_4k.png", "wb") as f:
        f.write(response.content)
else:
    print(response.json())

Swap /fast for /conservative or /creative depending on how much the model should be allowed to regenerate detail versus faithfully enlarge what’s already there. Conservative sticks close to the source; Creative behaves more like a diffusion repaint and is the better choice for faces, hands, and heavily compressed source images.

Step 7: Try Recraft’s Crisp and Creative Upscale endpoints

Recraft — already a popular choice for vector and icon-style AI generation — ships two distinct upscaling modes through its API. Crisp Upscale increases resolution and sharpness without altering content, and is priced around $0.004 per image, making it one of the cheapest upscaling APIs available in 2026. Creative Upscale regenerates fine detail (skin texture, fabric, anatomy) and costs closer to $0.25 per image.

curl -X POST https://external.api.recraft.ai/v1/images/crispUpscale 
  -H "Authorization: Bearer $RECRAFT_API_KEY" 
  -F image=@my_flux_render.png

For product photography or icon sets where you need clean enlargement without the model second-guessing details, Crisp is the practical default. Save Creative Upscale for portraits and hero images.

Step 8: Compare the GUI-first paid tools

Not every workflow needs to be scripted. Topaz Photo AI 4, Magnific (formerly under the Freepik umbrella), Leonardo AI, and Krea all offer point-and-click upscaling through a browser or desktop app, and each targets a slightly different use case. Topaz leans toward photographers who want denoise, sharpen, and upscale bundled into one desktop pass over real photography as much as AI generations. Magnific leans toward the print and poster crowd, with its Sublime mode specifically built for pushing a single image as far as 16x. Leonardo makes the most sense if you’re already generating inside its ecosystem, since the Universal Upscaler is bundled in at no extra cost. Krea is the best starting point if you just want to try upscaling without committing to a subscription first — its free daily allowance is generous enough to cover casual use indefinitely.

Tool	Entry price	Max scale	Best for
Real-ESRGAN (local)	Free	4x	Bulk batch upscaling, clean source images
Krea AI Enhancer	Free tier (daily credits)	Up to 8x, 4K+	Fast, no-cost cloud upscaling for casual use
Recraft Crisp / Creative	~$0.004 / ~$0.25 per image	Not fixed (resolution-based)	API-driven pipelines, product photos
Stability AI API	$0.02–$0.60 per image	~4 megapixels (4K)	Developers already on the Stability platform
Leonardo AI Universal / Pro Upscaler	Free (Universal) / plans from $12/mo	Up to 8x, ~105 megapixels	Creators already generating inside Leonardo
Topaz Photo AI 4	~$199/year (~$17/mo on annual)	Model-dependent, photo-focused	Photographers who need denoise + sharpen + upscale together
Magnific	$20–$280/month (credit-based)	Up to 16x (Sublime mode)	Print-scale, poster-scale upscales

Krea’s free tier is worth calling out specifically: it lets signed-in users upscale several images a day at no cost, at 2x, 4x, or 8x scale factors, up to roughly 4K resolution — a genuinely useful option if you just need to enlarge a handful of images without setting up anything locally or paying for a subscription.

Step 9: Build a batch upscaling script (the complete working project)

Here’s a complete, working Python project that ties the local and cloud paths together: it walks a folder of AI-generated images, checks each one’s resolution, and routes it to Real-ESRGAN locally if a GPU is available or falls back to the Stability API if not. Save this as batch_upscale.py.

import os
import subprocess
import requests
from pathlib import Path
from PIL import Image

INPUT_DIR = Path("raw_generations")
OUTPUT_DIR = Path("upscaled")
OUTPUT_DIR.mkdir(exist_ok=True)

STABILITY_API_KEY = os.environ.get("STABILITY_API_KEY")
HAS_GPU = subprocess.run(
    ["python3", "-c", "import torch; print(torch.cuda.is_available())"],
    capture_output=True, text=True
).stdout.strip() == "True"

def upscale_local(image_path: Path, out_path: Path):
    subprocess.run([
        "python", "Real-ESRGAN/inference_realesrgan.py",
        "-n", "RealESRGAN_x4plus",
        "-i", str(image_path),
        "-o", str(out_path.parent),
        "--outscale", "4",
        "--tile", "400",
    ], check=True)

def upscale_cloud(image_path: Path, out_path: Path):
    resp = requests.post(
        "https://api.stability.ai/v2beta/stable-image/upscale/conservative",
        headers={"authorization": f"Bearer {STABILITY_API_KEY}"},
        files={"image": open(image_path, "rb")},
    )
    resp.raise_for_status()
    out_path.write_bytes(resp.content)

for img_path in INPUT_DIR.glob("*.png"):
    width, height = Image.open(img_path).size
    out_path = OUTPUT_DIR / f"{img_path.stem}_4k.png"

    if max(width, height) >= 2048:
        print(f"Skipping {img_path.name}: already {width}x{height}")
        continue

    try:
        if HAS_GPU:
            upscale_local(img_path, out_path)
        else:
            upscale_cloud(img_path, out_path)
        print(f"Upscaled {img_path.name} -> {out_path.name}")
    except Exception as e:
        print(f"Failed on {img_path.name}: {e}")

Run it with python batch_upscale.py after dropping raw generations into raw_generations/. It skips anything already above 2048px on its longest edge, so re-running it on a partially processed folder won’t waste API credits or GPU time redoing finished work.

Step 10: Chain upscaling directly onto a FLUX.2 generation pipeline

If you’re already generating with FLUX.2 through its API, the cleanest setup skips the intermediate save-and-reload step entirely and pipes the raw output straight into your upscaler function.

def generate_and_upscale(prompt: str):
    gen_resp = requests.post(
        "https://api.bfl.ai/v1/flux-2-pro",
        headers={"x-key": FLUX_API_KEY},
        json={"prompt": prompt, "width": 1024, "height": 1024},
    )
    result_url = gen_resp.json()["result"]["sample"]

    raw_image = requests.get(result_url).content
    with open("temp_raw.png", "wb") as f:
        f.write(raw_image)

    upscale_cloud(Path("temp_raw.png"), Path("final_4k.png"))
    print("Done: final_4k.png")

This is the pattern worth internalizing: treat generation and upscaling as two separate, swappable stages. You can point the first stage at FLUX.2, Nano Banana Pro, Imagen 4, or anything else with an API, and point the second stage at whichever upscaler fits your budget that week, without rewriting the rest of the pipeline.

Step 11: Quality-check the output before you ship it

Upscalers fail in specific, recognizable ways, and it’s worth a manual pass before a batch goes out the door. Zoom in on faces and hands first — GAN-based upscalers like Real-ESRGAN are prone to smearing fine facial detail into a waxy texture, while diffusion-based options (Creative modes, SUPIR, Magnific’s Sublime) can occasionally invent extra fingers or asymmetrical eyes when pushed too far past the source resolution. Check high-contrast edges for ringing artifacts (a faint halo around sharp boundaries), and check any text or logos in the frame — nearly every upscaler in this guide will mangle small text, since none of them were trained to preserve typography.

Step 12: Automate delivery and cleanup

Once the pipeline is reliable, the last step is making sure it doesn’t silently pile up disk space or leftover API charges. Add a cleanup pass that deletes the raw pre-upscale files after a successful run (or archives them to cold storage if you need to re-run with different settings later), and log the cost per image if you’re using a paid API so a runaway batch doesn’t surprise you on the invoice.

import json
from datetime import datetime

def log_cost(image_name: str, cost_usd: float, log_file="upscale_costs.jsonl"):
    with open(log_file, "a") as f:
        f.write(json.dumps({
            "image": image_name,
            "cost_usd": cost_usd,
            "timestamp": datetime.utcnow().isoformat(),
        }) + "n")

Common pitfalls when upscaling AI-generated images

Upscaling an already-compressed JPEG. Re-saving a generation as JPEG before upscaling bakes compression artifacts into the source, and the upscaler will happily enlarge those artifacts along with everything else. Keep raw generations as PNG until the final export.
Running Creative or diffusion-based upscale modes on images with visible text or logos. These modes regenerate detail rather than faithfully enlarge it, and text is the single most common casualty. Use a Crisp/Conservative mode instead for anything with typography in frame.
Ignoring VRAM limits and letting the process crash mid-batch. Set the tile size before running a large batch, not after your GPU throws an out-of-memory error on image 40 of 200.
Assuming higher scale factor always means better quality. Pushing a 512×512 source to 16x with Magnific’s Sublime mode can produce a technically larger but visually worse image than a modest 4x pass, since the model has to invent more detail than the source actually supports.
Mixing upscaler outputs with inconsistent color profiles. Some cloud upscalers strip or alter embedded ICC color profiles on output. If color accuracy matters (print work especially), check the profile on a test image before running a full batch.
Paying per-megapixel cloud rates for bulk batch work. At scale, cloud API costs add up fast — a 500-image batch at $0.40 each is $200. Route bulk work to free local tooling and reserve paid cloud upscaling for images that actually need the extra quality.

Troubleshooting

“CUDA out of memory” during local upscaling. Lower the --tile value (try 200 instead of 400), close other GPU processes, or fall back to the cloud API for that image.
Output image looks softer than the input after upscaling. You’re likely using a Conservative or Crisp mode on a source that needed a Creative pass instead — low-detail sources need the model to invent texture, not just interpolate pixels.
Faces come out waxy or plastic-looking. Classic Real-ESRGAN symptom. Switch to a face-restoration-aware pipeline (GFPGAN, which Real-ESRGAN’s own setup already installs as a dependency) or use a diffusion-based Creative/Sublime mode instead.
ComfyUI Ultimate SD Upscale produces visible tile seams. Increase the tile overlap/padding setting and lower the denoise strength — seams usually mean the blend region is too small or the model is repainting too aggressively at tile boundaries.
Stability API returns a 402 or billing error. Check your account credit balance on the Developer Platform dashboard; the API fails the request rather than silently downgrading quality.
Batch script skips images that actually need upscaling. The example script in Step 9 skips anything already 2048px or larger on its longest edge — adjust that threshold if your target resolution is higher (e.g. 4096 for true 4K delivery).
Real-ESRGAN install fails on basicsr or facexlib. These packages have historically lagged behind newer versions of torchvision; pin to the versions listed in the repository’s requirements.txt rather than installing the latest release of each.
Upscaled image has a visible color shift compared to the source. Some GAN-based models slightly alter color balance during upscaling. Run a quick histogram match against the original in post if consistency across a batch matters.

Advanced tips: SUPIR, benchmarks, and picking the right tool per job

For the hardest cases — badly compressed, low-resolution, or damaged source images that need 8x enlargement — SUPIR (Scaling Up to Excellence), built on SDXL, is generally regarded as the strongest option in 2026 for extreme restoration-grade upscaling. It’s slower and needs 8GB or more of VRAM, with 30-60 seconds per image at 4K, but it can recover detail that ESRGAN-family models simply can’t invent.

If you want to evaluate upscaler quality objectively rather than eyeballing it, the super-resolution research community has standardized on a handful of benchmark datasets — Set5, Set14, BSD100, Urban100, and Manga109 — scored on PSNR and SSIM. Academic comparisons consistently show Real-ESRGAN outperforming classic ESRGAN on real-world image benchmarks by a meaningful margin, which is part of why it remains the default embedded choice in consumer tools years after its last tagged release.

Upscaler	Type	Approx. VRAM	Speed (1024→4096)
Real-ESRGAN (x4plus)	GAN	~1-4GB with tiling	~2 seconds
4x-UltraSharp (ComfyUI)	ESRGAN-family	~2-4GB with tiling	~2-5 seconds
Ultimate SD Upscale (tile diffusion)	Diffusion	6-8GB+	10-30 seconds
SUPIR	Diffusion (SDXL-based)	8GB+	30-60 seconds

The practical rule: match the tool to the job rather than defaulting to the most powerful (and slowest, most expensive) option every time. Product catalog thumbnails don’t need SUPIR. A single hero image for a print ad does.

Real-world cost examples: local vs cloud at scale

The pricing differences above look small per image, but they compound fast once you’re running production batches. Consider a mid-size e-commerce catalog with 2,000 product photos that need upscaling for a site refresh. Routed entirely through Stability’s Conservative tier at roughly $0.40 an image, that batch costs about $800. Routed through Recraft’s Crisp Upscale at roughly $0.004 an image, the same batch costs about $8 — a 100x difference for a use case (clean product photos, no need to invent new detail) where the cheaper Conservative-style mode is arguably the more appropriate tool anyway. Routed entirely through local Real-ESRGAN on a GPU you already own, the marginal cost drops to essentially zero beyond electricity, with the whole batch finishing in well under an hour on a modern consumer card.

Now flip the scenario to a single hero image for a magazine cover or a large-format print. Here the math runs the other way: paying $0.60 for Stability’s Creative tier, or a few dollars in Magnific credits for a Sublime-mode pass, is trivial next to the cost of a bad print run or a client rejecting a soft, artifact-heavy result. The lesson holds across every tool in this guide — cost per image only matters in the context of volume, and the right default changes depending on whether you’re processing two images or two thousand.

Privacy and data handling when using cloud upscalers

Every cloud-based option in this guide — Stability AI, Recraft, Magnific, Topaz’s cloud rendering mode, Krea — requires uploading your source image to a third-party server for processing. For most casual and commercial creative work that’s a non-issue, but it’s worth pausing on for two categories of images: anything containing a real, identifiable person who hasn’t consented to their photo being processed by a third-party AI service, and anything under an NDA or containing proprietary product designs ahead of a public launch. Read the specific provider’s data retention policy before uploading — some explicitly state images are deleted after processing, others retain them for a fixed window for abuse monitoring or model improvement unless you’re on a business-tier plan with stricter terms. If that’s a dealbreaker for a specific project, local processing with Real-ESRGAN or a self-hosted ComfyUI pipeline keeps every file on hardware you control, at the cost of needing your own GPU.

Local vs cloud: which path should you actually pick?

For a solo creator generating a handful of images a week, Krea’s free tier or Leonardo’s Universal Upscaler covers most needs at zero cost. For a developer building a product that generates images programmatically, Recraft’s Crisp Upscale at roughly $0.004 an image is close to negligible at scale, with Stability’s Fast tier as a comparable alternative. For anyone doing volume batch work with a decent GPU on hand, Real-ESRGAN running locally is effectively free after setup and fast enough to process hundreds of images in an afternoon. Reserve the premium diffusion tools — Magnific’s Sublime mode, Topaz Photo AI, SUPIR — for the images that are actually going to be printed, projected, or scrutinized up close.

Frequently asked questions

What resolution do AI image generators actually output by default?

Most current models default to roughly 1024×1024 (about 1 megapixel). FLUX.2 uses 1024×1024 as its default and caps native generation around 4 megapixels; Midjourney and Stable Diffusion 3.x sit in a similar range. Anything larger typically needs a separate upscaling pass rather than a bigger generation request.

Is Real-ESRGAN still worth using in 2026?

Yes. It’s effectively in maintenance mode with no recent tagged releases, but it remains the default open-source 4x upscaler embedded in tools like Upscayl and ComfyUI, and academic benchmarking still shows it outperforming classic ESRGAN on real-world photo tests. For clean-source images it’s still the fastest free option available.

How much does it cost to upscale images through a cloud API?

Rates vary widely by provider and mode. Recraft’s Crisp Upscale runs around $0.004 per image, Stability AI’s tiers range from about $0.02 to $0.60 per image depending on quality mode, and premium diffusion-based tools like Magnific charge through monthly credit plans starting around $20 a month for tens of thousands of credits.

What’s the difference between Conservative and Creative upscaling modes?

Conservative (or Crisp) modes enlarge and sharpen the image while staying faithful to the existing pixels — good for text, logos, and product photos where accuracy matters. Creative modes behave more like a diffusion repaint, regenerating fine detail like skin texture or fabric weave, which looks better on portraits but can alter details the source never had.

Do I need a powerful GPU to upscale AI images locally?

Not necessarily. Real-ESRGAN and similar ESRGAN-family models can run in as little as 2-4GB of VRAM with tiling enabled, though results and speed improve with more headroom. Diffusion-based options like SUPIR or Ultimate SD Upscale generally want 8GB or more for reasonable performance.

Can I upscale images without any coding at all?

Yes. Krea, Leonardo AI, Magnific, and Topaz Photo AI all offer browser or desktop apps with drag-and-drop upscaling and no scripting required. Krea in particular offers a genuinely free daily allowance for casual use.

Why does upscaled text or logos look garbled?

Nearly every upscaler covered in this guide, free or paid, was trained on general photographic and illustrative content rather than typography. Creative and diffusion-based modes are especially prone to mangling small text since they regenerate detail rather than faithfully enlarging it. Use a Conservative or Crisp mode for any image containing readable text.

How large can I actually scale a single AI-generated image?

It depends on the tool and the quality of the source. Standard options top out around 4x-8x; Magnific’s Sublime mode advertises up to 16x, and Leonardo’s Pro Upscaler can reach roughly 105 megapixels of output. Past a certain point the upscaler is inventing more detail than enlarging existing detail, so quality gains diminish even as the pixel count keeps climbing.

What’s the difference between Real-ESRGAN and SUPIR?

Real-ESRGAN is a GAN-based model: fast, low VRAM, free, and best suited to clean source images that just need clean enlargement. SUPIR is a diffusion-based restoration model built on SDXL: slower, needs 8GB or more of VRAM, and is better suited to damaged, heavily compressed, or very low-resolution sources where the model needs to genuinely reconstruct missing detail rather than just sharpen what’s there.

Should I upscale before or after editing an AI-generated image?

Upscale last, after any color correction, cropping, or compositing is finished. Upscalers amplify whatever is in the source, including any editing artifacts, so a rough crop or a heavy-handed color adjustment made after upscaling can introduce visible seams or banding at the higher resolution that weren’t noticeable at the smaller original size.