Batch Photo Upscaler and Restoration

Upscale a batch of authorized product photos on Apify compute, without sending them to an external AI API. Choose a target pixel budget, optional denoising and PNG, JPEG or WebP output. Get an ordered per-image manifest with dimensions, download links, bytes, elapsed time and model version.

For catalog teams receiving small supplier photos every day, this provides repeatable enlargement with explicit limits and visible failures. It does not promise to recover missing product detail.

What this Actor does

• Downloads direct public image URLs or reads binary uploads from an accessible Apify key-value store.
• Runs bundled FSRCNN neural super-resolution on CPU, with no runtime model download.
• Offers a non-neural Lanczos option when conservative interpolation is preferred.
• Preserves aspect ratio and PNG/WebP transparency, with integer dimension rounding.
• Writes one manifest entry per attempted image and stores successful files in the run key-value store.
• Reports failures without charging an image event for them.

Who is it for?

E-commerce catalog teams can normalize small supplier assets before a human quality review. Merchandising teams can enlarge approved images for layouts. Developers can put image enlargement between an ingestion job and an asset-management upload.

This is not a generative image editor, forensic tool, OCR recovery system, face restoration service, scratch remover or colorizer. Never rely on enlarged labels, serial numbers or texture as newly recovered evidence.

Why use this Actor?

The model and compute are self-contained. No paid AI account or external model API is needed. Every attempted image has an explicit outcome, making batch reconciliation straightforward.

FSRCNN is a compact regression CNN rather than a GAN or diffusion model. It can sharpen edges and also create artifacts; non-generative does not mean authentic detail recovery. Select lanczos to avoid neural reconstruction entirely. Denoising is off by default to protect small product labels and texture.

Getting started

1. Supply direct public JPEG, PNG or WebP URLs you are authorized to process.
2. Choose a target larger than the original image but no more than 16 times its pixel count.
3. Leave denoising at zero for your first product-detail comparison.
4. Start the Actor and inspect the dataset manifest.
5. Download successful outputUrl files and review them against the originals before use.

The prefilled fruit photograph is a public OpenCV sample. The following input requests approximately one million output pixels:

{
  "imageUrls": ["https://raw.githubusercontent.com/opencv/opencv/master/samples/data/fruits.jpg"],
  "targetPixels": 1000000,
  "mode": "fsrcnn",
  "denoiseStrength": 0,
  "outputFormat": "png",
  "maxImages": 100
}

Input parameters

Field	Meaning
imageUrls	Direct HTTP(S) image links. Private/local addresses, credentials, custom ports and unsafe redirects are rejected.
imageKeys	Binary upload keys. Read from inputStoreId or the current run default key-value store.
inputStoreId	Select your Apify upload store to grant the run read-only access under limited permissions. Used only for upload keys; source store is never written.
targetPixels	Output pixel budget, 10,000–2,000,000; default 1,000,000. Must be larger than each original and at most 16 times its pixel count.
mode	fsrcnn (default) or lanczos. No automatic method switching.
denoiseStrength	0–1; default 0. OpenCV non-local-means pre-filter, h=10×strength. Applies to both methods.
outputFormat	png default, jpeg or webp. JPEG/WebP quality 92. JPEG uses white behind transparency.
maxImages	First 1–100 combined entries attempted, URLs then keys. Default 100. Includes failed entries and duplicates; zero/unlimited unsupported.

At least one URL or key is required; combined input cannot exceed 100 entries. Entries beyond maxImages are not attempted or included in the manifest. Duplicates are processed separately and incur separate image events when successful.

Uploaded images

Upload binary records into your own Apify key-value store before starting the Actor, then pass that store ID and image keys:

{
  "inputStoreId": "YOUR17CHARSTOREID1",
  "imageKeys": ["product-front", "product-back"],
  "targetPixels": 1000000,
  "mode": "lanczos"
}

Select the store in the upload-store picker (or supply its ID through the API input). The Actor requests only READ permission on that selected store under limited permissions, not full account access. Your calling token must itself be authorized for the selected store. Unselected stores and source-store writes are not granted. If no store ID is supplied, keys refer only to this run's default store. INPUT and keys beginning upscaled- are reserved. Uploads must be binary images, not JSON containing a URL.

Output manifest

The default dataset contains successful and failed entries in attempted order. Successful entries contain:

Fields	Description
index, sourceType, source	Zero-based batch index and original URL or key. Original URL queries remain in the dataset; keep it private if sensitive.
status, error	success or error; error text is present on failed entries.
originalWidth, originalHeight	Dimensions after EXIF orientation.
outputWidth, outputHeight	Actual encoded output dimensions.
scaleFactor, scaleFactorY	Actual width/height multipliers, slightly different when rounded.
inputBytes, outputBytes	File sizes in bytes.
outputKey, outputUrl	Run storage record and downloadable file URL.
model, modelVersion	Actual FSRCNN native scale and pinned source commit, or Lanczos/Pillow version.
nonGenerative	No GAN/diffusion used, not a guarantee of recovered authenticity.
elapsedMs	Per-entry download, processing and storage time.

For example, the tested 512×480 fruit sample at a 600,000 pixel budget produces 800×750 pixels using FSRCNN x2. A representative manifest shape is:

{
  "index": 0,
  "sourceType": "url",
  "source": "https://example.com/product.jpg",
  "status": "success",
  "originalWidth": 512,
  "originalHeight": 480,
  "outputWidth": 800,
  "outputHeight": 750,
  "scaleFactor": 1.5625,
  "scaleFactorY": 1.5625,
  "inputBytes": 82429,
  "outputBytes": 1000000,
  "outputKey": "upscaled-1.png",
  "outputUrl": "https://api.apify.com/v2/key-value-stores/EXAMPLESTORE12345A/records/upscaled-1.png",
  "model": "FSRCNN x2",
  "modelVersion": "6a4812c4ef1c4f5947d79beafa32a05a6eb4a94d",
  "nonGenerative": true,
  "elapsedMs": 1066
}

The URL and output byte count above are illustrative, not a permanent download. Use your run's values. Failed entries omit output dimensions/files/model and contain a reason. If an image event cannot be charged because of a spending limit, its file is deleted and an uncharged error row records that attempted image; later images are not attempted. Partial success is possible; a run in which every entry fails exits FAILED.

Image limits and quality

Inputs: static JPEG, PNG or WebP, at most 10 MB, one million pixels and 4096 pixels on either side. Animation and other formats are rejected. Outputs: at most two million pixels, 8192 pixels on either side and 4x original dimensions.

The target is a maximum pixel budget, not an exact size promise; integer rounding may reduce it slightly. Already-larger images and excessive enlargement requests produce an error instead of silent downscaling. A 128×128 image cannot reach one million pixels within the supported 4x enlargement: use a target up to 262,144.

FSRCNN selects native 2x inference for requested scale up to 2, otherwise 4x, and resizes to the requested budget. Tiled inference bounds activation memory. Lanczos enlarges without neural inference. There is no quality fallback, proxy fallback, face model or subscription service behind either mode.

Denoising and product-detail preservation

Start with zero denoising. Positive values apply a non-local-means pre-filter and can remove both noise and useful detail. The effect depends on the image; this is not scratch repair. Compare all outputs with originals, especially labels, fabric, logos, fine patterns and sharp edges. Larger dimensions do not create trustworthy missing information.

PNG is the safest lossless delivery format. WebP and JPEG introduce compression. Alpha is preserved in PNG/WebP, interpolated independently from color; JPEG composites transparency onto white. EXIF orientation is applied; metadata is stripped from processed copies. Retain originals and their provenance records separately. This Actor is not a provenance-removal or authenticity-bypass tool.

How much does it cost to upscale product photos?

A one-time $0.005 start event applies per run. Each successfully processed and stored image incurs one image upscaled event. Failed entries have no image event charge; the start event can still apply when all images fail. No separate dataset-row event is charged.

BRONZE image price is $0.0096 per image. At this price, 1 image costs $0.0146, 10 images $0.101, and 100 images $0.965 in Actor event charges. Your applicable subscription tier determines the image rate; consult the live Pricing tab. Platform usage, storage, transfer and applicable taxes depend on Apify billing rules. The price is the same for either method and any supported pixel budget.

Integrations

• In n8n or Make, send the daily supplier image list, wait for the same run to finish, then filter manifest rows with status=success before uploading files to your asset manager.
• Join results back to your catalog using index and source; preserve failures for review instead of silently dropping SKUs.
• Use the Apify dataset JSON/CSV export for reconciliation; the dataset contains metadata, not inline image bytes.
• Download images before the run storage expires. Treat shared output links as access-bearing links and follow your retention policy.

Related Actors

This Actor is standalone: it does not scrape suppliers, publish products or require any other Actor. No companion Actor is required; use your existing catalog ingestion and asset-management pipeline.

API examples

Use your own Apify token. Start once and retain the returned run ID and storage IDs.

cURL

curl -X POST 'https://api.apify.com/v2/acts/automation-lab~batch-photo-upscale-restore/runs' \
  -H "Authorization: Bearer $APIFY_TOKEN" -H 'Content-Type: application/json' \
  -d '{"imageUrls":["https://example.com/product.jpg"],"targetPixels":1000000}'

JavaScript

import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/batch-photo-upscale-restore').call({
  imageUrls: ['https://example.com/product.jpg'], targetPixels: 1000000
});
if (run.status !== 'SUCCEEDED') throw new Error(`Run ${run.id}: ${run.status}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems({ limit: 100 });
console.log(items);

Python

import os
from apify_client import ApifyClient
client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/batch-photo-upscale-restore').call(
    run_input={'imageUrls': ['https://example.com/product.jpg'], 'targetPixels': 1000000})
if run['status'] != 'SUCCEEDED':
    raise RuntimeError(run['status'])
print(client.dataset(run['defaultDatasetId']).list_items(limit=100).items)

MCP setup

For Claude Code:

$claude mcp add --transport http apify "https://mcp.apify.com?tools=automation-lab/batch-photo-upscale-restore"

For Claude Desktop or Cursor, configure an HTTP-capable MCP client with:

{"mcpServers":{"apify":{"url":"https://mcp.apify.com?tools=automation-lab/batch-photo-upscale-restore"}}}

For VS Code, use:

{"servers":{"apify":{"type":"http","url":"https://mcp.apify.com?tools=automation-lab/batch-photo-upscale-restore"}}}

Authenticate with your own Apify account. Discover actual tool names and schemas with scoped tools/list: Actor selection also includes run/dataset/storage/abort tools, not exactly one tool. Discovery itself is read-only.

Example prompt: “Upscale these authorized product images to one million pixels with denoise off, then report success/error counts and download links.” Start only once. Keep the returned run ID; metadata IDs are not results. A call can return before completion. Poll that same run with bounded backoff (2,4,8 seconds, capped at 10) up to a stated 120-second consumer deadline. Recover the known run after client timeout instead of starting a duplicate. At deadline, report pending and stop; terminal failures mean any rows are partial.

After success, read bounded dataset pages: 20 source rows, at most 100 rows and 64 KiB of serialized UTF-8 content admitted to model context, whichever comes first. Enforce bytes host-side, including oversized pages, and disclose truncation and continuation offsets. If your client cannot intercept oversized responses, do not promise a hard byte limit. Keep full exports and image files outside model context. Discovery/caching behavior is client-dependent; no token-savings guarantee is claimed.

Legality, privacy and responsible use

Process only images you own or are authorized to transform. Respect copyrights, depicted people, supplier contracts and platform rules. Never use enlarged output as forensic or medical evidence. No watermark-removal, document reconstruction or provenance-bypass capability is offered.

Image processing occurs in the Actor container. Images are retrieved from supplied hosts or Apify storage and output files are stored in Apify. Failed operations send sanitized diagnostic input, exceptions and Actor/build/run IDs to our private GlitchTip service for repair; secret fields and URL queries are removed and reports are retained for 30 days. Image bytes are not included in these diagnostics. The output dataset retains the original input references, so protect it appropriately.

Bundled FSRCNN models are distributed under Apache-2.0 from Saafke/FSRCNN_Tensorflow; model versions and hashes are documented in models/README.md, with the upstream license included. OpenCV, Pillow and NumPy license notices are included in installed distributions. No proprietary model API or runtime download is used. Contact us through the Actor's Apify Issues tab for bugs or usage questions. Released model licensing is not a warranty about all training-image provenance or your rights to input/output assets.

Troubleshooting and FAQ

Why is my image rejected? Check direct-image URL access, single-frame format, 10 MB/1 MP input limits and target-size range. Tiny thumbnails need a smaller target; already-large inputs need a larger target within two million pixels. Private/internal hosts and unsafe redirects are intentionally unsupported.

Can I upload instead of expose a public URL? Yes, use binary records in an accessible Apify store and supply its ID and keys. Uploaded keys are not file paths or JSON documents.

Does success guarantee every image worked? No. Inspect each row's status. Partial batches can succeed; all-error batches fail. Network requests time out after 30 seconds, allow at most three redirects and do not blindly retry permanent failures.

Will this recover text or faces? No such claim is made. Use original higher-resolution sources wherever accuracy matters. Lanczos is the non-neural alternative, not detail recovery.

Are outputs permanent? No. Apify storage retention applies. Download and retain permitted results in your own system.