Bulk AI Image Upscaler from CSV, Google Sheet or Dataset

Got a whole catalogue of small, blurry product photos? Point this actor at your spreadsheet, Google Sheet or scraper results and every image comes back 2x, 3x or 4x bigger and sharper, each with its own download link, sitting next to your original columns (SKU, name, price, whatever you had).

No uploading one image at a time. No GPU, no subscription, no API key.

What it does

1. Reads your rows from a CSV, Excel file, Google Sheet, Apify dataset, JSON file or a plain list of image links.
2. Finds the image link in each row (or uses the column you name).
3. Upscales each image with Real-ESRGAN, a well-known AI upscaling model that sharpens edges and cleans up compression blur.
4. Stores every result with a public link and writes one output row per input row, keeping your own columns.

Typical uses:

• Ecommerce: small supplier photos to marketplace-ready sizes (Amazon, Etsy, Shopify zoom).
• Property and car listings: old, low-resolution listing photos made presentable.
• After a scraper: upscale every image a scraper found, straight from its dataset.
• With Bulk Image & File Downloader: download a list of images, then upscale them (use fileUrl as the link column), or chain both in one run with Actor Pipeline Runner.

Example

Input: a CSV with sku, name, price, imageUrl, each image 320 x 240.

sku	name	upscaledUrl	inputWidth	inputHeight	outputWidth	outputHeight	status
NL-2001	Stamp Mug	https://api.apify.com/v2/key-value-stores/.../upscaled-sample-lowres-mug.jpg	320	240	1280	960	upscaled
NL-2002	Glass Teapot	https://api.apify.com/v2/key-value-stores/.../upscaled-sample-lowres-teapot.jpg	320	240	1280	960	upscaled

Every output row also has sourceUrl, upscaledKey, scale, format, sizeBytes, processedInputWidth/Height, resizedToFitCap, processingSeconds, chargedLargeImageMegapixels and a plain-English statusDetail.

Pricing

Pay per event, only for what you receive:

Event	Price	When
Image upscaled	$0.015 per image (Bronze $0.0135, Silver $0.012, Gold $0.0105)	Each image upscaled and stored
Large image megapixel	$0.015 per megapixel	Each started megapixel of input above the first 1 MP (about 1000 x 1000). A 2000 x 2000 input adds 3.

Worked examples:

• 100 product photos around 600 x 600: 100 x $0.015 = $1.50.
• 1,000 photos around 800 x 600: $15 (Gold plan: $10.50).
• One 2000 x 2000 photo: $0.015 + 3 x $0.015 = $0.06 (the output is 8000 x 8000).

Never charged: rows with no link, failed or blocked downloads, links that are web pages rather than images, repeated links (they point at the first result), images skipped by Skip images at least this big, and anything beyond your run's spending limit. If your spending limit is reached, the remaining rows are marked skipped_budget and any image that could not be paid for is deleted, not kept.

Input

• File or Google Sheet URL (fileUrl), Dataset (datasetId), Image URLs (imageUrls) or Rows (data): use one.
• Link column (urlField): leave empty to detect it.
• Upscale factor (scale): 4 (default), 3 or 2.
• Output format: Auto (JPEG, or PNG when the image has transparency), JPEG, PNG or WebP. Transparency is preserved.
• Largest input (maxInputMegapixels, default 4): bigger inputs are shrunk first so a huge photo cannot produce a gigantic file or a large charge.
• Skip images at least this big (skipIfLongEdgeAtLeast): leave already-large photos alone, uncharged.
• Name files by column (fileNameField): name each file after your SKU or ID.
• Keep images in a named store (storeName): keep the files beyond the run's normal data retention.
• Max images, Max rows, download size limit and timeout.

Google Sheets: share as "Anyone with the link can view" and paste the normal link.

Speed

It runs on normal Apify CPUs (no GPU). At the default 4 GB of memory a 600 x 600 photo takes about 13 seconds and a 320 x 240 thumbnail about 3 seconds, so roughly 200 to 250 typical product photos an hour. For big batches, raise the run's memory: every 4 GB adds a CPU core and one more image processed at the same time, so 16 GB handles about four times as many photos an hour. The price per image is the same at any memory size. Long runs save each row as it finishes, so nothing is lost if a run hits its timeout (raise the timeout for very long lists).

Honest limits

• The model sharpens and cleans; it does not invent detail that was never there. Very fine textures (fabric weave, hair) can look slightly smooth. Faces are not specially restored.
• Links must point straight at an image file. A product page link returns not_an_image (not charged); use a scraper or Bulk Image & File Downloader to get the direct image links first.
• Animated GIFs: only the first frame is upscaled.
• The actor never fetches private or internal network addresses.
• Images are stored in the run's key-value store and follow your Apify plan's data retention, unless you set a named store.

For AI agents and integrations

Send rows in data or a file in fileUrl, read upscaledUrl from each output row. Pay per event via x402 and MCP; no API key needed. Works with the Apify API, n8n, Make and Zapier.

FAQ

Is this free for commercial use? Yes. The model, Real-ESRGAN general x4v3 by Xintao Wang et al., is released under the BSD-3-Clause licence, and you own your images.

Why not a heavier "generative" upscaler? Those invent new detail with a diffusion model and cost several times more per image. This one is predictable, keeps the product looking like the product, and handles whole lists.

Can I upscale only the small images in a mixed list? Yes: set Skip images at least this big to, say, 1500 px.

Did it help? If this saved you an afternoon of one-at-a-time uploads, a quick review on the Store helps a lot. Questions or a feature you need: open an issue on the Issues tab and I reply personally.

Model credit: Real-ESRGAN, Xintao Wang, Liangbin Xie, Chao Dong, Ying Shan (BSD-3-Clause).