AI Image Upscaler API — SeedVR2 super-resolution, batch 2x/4x, pay per image

Give it one image URL or a thousand, or the dataset of another Actor, and get every image upscaled 2x, 4x or to a target size in pixels with an AI super-resolution model (SeedVR2), one dataset item per image: the upscaled file URL, its width and height, or a clear error. No API key, no GPU, no subscription. $0.012 to $0.018 per image delivered depending on your Apify plan (volume plans pay less), failures are free.

Built for automation and AI agents: send a list in imageUrls, or a single URL (or a comma-separated string) in imageUrl; every alias (imageUrls, imageUrl, urls, images, startUrls, imageFiles) is merged, nothing is required, and the default input runs on its own so you can see the output shape before sending your own files. Images can be public URLs, Google Drive or Dropbox share links, Google Drive file IDs, base64 images or data URIs (handy from n8n, Make or Zapier), or files uploaded from the Apify console.

What you get

One item per image, in your dataset:

{
  "index": 0,
  "inputUrl": "https://example.com/product-small.jpg",
  "outputUrl": "https://api.apify.com/v2/key-value-stores/abc123/records/upscaled-0000.jpg",
  "width": 2048,
  "height": 2048,
  "megapixels": 4.19,
  "scale": "2",
  "factor": 2,
  "format": "jpg",
  "model": "fal-ai/seedvr/upscale/image",
  "durationMs": 9120,
  "status": "ok",
  "error": null
}

A failed image (unreachable URL, not an image, over 25 MB) comes back with "status": "error" and the reason in error. It is never charged. A string that is not an image source at all (a file name, a broken ID) also comes back as an error item, so nothing is silently dropped. For a base64 image, inputUrl holds a short label (data:image/png;base64,iVBOR…) rather than the whole payload.

An image already large enough for targetLongEdge or skipIfLongEdgeAtLeast comes back with "status": "skipped" and its original URL in outputUrl, so the next step of a workflow still gets a usable file. It is never charged either.

Transparent images, such as cutouts from a background remover, keep their transparency in PNG and WebP output. JPG has no transparency: transparent areas become white.

Use cases

• Upscale e-commerce product photos for listings and marketplaces in bulk.
• Enhance image quality and increase the resolution of blurry, compressed or old pictures before print.
• Enlarge AI-generated images (Midjourney, Flux, Stable Diffusion) to usable sizes.
• Upscale images to 4K (targetLongEdge: 3840) for wallpapers, banners and large displays.
• Sharpen thumbnails and avatars pulled from a scraper, in the same workflow.
• Give an AI agent or an n8n / Make / Zapier flow a single call that handles a whole list.

Input

Field	Type	Default	Notes
imageUrls	array	two sample images	Public JPG, PNG or WebP URLs, Google Drive or Dropbox share links, Google Drive file IDs, base64 images or data URIs. For a single item or a comma-separated string, use imageUrl.
imageFiles	array	—	Files uploaded from the console (stored in a key-value store of your choice). Through the API: key-value store record links, or any image URLs.
imageUrl, urls, images, startUrls	aliases	—	Merged with imageUrls, duplicates removed. startUrls accepts {"url": "..."} objects.
datasetId	string	—	Read the image URLs from an Apify dataset instead (see below).
urlField	string	auto	Field holding the image URL in each dataset item: images[].url, photo.thumbnails[0].url...
maxImagesPerItem	integer	1	Image URLs taken from each dataset item.
keepFields	array	—	Fields copied from each dataset item into its result, under source (SKU, ASIN, listing URL).
scale	"2" or "4"	"2"	2 doubles width and height, 4 quadruples them.
targetLongEdge	integer	—	Longest side to reach, in pixels, instead of 2x/4x (at most 4x). Images already this large are skipped.
skipIfLongEdgeAtLeast	integer	—	Skip, without charge, images whose longest side is already this large.
outputFormat	jpg, png, webp	jpg	PNG and WebP keep transparency.
maxOutputMegapixels	integer	16	Cap on output size; larger results are upscaled to this size instead. 4 MP ≈ 2000×2000.
maxImages	integer	100	Stop after this many images.

Minimal call:

{ "imageUrls": ["https://example.com/a.jpg", "https://example.com/b.png"] }

Other ways to give images

Every item of imageUrls (or of any alias) can be:

• a public URL of a JPG, PNG or WebP file;
• a Google Drive share link (https://drive.google.com/file/d/ID/view?usp=sharing, open?id=ID, uc?id=ID) or just the file ID, for a file shared with anyone who has the link;
• a Dropbox share link (https://www.dropbox.com/s/.../photo.jpg?dl=0, scl/fi/...), converted to a direct download;
• a base64 image or a data URI (data:image/png;base64,...), the way n8n, Make and Zapier hand over binary data;
• an Apify key-value store record link (https://api.apify.com/v2/key-value-stores/STORE/records/KEY), read with the run's permissions, which is what the console's Upload images field (imageFiles) produces.

{
  "imageUrls": [
    "https://drive.google.com/file/d/1AbC.../view?usp=sharing",
    "1AbC...",
    "https://www.dropbox.com/s/abc123/photo.jpg?dl=0",
    "data:image/png;base64,iVBORw0KGgo..."
  ]
}

A Drive file that is not shared publicly answers with a web page instead of an image: the item comes back as an error saying so, free of charge. Private Google Drive access (OAuth) is not supported.

Chain it after another Actor

Give datasetId (a dataset ID or name) and the Actor reads the image URLs from its items: the output of a scraper, of Background Remover API or of AI Image Generator. The image field is detected automatically (outputUrl, highResolutionImages, imageUrls, images, displayUrl, thumbnailImage...), or set it with urlField.

{
  "datasetId": "YOUR_DATASET_ID",
  "urlField": "images[].url",
  "keepFields": ["sku", "url"],
  "targetLongEdge": 2048
}

To run it automatically after another Actor, add it on that Actor's Integrations tab with this input; the platform fills in the dataset of each finished run:

{ "datasetId": "{{resource.defaultDatasetId}}", "outputFormat": "png" }

Each result carries sourceItemIndex, the position of the item it came from, and the fields listed in keepFields, so a spreadsheet or a store import can match every upscaled image with its product.

Pricing

• Image upscaled — per image delivered, output up to 4 MP included. The price depends on your Apify plan: $0.012 on the free plan, $0.018 on Starter, $0.015 on Scale, $0.012 on Business and above — the store page shows yours.
• Extra megapixel — $0.002 per started megapixel above 4 MP (a 4x upscale of a 1000×1000 photo is 16 MP, so 12 extra).
• Failed, unreachable or non-image URLs: free.

Set a maximum cost per run in Apify and the Actor stops cleanly when it is reached; remaining images are reported, not processed.

Via API, Python, n8n, Make or MCP

Call it like any Apify Actor: POST https://api.apify.com/v2/actors/sherwood~image-upscaler-batch/run-sync-get-dataset-items with the JSON input above, or add it as a tool through the Apify MCP server. Results are plain dataset items, so get-dataset-items returns the URLs directly.

From Python, with the apify-client package:

from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("sherwood/image-upscaler-batch").call(run_input={
    "imageUrls": ["https://example.com/a.jpg", "https://example.com/b.png"],
    "targetLongEdge": 2048,
})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["status"], item.get("outputUrl") or item.get("error"))

In n8n, use the verified Apify node with Actor sherwood~image-upscaler-batch and the JSON input in the custom body.

The Actor is eligible for agentic payments (x402, Skyfire, MPP): an AI agent can run it and pay per request without an Apify account.

Run it on a schedule

New product photos rarely stop coming. Create a schedule on this Actor, or on a saved task holding your settings — Apify's one-minute video shows how: Schedule your Actor. With skipIfLongEdgeAtLeast or a datasetId input, a scheduled run skips what is already done and only pays for new images. To run it automatically after a scraper or a generator instead, use the Integrations tab as shown above (video: Actor-to-Actor integration).

Limits

• Input images up to 25 MB each, from public http(s) URLs, share links or uploads. Base64 images travel inside the Actor input, so keep them to a few MB.
• Output files live in the run's key-value store and follow your account's data retention.
• Processing time is typically 5 to 25 seconds per image; 4 images are processed in parallel.

Related Actors

• AI Image Generator (FLUX) — generate the images this Actor enlarges.
• Background Remover API — cut the subject out before or after upscaling (PNG keeps transparency).
• Image to Video API — animate the upscaled images into short clips.
• Instagram Scraper and Google Maps Scraper — two common sources of image URLs to feed in through datasetId.

FAQ

How do I upscale multiple images at once? Send the whole list in imageUrls (or point datasetId at another Actor's output). One call handles up to maxImages images, processed 4 at a time, and returns one dataset item per image in input order.

How do I upscale a photo without losing quality? Classic resizing stretches pixels; this Actor runs SeedVR2, an AI super-resolution model that reconstructs detail, so edges and textures stay sharp at 2x or 4x. Faces, text and logos come out noticeably cleaner than bicubic resizing.

Can I upscale an image to 4K? Yes: set targetLongEdge to 3840 and any smaller image is enlarged to 4K (up to 4x its original size). Output above 4 megapixels is billed as extra megapixels, shown in Pricing above.

Is there a free image upscaler API? Apify's free plan includes $5 of platform credit each month, which covers roughly 400 upscaled images at $0.012 each — enough to test and run small batches without paying. Failures and skipped images are always free.

Why use this instead of calling an upscaling model's API directly? No GPU account, no model API key to create and store, no rate-limit handling: you send URLs (or Drive/Dropbox links, base64, uploads), the Actor manages the model calls, retries and parallelism, and bills per delivered image. A direct model API bills you for failures too.

Does it work on AI-generated images? Yes — enlarging Midjourney, FLUX or Stable Diffusion outputs to print or banner size is one of the main use cases. Chain it after AI Image Generator with datasetId.

Can I call it from Python or n8n? Yes: the Python snippet above uses apify-client, and in n8n the verified Apify node calls sherwood~image-upscaler-batch directly. Make, Zapier and MCP agents work the same way.