AI Image Upscaler - 2x / 4x Real-ESRGAN from URLs

Upscale images 2x or 4x with Real-ESRGAN neural networks running on CPU, straight from a list of image URLs. Each result is stored in the run's key-value store and comes with a public download link in the dataset. No GPU, no API keys, no model downloads at run time: the networks are bundled in the Actor image.

Pay only for images that were actually upscaled and stored. Failed downloads, undecodable files, oversized inputs and duplicates are never charged. New Apify accounts can try it on the free plan credit.

Who is it for

• E-commerce and marketplace sellers who need larger versions of small supplier or catalogue images.
• Designers, bloggers and agencies refreshing old low-resolution assets (logos, screenshots, illustrations, thumbnails).
• Developers who want an upscale step in a pipeline (Make, n8n, Zapier, your own code) without hosting a model.

What it does and what it does not do

• It runs the open-source Real-ESRGAN family through realesrgan-ncnn-py (ncnn inference engine, CPU mode, gpuid=-1).
• It does not restore faces. There is no face-enhancement option, and none is claimed.
• It cannot add information that is not in the picture. Neural upscaling invents plausible detail; it can look sharper than a normal resize but may hallucinate textures or distort small text. Do not use it for evidence, medical or forensic images, or anywhere exact pixels matter.
• It is built for small and medium inputs. See "Limits" for the exact caps per model.

Input

Field	Type	Default	Description
imageUrls	array of strings	required	Direct http(s) image URLs (JPEG, PNG, WebP, GIF, BMP, TIFF; max 30 MB each). Web pages are not crawled.
scale	2 or 4	4	Width and height multiplier.
model	general, anime-hq, photo-hq	general	See the model table below.
denoise	string "0".."1"	"0"	Optional non-local-means noise filter applied before upscaling (a pre-filter, not a model-based denoise).
outputFormat	png, jpg, webp	png	JPG has no transparency (transparent areas become white).
quality	40-100	92	JPG/WebP quality.
maxInputPixels	1,000 - 2,000,000	1,000,000	Inputs with more pixels (width x height) are rejected before any charge.
maxImages	1-500	100	Only the first N URLs are processed.
includeFailed	boolean	false	Add free status: "failed" rows for images that failed (never charged).

Models

model	Network	Speed (measured, 1 CPU core)	Max input	Best for
general	Real-ESRGAN realesr-animevideov3 (compact, native 2x and 4x)	about 8 s for 512x512 -> 2048x2048	2 MP	Everything, default
anime-hq	Real-ESRGAN x4plus-anime	about 23 s for 256x256 -> 1024x1024	0.1 MP (about 316x316)	Line art, flat colors
photo-hq	Real-ESRGAN x4plus	about 45 s for 256x256 -> 1024x1024	0.04 MP (about 200x200)	Small photos, avatars

For 2x with the HQ models the network runs at 4x and the result is scaled down with Lanczos, so it takes as long as 4x. The general model was trained mostly on anime video frames but is a general-purpose compact network; the HQ photo model gives better texture on real photos but is much slower, which is why its input cap is small.

Output

One dataset row per upscaled image. The image itself is in the default key-value store; upscaleUrl is a public link to it.

{
  "id": "cd6d73be58717af8",
  "originalUrl": "https://example.com/images/product-small.jpg",
  "inputWidth": 640,
  "inputHeight": 480,
  "inputFormat": "JPEG",
  "inputBytes": 48211,
  "outputWidth": 2560,
  "outputHeight": 1920,
  "outputFormat": "png",
  "outputBytes": 5912044,
  "scale": 4,
  "model": "general",
  "engineModel": "realesr-animevideov3",
  "denoise": 0.0,
  "upscaleUrl": "https://api.apify.com/v2/key-value-stores/<storeId>/records/upscaled-cd6d73be58717af8-x4-general.png",
  "recordKey": "upscaled-cd6d73be58717af8-x4-general.png",
  "seconds": 9.4,
  "chargedEvents": 1,
  "note": null,
  "processedAt": "2026-10-14T10:43:41.062Z",
  "attribution": "Upscaled with Real-ESRGAN (BSD-3-Clause) via realesrgan-ncnn-py (MIT), CPU inference"
}

The run also writes an OUTPUT record (counts, charged events, every skipped URL with its reason, stop reason) and a short RESULTS_MD summary to the key-value store.

Pricing

Pay-per-event, pay only for images that were upscaled and stored:

Event	Price	When
image	$0.02	One image upscaled and stored, output up to 2048x2048 pixels (about 4.19 MP). Larger output counts as 2 events.

Not charged: failed downloads, HTTP errors, files that are not images, images over the input pixel limit, duplicate image content within a run, rows added by includeFailed, and anything beyond your maximum cost per run (the run stops softly and OUTPUT.stoppedReason is budget). Apify may apply Bronze/Silver/Gold plan discounts to the price.

A 4x upscale of a 1 MP image gives 16 MP output and therefore costs 2 events ($0.04).

How it works

1. URLs are validated, de-duplicated and capped to maxImages.
2. Each image is downloaded with a timeout, retries on 429/5xx and a 30 MB size cap. URLs that resolve to private network addresses are blocked.
3. The image is decoded (EXIF orientation applied, first frame only for animations). Alpha channels are kept: the colors go through the network, the alpha channel is resized with Lanczos.
4. The network processes the image in tiles to keep memory low (typically 300-800 MB peak).
5. The result is encoded, stored in the key-value store, and only then charged. If the budget is not enough, the stored file is deleted and nothing is pushed.
6. Progress is saved after every image. If the run migrates or restarts, finished images are not processed or charged again.

Limits and honest caveats

• CPU only: expect seconds for small images and a minute or more for the HQ models. Use general for anything bigger than a thumbnail.
• Maximum input 2 MP (2,000,000 pixels) for general, less for the HQ models. Larger images are rejected, not downscaled, so you stay in control.
• Output of a 2 MP image at 4x is 32 MP; large PNGs can be tens of MB. Use jpg or webp to keep files small. Very large records may hit key-value store record size limits.
• Images behind logins, signed URLs that expire, or hosts that block data-center IPs cannot be fetched.
• No face restoration, no inpainting, no colorization, no background removal.
• Results are subjective. Always look at a sample before processing thousands of images.

Legal and ethical notes

• You are responsible for having the right to copy and modify the images you submit. Upscaling does not change copyright.
• Image URLs and files are fetched and stored only to produce the result; stored files live in your own Apify key-value store, subject to its retention settings.
• Images containing personal data (for example people's faces) are subject to GDPR and similar laws; make sure you have a lawful basis.
• Models: Real-ESRGAN (BSD-3-Clause) by Xintao Wang et al.; ncnn inference wrapper realesrgan-ncnn-py (MIT). The model weights are bundled in the package.

FAQ

Is this real AI upscaling or just a resize? Real neural-network upscaling (Real-ESRGAN, CPU). The output differs from a plain Lanczos resize; it adds plausible detail rather than just interpolating.

Why is my photo rejected as too large? The general model accepts up to 2,000,000 pixels (about 1414x1414). Downscale first or crop; larger images would be slow and costly on CPU.

Why does a 1000x1000 image at 4x cost 2 events? The output is 4000x4000 = 16 MP, above the 2048x2048 threshold of a single event.

Can it enhance faces? No, face enhancement is not supported.

How do I keep files small? Choose jpg or webp and set quality to 80-90.

Does it keep transparency? Yes for PNG and WebP. JPG cannot, transparent areas become white.

What happens if the run is interrupted or my budget runs out? Progress is saved after every image; a restarted run skips finished images and never charges them twice. When the maximum cost per run is reached, the run stops cleanly and lists the remaining images as not processed.

Does denoise use AI? No. It is a classical non-local-means filter applied before upscaling. Use small values; large values smear detail.

Use via API

Replace username~image-upscaler with this Actor's ID and YOUR_TOKEN with your Apify API token.

curl -X POST "https://api.apify.com/v2/acts/username~image-upscaler/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"imageUrls":["https://example.com/a.jpg"],"scale":4,"outputFormat":"webp"}'

import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: 'YOUR_TOKEN' });
const run = await client.actor('username~image-upscaler').call({
    imageUrls: ['https://example.com/a.jpg'],
    scale: 4,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items[0].upscaleUrl);

from apify_client import ApifyClient

client = ApifyClient("YOUR_TOKEN")
run = client.actor("username~image-upscaler").call(run_input={
    "imageUrls": ["https://example.com/a.jpg"],
    "scale": 4,
})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["upscaleUrl"])

Integrations

Use the Apify integrations for Make, n8n, Zapier and Google Sheets: trigger the Actor with a list of image URLs, then read upscaleUrl from the dataset to download the result or write it to a sheet or CMS. Webhooks can notify you when a run finishes.

Support

Open an issue from the Actor page with the run link and the failing URL. Please do not send images you do not have rights to.