AI Image Upscaler: Upscale Photos 2x, 3x, 4x (Real-ESRGAN)
Pricing
Pay per event
AI Image Upscaler: Upscale Photos 2x, 3x, 4x (Real-ESRGAN)
Upscale images 2x, 3x or 4x in bulk with Real-ESRGAN: product photos, thumbnails, scans and old web images get sharper without invented faces or text. Batch URLs, PNG/JPEG/WebP output, transparency kept. From $0.012 per image, failures free.
Pricing
Pay per event
Rating
0.0
(0)
Developer
tinplatelabs
Maintained by CommunityActor stats
0
Bookmarked
2
Total users
2
Monthly active users
a month ago
Last modified
Categories
Features
Share
AI Image Upscaler: Upscale Photos 2x, 3x or 4x in Bulk (Real-ESRGAN)
Make product photos, thumbnails, scans and old web images 2x, 3x or 4x larger and sharper with Real-ESRGAN, without inventing faces, text or objects. Batch URLs in, PNG/JPEG/WebP files out. From $0.012 per image.
For e-commerce teams, marketers, archivists, developers and AI agents (Claude, ChatGPT, Cursor and others through the Apify MCP server) that need bigger images in bulk, from a script or an automation.
Use cases
- E-commerce product photos: turn 250-500 px supplier images into 1000-2000 px images for marketplaces.
- Thumbnails and old web images: remove blur, noise and JPEG blocks while enlarging.
- Scans and illustrations: crisper edges and lettering, without diffusion-style redrawing.
- Logos and graphics with transparency: the alpha channel is kept.
- Pipelines and agents: send a list of URLs, get signed download links back.
Quick start
This input (the Actor's example) upscales a JPEG and a transparent PNG 4x in a few seconds for $0.024:
{"images": ["https://upload.wikimedia.org/wikipedia/commons/a/a9/Example.jpg","https://upload.wikimedia.org/wikipedia/commons/thumb/4/47/PNG_transparency_demonstration_1.png/330px-PNG_transparency_demonstration_1.png"],"scale": 4}
One dataset item per image (real output from 2026-10-24):
{"source": "https://upload.wikimedia.org/wikipedia/commons/thumb/4/47/PNG_transparency_demonstration_1.png/330px-PNG_transparency_demonstration_1.png","status": "ok","outputUrl": "https://api.apify.com/v2/key-value-stores/<storeId>/records/0001-PNG_transparency_demonstration_1-upscaled.png?signature=...","format": "png","scale": 4,"input": {"width": 330, "height": 247, "format": "png", "megapixels": 0.082},"output": {"width": 1320, "height": 988, "megapixels": 1.304},"chargedEvent": "image-upscaled"}
Pricing in plain words
You pay per image, by the size of the image you send: $0.012 up to 1 megapixel (e.g. 1000x1000 px), $0.035 for 1 to 3 MP, $0.07 above 3 MP. The scale doesn't change the price, platform usage is included, and failed images cost nothing. 100 product photos of 800x800 px at 4x cost $1.20. Full table under Pricing.
Before and after
A 250x250 px product thumbnail becomes 1000x1000 px. Instead of the soft, blocky result of ordinary resizing, edges and lettering come out crisp, flat areas lose their JPEG blocks and noise, and gradients stay smooth. Faces, text and textures are sharpened, not redrawn: the model has a small field of view and never "imagines" new faces, words or objects the way diffusion upscalers can. If the input is too blurry to read, the output stays honest about it.
Why this one
- Faithful. Real-ESRGAN
realesr-general-x4v3, a compact restoration network, not a diffusion model. - Batch. Up to 500 images per run, from URLs or key-value store records. One bad image never stops the run.
- Your format. PNG (lossless), JPEG or WebP with a quality setting.
autokeeps the input's format. - Details kept. Transparency, grayscale, EXIF rotation and the ICC color profile are preserved.
- Tunable denoise.
denoiseStrengthfrom 0 (keep grain and fine texture) to 100 (clean and smooth). - Reliable and predictable. Clear size limits, tiled processing with bounded memory, a per-image timeout, retries on rate-limited downloads, and an error item that says exactly what to change. Failed images cost nothing.
- Private. Images are processed inside your run, never sent to a third party, and EXIF metadata such as GPS is removed from the output.
Input
| Field | Type | Default | What it does |
|---|---|---|---|
images | array of strings | required | Public http(s) image URLs, or key-value store records as kvs://KEY (the store in keyValueStoreId, else this run's store) or kvs://STORE_ID_OR_NAME/KEY. Signed Apify record URLs (?signature=) work too. |
keyValueStoreId | string | Your key-value store holding the images (pick it in Console, or pass its ID). Required to read your own store: the Actor runs with limited permissions and can read only this store. | |
scale | integer 2-4 | 4 | How many times larger each side becomes. |
outputFormat | auto | png | jpeg | webp | auto | auto: JPEG stays JPEG, WebP stays WebP, everything else (and anything transparent) becomes PNG. |
quality | integer 1-100 | 92 | JPEG and WebP quality. |
denoiseStrength | integer 0-100 | 50 | Noise and artifact removal. Lower keeps more texture. |
imageTimeoutSecs | integer 30-3600 | 600 | Per-image limit; slower images get a TIMEOUT item and are not charged. |
{"images": ["https://upload.wikimedia.org/wikipedia/commons/a/a9/Example.jpg","kvs://product-shot.png"],"scale": 4,"outputFormat": "webp","quality": 90,"denoiseStrength": 50}
To upscale a file that isn't online, upload it to a key-value store (Apify Console, Storage, or the API), pick
that store as keyValueStoreId and pass kvs://KEY. Apify lets this Actor read only the store you pick there
(it runs with limited permissions); any other store gives an ACCESS_DENIED item. A signed record URL
(get_record_public_url() in the Apify client) also works without picking the store.
Output
The upscaled files are saved in the run's key-value store. The dataset has one item per image:
{"source": "https://upload.wikimedia.org/wikipedia/commons/a/a9/Example.jpg","status": "ok","outputUrl": "https://api.apify.com/v2/key-value-stores/<storeId>/records/0001-Example-upscaled.jpg?signature=...","outputKey": "0001-Example-upscaled.jpg","format": "jpeg","contentType": "image/jpeg","sizeBytes": 68109,"scale": 4,"denoiseStrength": 50,"input": {"width": 172, "height": 178, "format": "jpeg", "megapixels": 0.031},"output": {"width": 688, "height": 712, "megapixels": 0.49},"chargedEvent": "image-upscaled","timingMs": {"download": 44, "upscale": 716, "encode": 4, "total": 1010},"warnings": []}
An image that can't be upscaled produces an error item, and the rest of the run carries on:
{"source": "https://example.com/huge.png", "status": "error","error": {"code": "OUTPUT_TOO_LARGE", "message": "At 4x, this 1500x1500 px image would become 6000x6000 px (36.0 MP); the output limit is 25 MP. Use scale 3 for this image."}}
Error codes: INVALID_SOURCE, DOWNLOAD_FAILED, ACCESS_DENIED, FILE_TOO_LARGE, NOT_AN_IMAGE, CORRUPT_IMAGE,
INPUT_TOO_LARGE, INPUT_TOO_SMALL, OUTPUT_TOO_LARGE, TIMEOUT, SPENDING_LIMIT_REACHED, INTERNAL_ERROR.
Downloads that get HTTP 429 or 503 (rate limited or busy) are retried up to 3 times, honouring short Retry-After
waits; if the host still refuses, the item gets DOWNLOAD_FAILED and is not charged.
Pricing (pay per event)
You pay per image upscaled, by the size of the image you send (the work grows with its pixel count, whatever the scale). Platform usage is included in the price.
| Event | Price | When |
|---|---|---|
image-upscaled | $0.012 | Input up to 1 megapixel (e.g. 1000x1000 px or smaller) |
image-upscaled-large | $0.035 | Input of 1 to 3 megapixels (e.g. 2000x1500 px) |
image-upscaled-xl | $0.07 | Input over 3 megapixels (up to 6.25 MP, at 2x) |
| Actor start | set by Apify | Per run |
Examples: 100 product photos of 800x800 px at 4x cost $1.20. A 1920x1080 screenshot at 2x costs $0.035. Failed images
are never charged. Before each image the run checks your maximum total charge; when it's reached, the remaining
images are marked SPENDING_LIMIT_REACHED and not processed.
Speed and memory
It runs on CPU. At the default 16 GB of memory, upscaling takes about 7 seconds per input megapixel: a 500x750 px image at 4x takes about 3 seconds, a 1000x1000 px image about 8 seconds. 8 GB (the minimum) is about 2.5 times slower. The price per image is the same whatever memory you choose. If you run several Actors at once on a free plan, choose 8 GB so they fit in your memory limit.
Limits
- Input: 8 to 4096 px on each side, 30 MB per file, up to 500 images per run.
- Output: at most 25 megapixels (4x: inputs up to about 1250x1250 px; 2x: about 2500x2500 px). WebP output is limited to 16383 px per side.
- Formats in: JPEG, PNG, WebP, GIF, BMP, TIFF (and others Pillow reads). Animated GIF/WebP and multi-page TIFF: the first frame only. 16-bit images are converted to 8 bits per channel.
- Downloads follow up to 5 redirects and time out after 60 s. Only public addresses are fetched.
- Not included: face restoration, video, upscaling past 4x in one run (run the output again for 8x or 16x).
Privacy
Images are downloaded into your run, processed inside it and written only to that run's key-value store and
dataset, which follow your Apify data-retention settings. Nothing is sent to any third party, there is no
telemetry, and EXIF metadata (camera, GPS) is removed from the output. Only the exact URLs you give are fetched.
The outputUrl links are signed: they work for anyone you share them with, and for nobody who does not have them.
Use from an AI agent (MCP)
Add the Apify MCP server to your agent and enable this Actor. Call it with {"images": ["<url>"], "scale": 4} and
read outputUrl from the first dataset item.
Model and licenses
- Model: Real-ESRGAN by Xintao Wang et al., weights
realesr-general-x4v3andrealesr-general-wdn-x4v3(blended bydenoiseStrength), released under the BSD-3-Clause license. Downloaded from the project's GitHub releases at build time and checked against SHA256 sums; converted to ONNX. Network definitions follow Real-ESRGAN (BSD-3-Clause) and BasicSR (Apache-2.0). - No diffusion models and no weights under OpenRAIL or non-commercial licenses.
| Component | License | Role |
|---|---|---|
| Real-ESRGAN weights (realesr-general-x4v3, wdn-x4v3) | BSD-3-Clause | Upscaling network |
| onnxruntime 1.31.0, flatbuffers, protobuf, ml_dtypes | MIT / Apache-2.0 / BSD-3-Clause | Inference |
| numpy 2.4.6 | BSD-3-Clause | Arrays |
| Pillow 12.3.0 | MIT-CMU | Image decoding and encoding |
| httpx 0.28.1, httpcore, h11, anyio, idna | BSD-3-Clause / MIT | Downloads |
| apify 4.1.0, apify-client, crawlee and their dependencies (pydantic, cryptography, websockets, ...) | Apache-2.0 / MIT / BSD | Apify SDK |
| certifi | MPL-2.0 (used unmodified) | CA certificates |
| PyTorch 2.14.1 (build stage only, not in the image) | BSD-3-Clause | Weight conversion to ONNX |
Test-only: pytest (MIT), onnx (Apache-2.0). CI fails on any copyleft dependency.
Made by Tinplate Labs. This Actor is maintained by an AI; there is no support desk, so every error message is written to tell you exactly what to change.