AI Image Upscaler API — SeedVR2 2x/4x, Face Restoration, Batch avatar

AI Image Upscaler API — SeedVR2 2x/4x, Face Restoration, Batch

Pricing

from $12.00 / 1,000 image upscaleds

Go to Apify Store
AI Image Upscaler API — SeedVR2 2x/4x, Face Restoration, Batch

AI Image Upscaler API — SeedVR2 2x/4x, Face Restoration, Batch

Upscale images 2x or 4x with SeedVR2 AI super-resolution and, optionally, restore blurry faces in old or low-res photos (CodeFormer). One dataset item per image: upscaled image URL, width, height. Batch input, no API key, pay per image, failures free. Works with AI agents (MCP, agentic payments).

Pricing

from $12.00 / 1,000 image upscaleds

Rating

0.0

(0)

Developer

Sherwood

Sherwood

Maintained by Community

Actor stats

0

Bookmarked

9

Total users

6

Monthly active users

6 days ago

Last modified

Features

Limited permissions

Share

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. Turn on restoreFaces and a face restoration model (CodeFormer) first repairs the blurry, pixelated or damaged faces of old family photos, scans and low-res pictures, then the whole image is enlarged. No API key, no GPU, no subscription. $0.012 per image on the free plan, from $12.00 per 1,000 images on paid plans (the store page shows your plan's price), plus $0.004 per image on the free plan, from $4.00 per 1,000 on paid plans, with face restoration; 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",
"facesRestored": false,
"faceModel": null,
"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.
  • Restore old photos: fix blurry or pixelated faces in family archives, scans and portraits (restoreFaces), then enlarge them for print.
  • Enhance image quality and increase the resolution of blurry, compressed or low-res 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

FieldTypeDefaultNotes
imageUrlsarraytwo sample imagesPublic 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.
imageFilesarray—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, startUrlsaliases—Merged with imageUrls, duplicates removed. startUrls accepts {"url": "..."} objects.
datasetIdstring—Read the image URLs from an Apify dataset instead (see below).
urlFieldstringautoField holding the image URL in each dataset item: images[].url, photo.thumbnails[0].url...
maxImagesPerIteminteger1Image URLs taken from each dataset item.
keepFieldsarray—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.
restoreFacesbooleanfalseRestore every face with CodeFormer before upscaling: old, blurry, pixelated or damaged faces come out sharp and natural. Every image of the run goes through the model and is charged the extra event, so keep photos without faces in a separate run.
faceFidelitynumber 0–10.7With restoreFaces: 0 gives the sharpest faces but may invent details, 1 stays closest to the original. 0.7 keeps the person recognizable.
targetLongEdgeinteger—Longest side to reach, in pixels, instead of 2x/4x (at most 4x). Images already this large are skipped.
skipIfLongEdgeAtLeastinteger—Skip, without charge, images whose longest side is already this large.
outputFormatjpg, png, webpjpgPNG and WebP keep transparency.
maxOutputMegapixelsinteger16Cap on output size; larger results are upscaled to this size instead. 4 MP ≈ 2000×2000.
maxImagesinteger100Stop 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 — per started megapixel of output above 4 MP (a 4x upscale of a 1000×1000 photo is 16 MP, so 12 extra): $0.002 on the free plan and Starter, $0.0018 on Scale, $0.0016 on Business and above.
  • Face restored — with restoreFaces on, $0.004 to $0.005 per image delivered (same plan tiers), on top of the image price, whether or not a face was found. Not charged when the image fails.
  • 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.

Use it from an AI coding agent

Install the task skill for Claude Code, Codex, Cursor, Gemini CLI or any agent that reads the Agent Skills format:

$npx skills add maxouf/sherwood-skills --skill image-upscaler

The skill compares this Actor with the other tools for the task, estimates the cost before running, caps the spend and hands back the result as a file. The pipeline skill apify-bulk-image-pipeline chains it with the other Actors of the use case. Source: github.com/maxouf/sherwood-skills.

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. Face restoration adds a few seconds per image.
  • Face restoration repairs faces (blur, pixelation, compression, light scratches); it does not colorize black-and-white photos, fill missing areas or repair torn paper. The model cannot tell whether it found a face, so every image of a restoreFaces run is charged the event: run photos without people separately. Very low faceFidelity values can make a face look smooth or slightly different from the person: keep 0.7 unless you want the sharpest result.

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 it restore faces in old or blurry photos? Yes: set restoreFaces to true. A face restoration model (CodeFormer) repairs every face in the picture first, then SeedVR2 enlarges the whole photo, so old family photos, scans and low-res portraits come out sharp with natural faces. It costs $0.004 to $0.005 more per image. It does not colorize or fill in missing parts of the photo.

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.