# AI Image Upscaler: Bulk Upscale Images to 4K (2x, 3x, 4x) (`clearpull/image-upscaler`) Actor

Upscale images 2x, 3x or 4x with Real-ESRGAN AI, in bulk: up to 1,000 image links a run. Sharpen low-res product photos, thumbnails, old web images and anime art, and remove JPEG noise. Full HD becomes 4K at 2x. PNG, JPEG or WebP, transparency kept. Pay per image; failed images are free.

- **URL**: https://apify.com/clearpull/image-upscaler.md
- **Developed by:** [Clearpull](https://apify.com/clearpull) (community)
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $8.00 / 1,000 image upscaleds

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

## AI Image Upscaler: Bulk Upscale Images to 4K (2x, 3x, 4x)

Upscale photos and illustrations 2x, 3x or 4x with Real-ESRGAN, an open-source AI upscaler. Give it a list of image links and get back sharper, larger images: low-resolution product photos, old web images, thumbnails, screenshots, anime and line art. It also cleans up JPEG blocks and noise.

You pay per image, with no subscription, no GPU and no API key to set up. Failed images are never charged.

### What you get

- **2x, 3x or 4x upscaling.** A 500 x 500 image becomes 2000 x 2000 at 4x.
- **Two models.** *Photo* (realesr-general-x4v3) for photographs, product shots and screenshots. *Illustration* (realesr-animevideov3) for anime, cartoons, drawings and line art, about twice as fast.
- **PNG, JPEG or WebP output.** Transparency is kept in PNG and WebP.
- **Bulk runs.** Up to 1,000 image links per run, processed one after another while the next image downloads.
- **Clean files.** EXIF, GPS and camera metadata are never copied to the output. Rotation from the camera is applied first, so the result is the right way up.
- **A results table** with a link to each upscaled file, its size, and a clear error for any image that failed.

### How to use it

1. Paste direct image links into **Image URLs**, one per line. A direct link ends in the image itself: right-click an image in your browser and choose "Copy image address".
2. Pick the **Scale**, the **Image type** and the **Output format**.
3. Start the run. Each upscaled file appears in the run's key-value store, and the **Results** table links to it.

To call it from code, use the Apify API or the `apify-client` package for JavaScript or Python, with the same input:

```json
{
  "imageUrls": [
    "https://upload.wikimedia.org/wikipedia/commons/a/a9/Example.jpg"
  ],
  "scale": "4",
  "imageType": "photo",
  "outputFormat": "png"
}
```

### Output example

One row per image in the dataset:

```json
{
  "type": "upscaledImage",
  "imageUrl": "https://upload.wikimedia.org/wikipedia/commons/thumb/a/a8/NASA-Apollo8-Dec24-Earthrise.jpg/500px-NASA-Apollo8-Dec24-Earthrise.jpg",
  "scale": 4,
  "imageType": "photo",
  "outputFormat": "jpeg",
  "status": "upscaled",
  "outputUrl": "https://api.apify.com/v2/key-value-stores/<store id>/records/upscaled-0002.jpg",
  "outputKey": "upscaled-0002.jpg",
  "inputWidth": 500,
  "inputHeight": 500,
  "inputFormat": "jpeg",
  "outputWidth": 2000,
  "outputHeight": 2000,
  "outputBytes": 175389,
  "hasTransparency": false,
  "pricingTier": "standard",
  "processingSeconds": 6.2,
  "upscaledAt": "2026-11-13T07:37:07.158Z"
}
```

An image that couldn't be processed gets `"status": "failed"` and an `error` explaining why, such as a link that opens a web page instead of an image.

### Pricing

You pay per upscaled image, by the size of the image you send in. The scale, image type and output format don't change the price.

| Input image size | Example sizes | Price per image |
|---|---|---|
| Up to 0.5 megapixels | 800 x 600, 700 x 700, 512 x 512 | $0.012 |
| Up to 1.1 megapixels | 1024 x 1024, 1280 x 720 | $0.03 |
| Up to 2.25 megapixels | 1920 x 1080, 1500 x 1500 | $0.06 |

Higher Apify plans pay less per image. For example, 1,000 product photos of 600 x 600 cost $12, and 100 HD frames (1920 x 1080) cost $6.

- **Failed images are free.** Broken links, web pages, files that aren't images and images over the size limit are listed with the reason and never charged.
- **No extra usage fees.** The price per image covers the computing time; you don't pay for memory or CPU on top.
- **Spending cap:** set a maximum cost per run in the run options. The Actor checks the cap before each image and stops cleanly when the next one wouldn't fit.

### Limits

- **Input size:** up to 2.25 megapixels per image, for example 1920 x 1080 or 1500 x 1500, and up to 30 MB per file. Larger images are listed as failed and not charged; shrink them first or upscale a crop.
- **Formats in:** JPEG, PNG, WebP, GIF (first frame), AVIF and TIFF.
- **Speed:** about 5 to 20 seconds for a 500 x 500 photo and about 3 minutes for 1920 x 1080 at the default 2 GB of memory. Doubling the memory roughly halves the time, and the price per image stays the same.
- **Faces:** this Actor does not detect, restore or change faces. It treats every part of the image the same way.
- **Your files:** images are only downloaded into the run and stored in the run's own key-value store, which Apify deletes after your plan's data retention period. Nothing is kept anywhere else.

### FAQ

**How is this different from simple resizing?** Resizing only spreads the existing pixels out, so edges get soft or blocky. Real-ESRGAN was trained to rebuild sharp edges and textures and to remove compression noise.

**Which image type should I pick?** *Photo* for anything from a camera or a screen. *Illustration* for flat colours and clean lines: anime, comics, logos and drawings.

**Can I upscale my own files?** Yes, upload them anywhere that gives a direct link, such as an Apify key-value store or cloud storage, and paste the links.

**Is there a GPU?** No. The models are small enough to run on Apify's CPUs, which keeps the price per image low.

### Credits

The models are Real-ESRGAN's realesr-general-x4v3 and realesr-animevideov3 by Xintao Wang et al., released under the BSD 3-Clause License, converted to ONNX for this Actor.

### Questions and problems

Open an issue on this Actor's **Issues** tab with the image link and what went wrong. Issues are answered within a day.

# Actor input Schema

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

Direct links to the images to upscale, one per line (JPEG, PNG, WebP, GIF, AVIF or TIFF, up to 30 MB). Each image can be up to 2.25 megapixels, for example 1920 x 1080 or 1500 x 1500. A run takes up to 1,000 images.

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

How many times larger the output is on each side. 4x turns 500 x 500 into 2000 x 2000. The price is the same at every scale.

## `imageType` (type: `string`):

Photo suits photographs, product shots and screenshots, and also removes JPEG noise. Illustration suits anime, cartoons, drawings and line art, and is about twice as fast.

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

PNG is lossless and keeps transparency. JPEG and WebP files are much smaller. WebP keeps transparency; JPEG puts transparent areas on white.

## `quality` (type: `integer`):

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

## Actor input object example

```json
{
  "imageUrls": [
    "https://upload.wikimedia.org/wikipedia/commons/a/a9/Example.jpg"
  ],
  "scale": "4",
  "imageType": "photo",
  "outputFormat": "png",
  "quality": 92
}
```

# Actor output Schema

## `results` (type: `string`):

One row per image: the link to the upscaled file, its size, and any error.

## `images` (type: `string`):

The upscaled image files stored in this run's key-value store.

# 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": [
        "https://upload.wikimedia.org/wikipedia/commons/a/a9/Example.jpg"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("clearpull/image-upscaler").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": ["https://upload.wikimedia.org/wikipedia/commons/a/a9/Example.jpg"] }

# Run the Actor and wait for it to finish
run = client.actor("clearpull/image-upscaler").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": [
    "https://upload.wikimedia.org/wikipedia/commons/a/a9/Example.jpg"
  ]
}' |
apify call clearpull/image-upscaler --silent --output-dataset

```

## MCP server setup

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

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/ZmBgnIjkcqxQ1CThZ/builds/n8jLFz3sqtIwK1fGn/openapi.json
