# AI Image Upscaler & Enhancer: 2x–4x, 4K, Bulk (`benexe/ai-image-upscaler`) Actor

Upscale and enhance images with SeedVR2 AI: 2x–4x or up to 4K, sharper details, bulk from URLs or any scraper dataset. Product photos, thumbnails, real-estate and social images. Pay per image, no subscription.

- **URL**: https://apify.com/benexe/ai-image-upscaler.md
- **Developed by:** [Marcel Tomas](https://apify.com/benexe) (community)
- **Categories:** AI, E-commerce, For creators
- **Security:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.50 / 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 & Enhancer: 2x–4x, 4K, Bulk

**Make any image 2x–4x bigger and sharper with SeedVR2 AI — in bulk, from $0.007 per image, no subscription.**

Low-resolution product photos, thumbnails, real-estate pictures, old photos, social media images: upscale them to HD or 4K with real recovered detail, not just blurry enlargement. Paste URLs or pick a dataset from any scraper and get every image back upscaled.

- ✅ SeedVR2 — state-of-the-art diffusion upscaler
- ✅ 2x, 3x, 4x or a target (720p, 1080p, 1440p, 4K)
- ✅ Bulk: thousands of images per run
- ✅ Works on any scraper dataset (Amazon, Shopify, real estate, Instagram…)
- ✅ JPG, PNG or WebP
- ✅ Failed images are free

### Before / after

Apollo 11 photo (NASA, public domain), 640×624 → 2x with SeedVR2 in 2.9 s. Zoomed detail:

![Original resized vs SeedVR2 upscaled: helmet visor detail](https://api.apify.com/v2/key-value-stores/ylaYBQ1gaeTfPTFdX/records/compare-crop.jpg?signature=1InXGZ1fEZwTjrq5ZA7Xh)

Full image:

![Before 640x624 and after 1280x1248](https://api.apify.com/v2/key-value-stores/ylaYBQ1gaeTfPTFdX/records/compare-full.jpg?signature=Q4GeycHkcpYVE7I3NDFz)

### Why this Actor

| | This Actor | Typical options |
|---|---|---|
| Price | **$0.007 per image** (up to 2 MP output) | $0.012–0.02 per image, or a monthly subscription |
| Bulk from scraper datasets | Yes, image fields detected automatically | Usually URLs only |
| Output control | Factor or target resolution, size cap, format | Fixed |
| Failed or rejected images | **Free** | Often charged |

### How it works

1. Add image URLs, or pick datasets produced by other Actors (product, listing or social media scrapers).
2. Choose **2x/3x/4x** or a **target resolution** (e.g. 4K).
3. Each image is upscaled with SeedVR2 and saved in your run's storage; you get a public link per image.

### Real runs

| Input | Setting | Output | Time |
|---|---|---|---|
| 412×412 PNG | Target 4K, WebP | 2160×2160 (4.7 MP) | 6.6 s |
| 288×288 logo PNG | 4x | 1152×1152 | 2.5 s |
| Instagram images from a scraper dataset, 828×1472 | 2x | 1664×2944 (4.9 MP) | 7.5 s each, in parallel |

### Use cases

- **E-commerce:** sharpen supplier and marketplace product photos before importing them to your store.
- **Creators:** upscale thumbnails, covers and screenshots to HD/4K.
- **Real estate and travel:** enhance listing photos at scale.
- **Archives:** restore small or compressed images.
- **Automations:** n8n, Make, Zapier, the Apify API or MCP — send URLs, receive upscaled images.

### Output (one record per image)

| Field | Meaning |
|---|---|
| `outputUrl` | Link to the upscaled image in your Apify storage |
| `source` | The original image URL |
| `inputWidth/Height`, `outputWidth/Height`, `outputMegapixels`, `scale` | Sizes before and after |
| `format`, `bytes` | Output file |
| `status`, `error` | `ok` or `error` (with the reason; not charged) |

### Pricing (pay per event)

| Event | Free plan | Paid plans |
|---|---|---|
| `image-upscaled` — one image, output up to 2 megapixels | $0.007 | down to $0.0055 |
| `extra-megapixel` — each started megapixel above 2 MP | $0.0025 | $0.0025 |
| `image-upscaled-byok` — one image of any size with your own fal.ai key | $0.003 | down to $0.0025 |

Examples (free plan): 800×600 → 2x (1.9 MP) = **$0.007** · 1000×1000 → 2x (4 MP) = $0.007 + 2 × $0.0025 = **$0.012** · 1920×1080 → 4K (8.3 MP) = $0.007 + 7 × $0.0025 = **$0.0245**.
**Never charged:** images that cannot be downloaded, unsupported files and images rejected by the safety checker. Without your own key, free-plan Apify accounts can upscale up to 4 images per run (add your own fal.ai key or upgrade for bulk).

### FAQ

**Which model?** SeedVR2, a diffusion-based restoration model that reconstructs fine detail (text, textures, faces) better than classic upscalers.

**Are my images stored?** Originals are processed in memory and sent to fal.ai for GPU processing; results are saved in your own Apify storage.

**Limits?** Input up to 25 MB; output up to 36 megapixels (default cap 16 MP — the factor is reduced automatically for very large inputs; images already at the cap are skipped for free). Images over 8 MB are passed to the GPU by URL, so the host must allow downloads.

**Content rules?** A safety checker is on. Only upscale images you have the right to use.

### Related

- [Instagram Reels & TikTok Transcript](https://apify.com/benexe/reels-tiktok-transcript)
- [PDF, YouTube, Audio & Video to Markdown](https://apify.com/benexe/pdf-to-markdown-ocr)
- [Website Contact Extractor](https://apify.com/benexe/website-contact-extractor) — emails, phones, socials and company data from any website or Google Maps results.

### Support

Open an issue on the Actor's *Issues* tab with the run ID. Feature requests welcome.

# Actor input Schema

## `images` (type: `array`):

Direct links to PNG, JPEG, WebP, GIF or BMP images (up to 25 MB each).

## `datasetIds` (type: `array`):

Upscale the images found in datasets from other Actors (product, real-estate, social media scrapers…). Common image fields are detected automatically.

## `imageField` (type: `string`):

Field that holds the image URL(s) in the dataset items, e.g. imageUrl or images. Dot notation works (product.image). Leave empty for auto-detection.

## `maxImagesPerItem` (type: `integer`):

For items with several images (e.g. product galleries).

## `mode` (type: `string`):

Factor multiplies width and height; Target resolution sets the shorter side of the output.

## `scale` (type: `number`):

Used with 'Factor': 2 = twice the width and height.

## `targetResolution` (type: `string`):

Used with 'Target resolution': the shorter side of the output (2160p = 4K).

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

JPG is smallest; PNG is lossless; WebP is a good balance.

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

Caps the output; the factor is reduced automatically for very large inputs.

## `noiseScale` (type: `number`):

Higher = more generated fine detail; lower = more faithful. 0.1 is a good default.

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

Hard cap for the whole run.

## `falApiKey` (type: `string`):

Use your own fal.ai key for the lower price per image and no free-plan cap. fal.ai bills you for the GPU time itself.

## `healthCheck` (type: `boolean`):

Internal. Never charged.

## Actor input object example

```json
{
  "images": [
    "https://storage.googleapis.com/falserverless/example_inputs/seedvr2/image_in.png"
  ],
  "maxImagesPerItem": 1,
  "mode": "factor",
  "scale": 2,
  "targetResolution": "2160p",
  "outputFormat": "jpg",
  "maxOutputMegapixels": 16,
  "noiseScale": 0.1,
  "maxImages": 500,
  "healthCheck": false
}
```

# Actor output Schema

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

Original and upscaled image, sizes, status.

## `runSummary` (type: `string`):

Images upscaled, failed, output megapixels, stop reason.

# 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 = {
    "images": [
        "https://storage.googleapis.com/falserverless/example_inputs/seedvr2/image_in.png"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("benexe/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 = { "images": ["https://storage.googleapis.com/falserverless/example_inputs/seedvr2/image_in.png"] }

# Run the Actor and wait for it to finish
run = client.actor("benexe/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 '{
  "images": [
    "https://storage.googleapis.com/falserverless/example_inputs/seedvr2/image_in.png"
  ]
}' |
apify call benexe/ai-image-upscaler --silent --output-dataset

```

## MCP server setup

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