# Bulk Image Downloader: All Images from Web Pages to ZIP (`humble-echidna/bulk-image-downloader`) Actor

Download all images from web pages you list, or from direct image links, into your key-value store, optionally as a ZIP. One row per image: page, image URL, alt text, width, height, type, bytes, SHA-256. Duplicates saved once; icons and tracking pixels skipped.

- **URL**: https://apify.com/humble-echidna/bulk-image-downloader.md
- **Developed by:** [Michael Costa](https://apify.com/humble-echidna) (community)
- **Categories:** Developer tools, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $7.00 / 1,000 page or image urls

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

### What does Bulk Image Downloader do?

**Bulk Image Downloader** downloads **all the images from web pages**, or from direct image links, into your own Apify
storage: the largest size each page offers, optionally packed as **ZIP files** to download in one go, plus one row per
image with its source page, alt text, size and hash.

For a page, it finds every image the page shows: `<img>` tags (the largest size in `srcset`), `<picture>` sources,
lazy-loaded images, and the page's preview image (`og:image`). It is **not** a way around copyright: download only
images you have the right to use.

**Try it in one click:** the input comes pre-filled with two direct links to public-domain photos on Wikimedia
Commons (see the example below for their licence pages). That's 2 URLs, about $0.014 (2 × $0.007, plus $0.00005
for the run start), plus the run's platform usage. **Then replace them with the pages or image links you actually
want.**

### What data does Bulk Image Downloader return?

| Field | Example | Notes |
|---|---|---|
| `imageUrl` | `https://www.python.org/static/img/python-logo.png` | The image's address. |
| `sourcePage` | `https://www.python.org/` | The page it was on; `null` for direct links. |
| `foundIn` | `img` | `img`, `srcset` (the largest size), `picture`, `og:image` or `direct`. |
| `altText` | `python™` | `null` when the page gives none. |
| `width`, `height` | `580`, `164` | Pixels, read from the file. |
| `contentType`, `bytes` | `image/png`, `15770` | The real type, read from the file itself. |
| `sha256` | `9c121e61...` | Duplicates (same bytes) are saved once. |
| `key` | `9c121e619bfe02ea-python-logo.png` | The file's name in the run's key-value store. |
| `storeUrl` | `https://api.apify.com/v2/key-value-stores/<store id>/records/...` | Downloads your saved copy. |
| `input` | `https://www.python.org/` | The input line it came from. |

One row per saved image; the files themselves are in the run's key-value store. The full list is under
[Output](#output).

### How much does it cost to download images in bulk?

You pay per URL you give it: **$7.00 per 1,000 URLs** (a page, however many images it has, or a direct image link),
plus $0.00005 each time a run starts, plus the run's Apify platform usage (compute, storage and data transfer) at
your plan's rates.

- **The example below:** 2 URLs × $0.007 = $0.014, plus the start fee, plus the run's platform usage (about 180 KB
  stored).
- **A month, for example:** 500 product pages = 500 × $0.007 = **$3.50**, plus platform usage, which grows with the
  bytes stored (large photos and the ZIP option cost more storage) and is billed at your plan's rates.
- **Caps:** **Max images per run** in the input, and **Maximum cost per run** in the run options: no URL is started
  that it doesn't cover. The run stops cleanly at whichever comes first.

**Never charged:** a URL where no image was saved: pages that fail, are blocked, have no images, or whose images are
all duplicates or filtered out. The images and ZIP files themselves aren't charged per file; storing them counts
toward platform usage, so large photos and the ZIP option (which stores each image a second time) cost more
storage.

### How to download all images from a web page

1. Open Bulk Image Downloader and click **Try for free** (or **Start** if you're signed in).
2. Put pages or direct image links in **Web pages or image URLs**, one per line.
3. Optional: set **Minimum width / height** and **Minimum file size** to skip icons, and turn on **Also save a ZIP
   file**.
4. Click **Start**, then open the **Output** tab for the rows, and the run's key-value store (**Storage**) for the
   files and ZIPs.

### Example: two public-domain images

The pre-filled input is two direct image links, both NASA photographs that are in the public domain. Their licence
pages on Wikimedia Commons say so (`{{PD-USGov-NASA}}`: "This file is in the public domain in the United States
because it was solely created by NASA"):

- [The Blue Marble, Apollo 17, 1972](https://commons.wikimedia.org/wiki/File:The_Earth_seen_from_Apollo_17.jpg)
- [Buzz Aldrin on the Moon, Apollo 11, 1969](https://commons.wikimedia.org/wiki/File:Aldrin_Apollo_11_original.jpg)

```json
{"urls": ["https://upload.wikimedia.org/wikipedia/commons/thumb/9/97/The_Earth_seen_from_Apollo_17.jpg/500px-The_Earth_seen_from_Apollo_17.jpg",
          "https://upload.wikimedia.org/wikipedia/commons/thumb/9/98/Aldrin_Apollo_11_original.jpg/500px-Aldrin_Apollo_11_original.jpg"],
 "minWidth": 100, "minHeight": 100, "minFileSizeKb": 1, "includePreviewImage": true, "createZip": false}
```

It saved both images. One row (real output from a local run on 2026-09-25; `storeUrl` points to your run's
key-value store):

```json
{
  "id": "f9e124d879181002a45939ce",
  "input": "https://upload.wikimedia.org/wikipedia/commons/thumb/9/97/The_Earth_seen_from_Apollo_17.jpg/500px-The_Earth_seen_from_Apollo_17.jpg",
  "sourcePage": null,
  "imageUrl": "https://upload.wikimedia.org/wikipedia/commons/thumb/9/97/The_Earth_seen_from_Apollo_17.jpg/500px-The_Earth_seen_from_Apollo_17.jpg",
  "foundIn": "direct",
  "altText": null,
  "width": 500,
  "height": 500,
  "contentType": "image/jpeg",
  "bytes": 82862,
  "sha256": "2075157c388887df11e7f4e1320717f5c0a38673d30c59340e3df6a059ae2f3e",
  "key": "2075157c388887df-500px-The_Earth_seen_from_Apollo_17.jpg"
}
```

Give it a web page instead and it finds every image on that page (see Output below for a page's row, with its alt
text and where on the page the image was found).

### Input

| Field | What it does |
|---|---|
| **Web pages or image URLs** | One per line: a page (all its images) or a direct image link. `https://` is added if missing. |
| Minimum width / height (pixels) | Skip images smaller than this (default 100 x 100). 0 keeps every size. |
| Minimum file size (KB) | Skip files smaller than this (default 1 KB). |
| Include the page's preview image | Also download the page's `og:image` / `twitter:image` (default on). |
| Max images per page | Look at only the first N images of each page (default: all, up to 1,000). |
| Also save a ZIP file | Pack the saved images into `images-001.zip`, `images-002.zip`, ... (default off). |
| Max images per run | Cap the total number of saved images. |

```json
{
  "urls": ["https://www.python.org/", "https://example.com/photos/sunset.jpg"],
  "minWidth": 200,
  "minHeight": 200,
  "createZip": true,
  "maxResults": 500
}
```

### Output

One row per saved image. Fields a page doesn't give are `null`.

```json
{
  "id": "20e72af68b277b1e6ea3d89e",
  "input": "https://www.python.org/",
  "sourcePage": "https://www.python.org/",
  "imageUrl": "https://www.python.org/static/img/python-logo.png",
  "finalUrl": "https://www.python.org/static/img/python-logo.png",
  "foundIn": "img",
  "altText": "python™",
  "width": 580,
  "height": 164,
  "contentType": "image/png",
  "bytes": 15770,
  "sha256": "9c121e619bfe02eaba582d7080eea46fd53ec0b50717e6794a948fada4ae8f3c",
  "key": "9c121e619bfe02ea-python-logo.png",
  "storeUrl": "https://api.apify.com/v2/key-value-stores/<store id>/records/9c121e619bfe02ea-python-logo.png",
  "scrapedAt": "2026-09-24T12:00:00Z"
}
```

- `foundIn` says where the address came from: `img`, `srcset` (the largest size), `picture`, `og:image`, or
  `direct` (a link you gave). `sourcePage` is `null` for direct links.
- `key` is the file's name in the run's key-value store: the start of its SHA-256, then its name from the URL.
  `storeUrl` downloads it.
- `id` is stable across runs for the same image address.

#### Files in the key-value store

- One file per saved image, under its `key`, with its real content type.
- With **Also save a ZIP file**: `images-001.zip`, `images-002.zip`, ..., each about 64 MB at most (a new part starts
  when one fills up), holding exactly the images in the dataset.
- `RUN_STATS`: per input, how many images were found, saved, and skipped for each reason (`duplicates`,
  `tooSmall`, `notAnImage`, `tooLarge`, `blockedByRobots`, `optedOutOfAI`, `failed`), with examples.

A run's default key-value store is unnamed, and Apify deletes unnamed stores after 7 days unless your plan keeps them
longer, so download or copy the files you want to keep.

### Run it on a schedule, or from your own code

1. Save your input as a **task** (**Save as a new task**, top right of the actor page) and add it to a
   **schedule** (Console → Schedules → **Create new**): for example weekly over a list of product pages, if you
   need fresh copies. Every run downloads, and charges for, every URL again.
2. Collect results: download the dataset as JSON, CSV or Excel; fetch the latest run's results from the API
   (`GET https://api.apify.com/v2/actor-tasks/<task id>/runs/last/dataset/items?status=SUCCEEDED&format=csv`, with
   your API token); let a webhook tell your system when a run succeeds; or connect it to Make, Zapier or n8n
   through Apify's integrations.

Files are saved in the run's own key-value store, which Apify deletes after your plan's retention period (7 days on
the free plan): download or copy what you want to keep.

#### Can I use Bulk Image Downloader from an AI agent (MCP)?

Yes, through Apify's MCP server: add `https://mcp.apify.com?tools=humble-echidna/bulk-image-downloader` to your
MCP client (or let the agent find it with the server's actor search). The agent passes pages, e.g.
`{"urls": ["https://example.com/product/1"], "maxResults": 20}`, and gets back rows with each saved image's
`storeUrl`.

### Who it's for

Shops, marketplaces and catalogue teams moving or checking product images, researchers building image sets they
have the rights to, and anyone archiving the images of pages they manage.

### Why this one?

- **Only the images you want.** Icons, spacers and 1x1 tracking pixels are skipped by a minimum width, height and
  file size you choose; an icon the page itself declares as small isn't even downloaded.
- **No duplicates.** The same picture reached through two addresses, or repeated across pages, is saved once
  (compared by its bytes, SHA-256).
- **The real file, the real type.** For responsive images it takes the largest size the page offers, not the
  thumbnail. The format is read from the file itself, not trusted from the server, so a web page served as
  "image/jpeg" is never saved as an image.
- **Useful rows, not just files.** Alt text, source page, dimensions, format, bytes and hash for every image, ready
  for a spreadsheet, a product catalogue or a dataset.
- **Polite and safe.** It identifies itself honestly (User-Agent `HumbleEchidnaApify`), follows each site's
  robots.txt (read once per site per run) and Crawl-delay, honours sites that opt out of AI crawlers in their
  robots.txt (GPTBot, CCBot, ClaudeBot, Google-Extended and the like), and only requests public web addresses on
  the standard ports (80 and 443). It never logs in or gets around blocking.
- **Reliable.** One failing page or image never affects the others. The run log and the `RUN_STATS` record say
  exactly which image was skipped and why.

### Limits

- Pages as the server sends them: images that a page only adds with JavaScript aren't seen (it doesn't run a
  browser). CSS background images aren't collected.
- Formats kept: JPEG, PNG, GIF, WebP, AVIF, BMP, TIFF and ICO. SVG files are skipped: they're documents that can
  carry scripts. HEIC/HEIF files are skipped too.
- Up to 25 MB per image, 2 GB of downloads per run, 1,000 images per page, pages up to 5 MB.
- Public web addresses on ports 80 and 443 only; no logins, no proxies, nothing behind bot protection.

### FAQ

#### Can I download any image with this?

Only images you have the right to download and use. Most images on the web are protected by copyright: check the
site's terms and the image's licence before you reuse it. The copies are saved only in your own Apify storage; this
actor doesn't publish or share them.

#### Why was an image skipped?

Check `RUN_STATS` and the run log: each skipped image is counted by reason, and the first few problems per input
are listed with the image address. A site's robots.txt or its AI opt-out can block an image even when the page
itself was allowed.

#### How long are the downloaded images kept?

They're in the run's default key-value store, which is unnamed; Apify deletes unnamed stores after 7 days unless
your plan keeps them longer. Download the files or ZIPs, or copy them, to keep them.

#### Something that used to work now fails or returns fewer images. Why?

The site may have changed its pages. The run log names the input and what went wrong, and every other input in the
run is unaffected. Please open an issue with the input you used.

#### Is it legal to download images from websites?

It fetches only the pages and image links you give it, as a logged-out visitor, and follows each site's robots.txt,
including its opt-outs for AI crawlers. It doesn't log in, get around blocking, or collect personal data about
anyone. Whether you may reuse the images is up to their owners' terms and licences, which you are responsible for
checking.

### Related actors

| Actor | Use it when |
|---|---|
| [Sitemap URL Extractor](https://apify.com/humble-echidna/sitemap-urls) | You want the list of product or article pages from a site's sitemap, with filters, to use as this actor's input. |
| [Image to Text OCR](https://apify.com/humble-echidna/image-ocr) | You want to read the text in images at public links. |

### Feedback and support

Found a bug, or a page whose images it misses? Open an issue on the **Issues** tab with the input you used.

### Versions

Current version: **1.0**. See the Changelog tab for what changed in each version.

# Changelog

This Actor's version history is a separate document: https://apify.com/humble-echidna/bulk-image-downloader/changelog.md

# Actor input Schema

## `urls` (type: `array`):

One per line. A web page (e.g. https://example.com/products/): every image on it is downloaded, from <img> tags (the largest size in srcset), <picture> sources and the page's og:image preview. Or a direct image link (e.g. https://example.com/photo.jpg): that image is downloaded. A missing https:// is added for you. Only public web addresses on ports 80 and 443; each site's robots.txt, including its opt-outs for AI crawlers, is honoured.

## `minWidth` (type: `integer`):

Skip images narrower than this many pixels: icons, spacers and 1x1 tracking pixels. 0 to 100,000, default 100; 0 keeps every size. Skipped images are not charged.

## `minHeight` (type: `integer`):

Skip images shorter than this many pixels. 0 to 100,000, default 100; 0 keeps every size. Skipped images are not charged.

## `minFileSizeKb` (type: `integer`):

Skip image files smaller than this many kilobytes: 0 to 25,600 (25 MB), default 1; 0 keeps every size. When the site states the size up front, the file isn't even downloaded. Skipped images are not charged.

## `includePreviewImage` (type: `boolean`):

Default true: also download the image the page declares for link previews (og:image or twitter:image), which is often a large version of its main picture. Set false to skip it.

## `maxImagesPerPage` (type: `integer`):

Look at no more than this many images on each web page, in page order (the preview image first), e.g. 20. 1 to 1,000; leave empty (the default) for all of them, up to 1,000 per page.

## `createZip` (type: `boolean`):

Default false. When true, also pack every saved image into ZIP files in the run's key-value store: images-001.zip, images-002.zip, ... (a new part starts at about 64 MB). The images are also saved one by one either way.

## `maxResults` (type: `integer`):

Stop after this many saved images in total, e.g. 20. Minimum 1; leave empty (the default) for no limit. Nothing past the limit is downloaded. The run also stops cleanly at the maximum cost per run you set in the run options, whichever comes first. Set it to keep a run small and quick.

## Actor input object example

```json
{
  "urls": [
    "https://upload.wikimedia.org/wikipedia/commons/thumb/9/97/The_Earth_seen_from_Apollo_17.jpg/500px-The_Earth_seen_from_Apollo_17.jpg",
    "https://upload.wikimedia.org/wikipedia/commons/thumb/9/98/Aldrin_Apollo_11_original.jpg/500px-Aldrin_Apollo_11_original.jpg"
  ],
  "minWidth": 100,
  "minHeight": 100,
  "minFileSizeKb": 1,
  "includePreviewImage": true,
  "createZip": false
}
```

# Actor output Schema

## `results` (type: `string`):

No description

## `files` (type: `string`):

No description

## `runStats` (type: `string`):

No description

# 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 = {
    "urls": [
        "https://upload.wikimedia.org/wikipedia/commons/thumb/9/97/The_Earth_seen_from_Apollo_17.jpg/500px-The_Earth_seen_from_Apollo_17.jpg",
        "https://upload.wikimedia.org/wikipedia/commons/thumb/9/98/Aldrin_Apollo_11_original.jpg/500px-Aldrin_Apollo_11_original.jpg"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("humble-echidna/bulk-image-downloader").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 = { "urls": [
        "https://upload.wikimedia.org/wikipedia/commons/thumb/9/97/The_Earth_seen_from_Apollo_17.jpg/500px-The_Earth_seen_from_Apollo_17.jpg",
        "https://upload.wikimedia.org/wikipedia/commons/thumb/9/98/Aldrin_Apollo_11_original.jpg/500px-Aldrin_Apollo_11_original.jpg",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("humble-echidna/bulk-image-downloader").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 '{
  "urls": [
    "https://upload.wikimedia.org/wikipedia/commons/thumb/9/97/The_Earth_seen_from_Apollo_17.jpg/500px-The_Earth_seen_from_Apollo_17.jpg",
    "https://upload.wikimedia.org/wikipedia/commons/thumb/9/98/Aldrin_Apollo_11_original.jpg/500px-Aldrin_Apollo_11_original.jpg"
  ]
}' |
apify call humble-echidna/bulk-image-downloader --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,humble-echidna/bulk-image-downloader"
        }
    }
}
```

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/HYuYaMROETaoWzJz5/builds/9jkZ2WFbUbxw4bJSP/openapi.json