# AI Image Upscaler 4x: From $0.01, Priced by Size, No Login (`conserving_celerytop/ai-image-upscaler`) Actor

Upscale images 2x, 3x or 4x in bulk with Real-ESRGAN. $0.01 per 640 x 480 pixels of input, so a 1000 x 1000 photo costs $0.04. Failed images are free. Sharper edges and cleaner JPEG noise than plain resizing, transparency kept. Alternative to Topaz Gigapixel and Let's Enhance. MCP-ready, no login.

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

## Pricing

from $7.00 / 1,000 image upscales

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

### What does AI Image Upscaler do?

**AI Image Upscaler 4x** makes your images larger (2x, 3x or 4x) with an AI super-resolution model, in bulk. It sharpens edges, cleans JPEG blocks and noise, and returns a new PNG, JPEG or WebP file for each image. Give it image links, upload files from your computer, or paste base64 data from your own code. Each enlarged image is saved in the run's key-value store, and a dataset row gives you its link, the size before and after, and the status.

It runs on CPU, so there is no GPU queue and no third-party AI service. Failed images are free. Use it as an AI image upscaler API: send image links in one request and read the enlarged file links from the dataset.

### An alternative to Topaz Gigapixel and Let's Enhance for bulk upscaling

This Actor is not Topaz Gigapixel or Let's Enhance and is not affiliated with either. It enlarges images 2x, 3x or 4x with a Real-ESRGAN model that runs on CPU inside the Actor, up to 5,000 images per run, and you pay per started 640 x 480 block of input, from $0.007 to $0.010 depending on your plan (see the pricing section below).

### Why upscale images with this Actor?

- **Real 4x.** A 512 x 512 image becomes 2048 x 2048. Output goes up to 16 megapixels by default and 64 at most.
- **Bulk.** Up to 5,000 images per run, from links, uploads or base64, in one dataset.
- **Noise control.** One setting decides how much grain and JPEG noise is cleaned, from 0 to 100.
- **Transparency kept.** PNG and WebP output keep transparent areas, so logos and cut-out product shots stay usable.
- **Honest billing.** You pay only for images that were enlarged and saved.

Typical uses: product photos for a shop, old or small photos, thumbnails for print, game and web art, and images made by AI generators that come out at 1024 px.

### How to upscale images, step by step

1. Open the Actor and click **Try for free**.
2. Paste your image links in **Image URLs**, or use **Upload images** to add files from your computer.
3. Pick a **Scale**: 2x, 3x or 4x.
4. Pick an **Output format**: PNG (lossless), JPEG or WebP (smaller files).
5. Click **Start**. When the run ends, open the **Enlarged images** table and click a link to download each file.

To call it from code, Make, Zapier or n8n, send the same input as JSON through the Apify API and read the dataset. Every row has `outputUrl`.

### How much does it cost to upscale images?

You pay per started 640 x 480 block of input pixels (307,200 pixels, or 0.3 megapixels), not per image. A small image is one block. A larger image is several blocks. The number of blocks is the input width times the input height, divided by 307,200, rounded up.

The price per block depends on your Apify plan: **$0.010** on Free, $0.009 on Starter, $0.008 on Scale and **$0.007** on Business.

| Input size | Blocks | Price on Free | Price on Business |
|---|---|---|---|
| 640 x 480 | 1 | $0.010 | $0.007 |
| 800 x 600 | 2 | $0.020 | $0.014 |
| 1024 x 768 | 3 | $0.030 | $0.021 |
| 1280 x 720 | 3 | $0.030 | $0.021 |
| 1920 x 1080 | 7 | $0.070 | $0.049 |
| 2048 x 2048 (largest allowed) | 14 | $0.140 | $0.098 |

Inputs above 4 megapixels, for example 4000 x 3000, are rejected and not charged. Images that fail, and images already at your output limit, are not charged either.

**Tip:** the price follows the size of the input, so shrinking a large input before you run it costs less.

**Worked example:** 500 product thumbnails at 400 x 400 (one block each), enlarged 4x to 1600 x 1600, cost 500 x $0.010 = **$5.00** on the Free plan ($3.50 on Business). You can set a spending limit on any run, and the Actor stops cleanly when it is reached.

### Input example

```json
{
  "imageUrls": ["https://raw.githubusercontent.com/xinntao/Real-ESRGAN/master/inputs/ADE_val_00000114.jpg"],
  "scale": "4",
  "outputFormat": "png",
  "noiseReduction": 50,
  "maxOutputMegapixels": 16
}
```

### Output example

```json
{
  "inputIndex": 1,
  "imageUrl": "https://raw.githubusercontent.com/xinntao/Real-ESRGAN/master/inputs/ADE_val_00000114.jpg",
  "source": "url",
  "status": "ok",
  "outputUrl": "https://api.apify.com/v2/key-value-stores/<store id>/records/upscaled-0001-ADE_val_00000114.png",
  "outputKey": "upscaled-0001-ADE_val_00000114.png",
  "outputFormat": "png",
  "outputWidth": 1024,
  "outputHeight": 1024,
  "inputWidth": 256,
  "inputHeight": 256,
  "scaleRequested": 4,
  "scaleApplied": 4.0,
  "noiseReduction": 50,
  "hasTransparency": false,
  "billedImages": 1,
  "charged": true,
  "error": null
}
```

Other statuses tell you why an image was skipped, for example `not_found`, `not_image`, `image_too_large`, `robots_disallowed` or `blocked`, with a plain-words `error`.

### Tips for the best results

- Start from the largest copy of the image you have. The model adds detail that fits, but it cannot recover text or faces that are only a few pixels tall.
- Use **Noise reduction** 20 to 40 for clean photos with fine texture, and 60 to 100 for heavily compressed JPEGs.
- Use **Maximum output megapixels** to hit a size, for example 4 for web pages or 16 for large prints.

### Bulk lists

Use a long list of image links from an Apify Dataset or from a file. Pick the Dataset under **Dataset with the list** and write the name of its field under **Field in the dataset**. Leave the field name empty to use the first text field. Or paste the web address of a .txt, .csv or .json file under **List file URL**. A .csv file uses its first column. A header row is skipped. The file can be up to 10 MB. Entries from the Dataset and the file are added to the ones typed under **Image URLs**, and duplicates are removed. "Maximum images" still limits each run. The price per image does not change.

### Related Actors

- [Bulk Image Compressor & Converter](https://apify.com/conserving_celerytop/image-converter-compressor): Use it to convert, compress and resize images in bulk to WebP, AVIF, JPEG or PNG.
- [Image to Text OCR](https://apify.com/conserving_celerytop/image-to-text-ocr): Use it to extract text from receipts, screenshots, scans and photos.
- [Website Screenshot API](https://apify.com/conserving_celerytop/website-screenshot-api): Use it to capture full-page screenshots or PDFs of a list of URLs.

### FAQ

**Is it legal to upscale images with this Actor?**
Yes for images you own or have the right to edit. The Actor only downloads the links you give it, reads robots.txt on each site first, and sends a user agent with a contact address. It keeps nothing after the run beyond your own storage.

**Which model does it use?**
The open Real-ESRGAN general model (BSD-3-Clause licence), run on CPU. The licence text is in the NOTICE file of the source.

**Which file types can I use?**
PNG, JPEG, WebP, GIF (first frame), BMP and TIFF in; PNG, JPEG or WebP out. Grayscale stays grayscale, and EXIF rotation is applied.

**Why did my image fail?**
The `error` field says why. The most common causes are a link to a web page instead of the image file, a site that refuses automated downloads, or an input larger than 4 megapixels.

**How long does it take?**
About 2 to 10 seconds per small image with the default 4 GB of memory. Give the run more memory to get more CPU and finish big batches sooner.

# Actor input Schema

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

Enter direct links to image files, one per line: PNG, JPEG, WebP, GIF, BMP or TIFF. Use your own photos, product shots, scans or artwork.

## `listDatasetId` (type: `string`):

Pick an Apify Dataset that holds your image links, one entry per item. They are added to the entries typed above.

## `listDatasetField` (type: `string`):

Name of the dataset field that holds the entry. Leave empty to use the first text field it finds.

## `listFileUrl` (type: `string`):

Web address of a .txt, .csv or .json file with your image links, one entry per line. A header row is skipped. Up to 10 MB.

## `imageUploads` (type: `array`):

Upload image files from your computer. Each file is stored in a key-value store you choose and read from its link.

## `imageBase64` (type: `array`):

Paste images as base64 strings or data URIs (data:image/png;base64,...), one per line. Handy from Make, Zapier, n8n or your own code. Up to about 10 MB each.

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

Choose how much larger each side gets. 4x turns 512 x 512 into 2048 x 2048.

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

Choose the file format of the enlarged images. PNG is lossless and keeps transparency; JPEG and WebP files are smaller.

## `noiseReduction` (type: `integer`):

Set how strongly noise and JPEG blocks are cleaned, from 0 (keep fine grain) to 100 (smoothest). 50 suits most photos.

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

Set the compression quality for JPEG and WebP output, from 50 to 100.

## `maxOutputMegapixels` (type: `integer`):

Cap the size of each enlarged image. An image that would be larger is enlarged less, to fit. 16 megapixels is 4096 x 4096.

## `maxImages` (type: `integer`):

Enlarge at most this many images per run.

## `maxFileSizeMb` (type: `integer`):

Download source files up to this size.

## Actor input object example

```json
{
  "imageUrls": [
    "https://raw.githubusercontent.com/xinntao/Real-ESRGAN/master/inputs/ADE_val_00000114.jpg"
  ],
  "imageBase64": [
    "data:image/png;base64,iVBORw0KGgo..."
  ],
  "scale": "4",
  "outputFormat": "png",
  "noiseReduction": 50,
  "quality": 92,
  "maxOutputMegapixels": 16,
  "maxImages": 1000,
  "maxFileSizeMb": 25
}
```

# Actor output Schema

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

outputUrl, status, imageUrl, input and output width and height, scaleApplied, outputFormat, billedImages and error.

## `files` (type: `string`):

All enlarged image files (keys start with upscaled-).

## `errors` (type: `string`):

Images that could not be enlarged and why. Not billed.

## `stats` (type: `string`):

JSON with images planned and done, statuses, images billed, seconds, megapixels in and out, requests and peak memory.

# 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://raw.githubusercontent.com/xinntao/Real-ESRGAN/master/inputs/ADE_val_00000114.jpg"
    ],
    "scale": "4"
};

// Run the Actor and wait for it to finish
const run = await client.actor("conserving_celerytop/ai-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://raw.githubusercontent.com/xinntao/Real-ESRGAN/master/inputs/ADE_val_00000114.jpg"],
    "scale": "4",
}

# Run the Actor and wait for it to finish
run = client.actor("conserving_celerytop/ai-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://raw.githubusercontent.com/xinntao/Real-ESRGAN/master/inputs/ADE_val_00000114.jpg"
  ],
  "scale": "4"
}' |
apify call conserving_celerytop/ai-image-upscaler --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,conserving_celerytop/ai-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/KhC3AMXNfn3qhf028/builds/1iqcqDzN5W51AvQh3/openapi.json