# AI Image Upscaler - Real-ESRGAN 2x and 4x Photo Enhancer (`parseforge/ai-image-upscaler-scraper`) Actor

Upscale images 2x or 4x with Real-ESRGAN AI. Paste image URLs, get sharper PNG, JPEG or WebP files with public links. Export to CSV, Excel, JSON or XML.

- **URL**: https://apify.com/parseforge/ai-image-upscaler-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** AI, Developer tools
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $10.20 / 1,000 result items

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

![ParseForge Banner](https://github.com/ParseForge/apify-assets/blob/ad35ccc13ddd068b9d6cba33f323962e39aed5b2/banner.jpg?raw=true)

## 🔍 AI Image Upscaler Scraper

> 🚀 **Export sharper, bigger images in seconds.** Paste image links, get 2x or 4x Real-ESRGAN upscales with public download links: a 500x500 photo becomes 2000x2000 in about 3.5 seconds.

The AI Image Upscaler takes public image URLs, enlarges each image 2x or 4x with the Real-ESRGAN general model, and saves the result in the run's key-value store with a public link. Every row also reports the source and output dimensions, formats, file sizes and the processing time, so you can audit a whole batch from the dataset.

Measured on the Apify platform: a 500x500 JPEG turns into a 2000x2000 PNG in 3.5 s, and a 1-megapixel photo into a 4096x4096 (16.8 MP) PNG in 19.4 s. Each row carries 19 fields. Up to 500 images per run, transparency is kept, and URLs that are not images are skipped without a charge.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| E-commerce teams, marketers, designers, print shops, archivists, developers and AI agents | Product photo enlargement, print-ready scans, thumbnail rescue, restoring old or compressed photos, batch pipelines in Make, Zapier or n8n |

### 📋 What the AI Image Upscaler Scraper does

- 🔍 **Upscales 2x or 4x** with Real-ESRGAN (general x4v3), a model trained to rebuild edges and texture and to clean JPEG artifacts, not just stretch pixels.
- 🔗 **Returns public links** to every upscaled file, ready to download, embed or pass to the next step of a workflow.
- 🗂 **PNG, JPEG or WebP output**, with adjustable quality for JPEG and WebP.
- 🫥 **Keeps transparency** in PNG and WebP: the alpha channel is enlarged and re-attached.
- 📏 **Reports the numbers**: source and output width, height, format and bytes, megapixels and seconds per image.
- 🛡 **Fails safely**: web pages, PDFs, videos, broken links and private-network addresses become error rows that are never billed.

> 💡 **Why it matters:** upscaling services usually mean a subscription, credits that expire or a desktop app. Here you send a list of links through the API and get files back in one dataset you can export to CSV, Excel, JSON or XML.

### 🎬 Full Demo

🚧 Coming soon

### 📊 Output

| Field | Description |
|---|---|
| 🖼 `imageUrl` | Public link to the upscaled file |
| 🔗 `sourceUrl` | The image URL you provided |
| 📄 `fileName` | Key of the file in the run's key-value store |
| 🔍 `scale` | Upscale factor applied (2 or 4) |
| ↔️ `outputWidth` / ↕️ `outputHeight` | Size of the result in pixels |
| 🧮 `outputMegapixels` | Result size in megapixels |
| 🗂 `outputFormat` | png, jpeg or webp |
| 💾 `outputSizeBytes` | Size of the result file |
| ↔️ `inputWidth` / ↕️ `inputHeight` | Size of the source image (after EXIF rotation) |
| 🗂 `inputFormat` | Detected source format |
| 💾 `inputSizeBytes` | Size of the downloaded source file |
| 📉 `inputDownscaled` | Yes when a source above 1 MP was shrunk to 1 MP first |
| 🫥 `hasTransparency` | Yes when the source had transparent pixels |
| 🧠 `model` | Upscaling model used |
| ⏱ `processingTimeSec` | Seconds spent upscaling and encoding |
| 🕒 `scrapedAt` | When the image was processed |
| ❌ `error` | Why an image was skipped (null on success) |

Three real rows from a platform run:

```json
{
  "imageUrl": "https://api.apify.com/v2/key-value-stores/iyepbKMNwSfLERsSc/records/upscaled-001-mugbe3ws.png?signature=1cLe2ToKfJlpe2rXkwrNF",
  "sourceUrl": "https://upload.wikimedia.org/wikipedia/commons/thumb/9/97/The_Earth_seen_from_Apollo_17.jpg/500px-The_Earth_seen_from_Apollo_17.jpg",
  "fileName": "upscaled-001-mugbe3ws.png",
  "scale": 4,
  "outputWidth": 2000,
  "outputHeight": 2000,
  "outputMegapixels": 4,
  "outputFormat": "png",
  "outputSizeBytes": 6175073,
  "inputWidth": 500,
  "inputHeight": 500,
  "inputFormat": "jpeg",
  "inputSizeBytes": 82862,
  "inputDownscaled": "No",
  "hasTransparency": "No",
  "model": "Real-ESRGAN general x4v3",
  "processingTimeSec": 3.5,
  "scrapedAt": "2026-09-25T02:01:13.373Z",
  "error": null
}
```

```json
{
  "imageUrl": "https://api.apify.com/v2/key-value-stores/iyepbKMNwSfLERsSc/records/upscaled-003-mugbemji.png?signature=1SJ8wo5No24v7QRqqRjki",
  "sourceUrl": "https://upload.wikimedia.org/wikipedia/commons/thumb/9/97/The_Earth_seen_from_Apollo_17.jpg/1280px-The_Earth_seen_from_Apollo_17.jpg",
  "fileName": "upscaled-003-mugbemji.png",
  "scale": 4,
  "outputWidth": 4092,
  "outputHeight": 4096,
  "outputMegapixels": 16.76,
  "outputFormat": "png",
  "outputSizeBytes": 24554250,
  "inputWidth": 1280,
  "inputHeight": 1281,
  "inputFormat": "jpeg",
  "inputSizeBytes": 431044,
  "inputDownscaled": "Yes",
  "hasTransparency": "No",
  "model": "Real-ESRGAN general x4v3",
  "processingTimeSec": 19.4,
  "scrapedAt": "2026-09-25T02:01:38.032Z",
  "error": null
}
```

```json
{
  "imageUrl": "https://api.apify.com/v2/key-value-stores/iyepbKMNwSfLERsSc/records/upscaled-005-mugbf5sn.png?signature=N3CIfu5fOS2H1ICiBNwN",
  "sourceUrl": "https://upload.wikimedia.org/wikipedia/commons/thumb/2/27/Apollo_11_insignia.png/330px-Apollo_11_insignia.png",
  "fileName": "upscaled-005-mugbf5sn.png",
  "scale": 4,
  "outputWidth": 1320,
  "outputHeight": 1332,
  "outputMegapixels": 1.76,
  "outputFormat": "png",
  "outputSizeBytes": 2275587,
  "inputWidth": 330,
  "inputHeight": 333,
  "inputFormat": "png",
  "inputSizeBytes": 140339,
  "inputDownscaled": "No",
  "hasTransparency": "Yes",
  "model": "Real-ESRGAN general x4v3",
  "processingTimeSec": 2.1,
  "scrapedAt": "2026-09-25T02:02:02.277Z",
  "error": null
}
```

### ✨ Why choose this Actor

- ⚡ **Fast on ordinary images**: 2 to 4 seconds for a typical web image, about 20 seconds for a full 1-megapixel photo at 4x.
- 📦 **Batches, not one file at a time**: send up to 500 links in a single run and get one dataset back.
- 🔢 **Real output sizes**: 4x means 4x. A 1 MP photo comes back at about 16 MP, far beyond the 1-2 MP targets of diffusion upscalers.
- 🧾 **Transparent about every file**: dimensions, bytes and timing per row, so you can check a batch without opening each image.
- 🔒 **No external AI service**: images are processed inside the run and stored in your own Apify storage.
- 🆓 **Failed images are free**: only successfully stored results count.

### 📈 How it compares to alternatives

| | This Actor | Desktop upscalers | Subscription web tools |
|---|---|---|---|
| Batch of links in one call | ✅ Up to 500 per run | ❌ Manual file picking | ⚠️ Usually a few at a time |
| API, Make, Zapier, n8n | ✅ Native | ❌ | ⚠️ Paid tiers only |
| Output size | 2x or 4x of the source (source capped at 1 MP) | Up to 6x | Often capped by plan |
| Transparency kept | ✅ PNG and WebP | ✅ | ⚠️ Varies |
| Per-image metadata | ✅ 19 fields | ❌ | ❌ |
| Face-specific restoration | ❌ Not included | ✅ Some | ✅ Some |

Honest ceiling: sources larger than 1 megapixel are shrunk to 1 megapixel before the 4x model runs (the row says so in `inputDownscaled`), so the largest output is about 16 megapixels. There is no dedicated face restoration model.

### 🚀 How to use

1. Create a free Apify account with $5 in monthly credit: [sign up here](https://console.apify.com/sign-up?fpr=vmoqkp).
2. Open the AI Image Upscaler and paste your image links into **Image URLs** (one per line, or upload a text file of links).
3. Pick **4x** or **2x** and the file format (PNG, JPEG or WebP).
4. Click **Start**. Each image takes a few seconds.
5. Open the **Output** tab: click any `imageUrl` to download the file, or export the dataset to CSV, Excel, JSON or XML.

Example run settings:

```
{ "imageUrls": [{ "url": "https://upload.wikimedia.org/wikipedia/commons/thumb/9/97/The_Earth_seen_from_Apollo_17.jpg/330px-The_Earth_seen_from_Apollo_17.jpg" }], "scale": "4", "outputFormat": "png" }
```

### 💼 Business use cases

#### 🛒 E-commerce and marketplaces

Enlarge supplier product shots that arrive at 400 or 500 pixels so they pass marketplace minimum-size rules and zoom cleanly on product pages.

#### 📣 Marketing and social media

Turn small logos, screenshots and archive photos into banner-ready assets without hunting for the original files.

#### 🖨 Print and publishing

Push web-resolution photos toward print sizes: a 500 px image at 4x reaches 2000 px, enough for a small print at 300 dpi.

#### 🗄 Archives and real estate

Batch-upscale scanned photos or low-resolution listing images, keeping a dataset that records exactly what was processed and when.

### 🔌 Automating AI Image Upscaler Scraper

- **Make and Zapier**: trigger a run when a new image lands in a folder or a spreadsheet row, then send the `imageUrl` onward.
- **n8n**: call the Actor from an HTTP node and loop over the dataset rows.
- **Slack**: post the finished links to a channel with the Apify Slack integration.
- **Google Drive**: copy the upscaled files into a shared folder after each run.
- **GitHub Actions**: upscale documentation screenshots as part of a build.
- **Airbyte**: sync the run metadata into your warehouse for reporting.

### 🌟 Beyond business use cases

- **Research**: prepare enlarged figures and satellite images for papers and slides.
- **Personal**: give old family photos a second life before printing them.
- **Non-profit**: restore small archive images for exhibitions and websites.
- **Experimentation**: compare 2x and 4x results or feed upscaled frames into other AI tools.

### 🤖 Ask an AI assistant about this scraper

Copy this Actor's URL into ChatGPT, Claude or Perplexity and ask how to connect it to your workflow, which scale to use for a print size, or how to loop over the dataset in your language of choice.

### ❓ Frequently Asked Questions

#### 🖼 Which image formats can I send?

JPEG, PNG, WebP, GIF (first frame), TIFF and AVIF, up to 25 MB per file. iPhone HEIC/HEIF photos are not supported; convert them to JPEG first.

#### 🔗 What kind of link works?

A link that downloads the image file itself. A web page that merely shows the image (a gallery page, a Google Drive share page) is rejected with an error row.

#### 🔍 What is the difference between 2x and 4x?

4x multiplies width and height by four (16 times the pixels). 2x is the 4x result resized down to twice the original size, which keeps the restored detail and gives smaller files.

#### 📏 Is there a size limit?

Sources above 1 megapixel are shrunk to 1 megapixel first, so a 4x result is at most about 16 megapixels. Files above 25 MB or 50 megapixels are refused.

#### ⏱ How long does it take?

About 3.5 seconds for a 500x500 image and about 20 seconds for a 1 megapixel photo at 4x, measured on the platform with default settings.

#### 🫥 Is transparency preserved?

Yes, in PNG and WebP output. JPEG has no transparency, so transparent areas turn white.

#### 🙂 Does it restore faces?

Faces are upscaled like the rest of the picture. There is no separate face restoration model.

#### 💸 Am I charged for images that fail?

No. Broken links, non-image files and refused URLs produce an error row that is never billed.

#### 🔒 Where are my images stored?

In the run's own key-value store in your Apify account. The public links carry a signature and follow your account's storage retention.

#### 📦 How many images can one run handle?

Up to 500 images per run. Split larger batches into several runs, which can also run in parallel.

#### 🧠 Which model is used?

Real-ESRGAN general x4v3, an open model released under the BSD-3-Clause licence, running inside the Actor.

Credit: the upscaling model is [Real-ESRGAN](https://github.com/xinntao/Real-ESRGAN) `realesr-general-x4v3`, Copyright (c) 2021 Xintao Wang et al., used under the BSD-3-Clause licence. The full licence text ships with the model inside the Actor (`models/LICENSE-Real-ESRGAN`).

#### 🏷 Can I use the results commercially?

The model licence allows commercial use. Rights to the pictures themselves stay with whoever owns the original images.

### 🔌 Integrate with any app

Use the [Apify API](https://docs.apify.com/api/v2), the JavaScript or Python client, webhooks, or ready-made integrations for Make, Zapier, n8n, Slack, Google Drive, Airbyte and more. Every run produces a dataset and a key-value store you can read from any tool.

### 🔗 Recommended Actors

- [Google Lens Scraper](https://apify.com/parseforge/google-lens-scraper): find where an image appears online.
- [Public Domain Vectors Scraper](https://apify.com/parseforge/public-domain-vectors-scraper): collect free CC0 clipart and vectors.
- [Freepik Coloring Pages Scraper](https://apify.com/parseforge/freepik-coloring-pages-scraper): gather printable coloring pages.
- [Civitai Models Scraper](https://apify.com/parseforge/civitai-models-scraper): track AI image models and creators.

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge) for more data tools.

**🆘 Need Help?** [Open our contact form](https://tally.so/r/BzdKgA)

> **⚠️ Disclaimer:** this is an independent tool, not affiliated with the Real-ESRGAN authors or any image host. It only processes publicly available data at the links you provide; make sure you have the right to use and modify those images.

# Actor input Schema

## `imageUrls` (type: `array`):

Public links to the images you want to upscale (JPEG, PNG, WebP, GIF, TIFF or AVIF, up to 25 MB each; HEIC/HEIF photos are not supported). The link must download the image file itself, not a web page that shows it. Sources larger than 1 megapixel are shrunk to 1 megapixel before the 4x network runs, so the longest output edge stays near 4,096 px. You can also upload a text file with one URL per line.

## `maxItems` (type: `integer`):

Maximum number of images to upscale in this run. Free users: Limited to 10 items (preview). Paid users: Optional, up to 500 images per run (split bigger batches into several runs).

## `scale` (type: `string`):

4x makes a 500x500 image 2000x2000. 2x makes it 1000x1000 (the 4x result resized down, which keeps the restored detail).

## `outputFormat` (type: `string`):

PNG is lossless and keeps transparency. JPEG is the smallest file (transparent areas become white). WebP keeps transparency at a fraction of the PNG size.

## `outputQuality` (type: `integer`):

Compression quality for JPEG and WebP output, from 50 to 100. Ignored for PNG.

## Actor input object example

```json
{
  "imageUrls": [
    {
      "url": "https://upload.wikimedia.org/wikipedia/commons/thumb/9/97/The_Earth_seen_from_Apollo_17.jpg/330px-The_Earth_seen_from_Apollo_17.jpg"
    },
    {
      "url": "https://upload.wikimedia.org/wikipedia/commons/thumb/9/98/Aldrin_Apollo_11_original.jpg/330px-Aldrin_Apollo_11_original.jpg"
    },
    {
      "url": "https://upload.wikimedia.org/wikipedia/commons/thumb/2/27/Apollo_11_insignia.png/330px-Apollo_11_insignia.png"
    }
  ],
  "maxItems": 10,
  "scale": "4",
  "outputFormat": "png",
  "outputQuality": 92
}
```

# Actor output Schema

## `overview` (type: `string`):

Upscaled image links with dimensions and timing

## `fullData` (type: `string`):

Complete dataset with all 19 fields

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "imageUrls": [
        {
            "url": "https://upload.wikimedia.org/wikipedia/commons/thumb/9/97/The_Earth_seen_from_Apollo_17.jpg/330px-The_Earth_seen_from_Apollo_17.jpg"
        },
        {
            "url": "https://upload.wikimedia.org/wikipedia/commons/thumb/9/98/Aldrin_Apollo_11_original.jpg/330px-Aldrin_Apollo_11_original.jpg"
        },
        {
            "url": "https://upload.wikimedia.org/wikipedia/commons/thumb/2/27/Apollo_11_insignia.png/330px-Apollo_11_insignia.png"
        }
    ],
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/ai-image-upscaler-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "imageUrls": [
        { "url": "https://upload.wikimedia.org/wikipedia/commons/thumb/9/97/The_Earth_seen_from_Apollo_17.jpg/330px-The_Earth_seen_from_Apollo_17.jpg" },
        { "url": "https://upload.wikimedia.org/wikipedia/commons/thumb/9/98/Aldrin_Apollo_11_original.jpg/330px-Aldrin_Apollo_11_original.jpg" },
        { "url": "https://upload.wikimedia.org/wikipedia/commons/thumb/2/27/Apollo_11_insignia.png/330px-Apollo_11_insignia.png" },
    ],
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/ai-image-upscaler-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "imageUrls": [
    {
      "url": "https://upload.wikimedia.org/wikipedia/commons/thumb/9/97/The_Earth_seen_from_Apollo_17.jpg/330px-The_Earth_seen_from_Apollo_17.jpg"
    },
    {
      "url": "https://upload.wikimedia.org/wikipedia/commons/thumb/9/98/Aldrin_Apollo_11_original.jpg/330px-Aldrin_Apollo_11_original.jpg"
    },
    {
      "url": "https://upload.wikimedia.org/wikipedia/commons/thumb/2/27/Apollo_11_insignia.png/330px-Apollo_11_insignia.png"
    }
  ],
  "maxItems": 10
}' |
apify call parseforge/ai-image-upscaler-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,parseforge/ai-image-upscaler-scraper"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/wKbBDf222aZ6hcnmw/builds/UvAEDB3QlfzL0Uuyj/openapi.json