# Bulk Image Downloader — URLs to Stored Files (`hipersoft/bulk-image-downloader`) Actor

Download thousands of images from a list of URLs and store each in the key-value store with a public link. Returns content type, size, dimensions and SHA-256 per image. Bulk-ready, no login. Great for datasets, backups and media pipelines.

- **URL**: https://apify.com/hipersoft/bulk-image-downloader.md
- **Developed by:** [hiper soft](https://apify.com/hipersoft) (community)
- **Categories:** Developer tools, Automation
- **Stats:** 12 total users, 8 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.056 / url processed

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## Bulk Image Downloader — Download Images from URLs at Scale

Bulk Image Downloader takes a list of image URLs and downloads every one, **stores each file in your run's key-value store**, and returns its **content type, size, pixel dimensions and SHA-256 hash** plus a direct link to the stored file. Export the metadata to JSON, CSV, Excel or XML. Fast and reliable, with no login or API key to run. Great for building image datasets, mirroring and backups, media pipelines and deduplicating creative assets.

![Bulk Image Downloader input — image URL list, store toggle and concurrency in the Apify Console](https://api.apify.com/v2/key-value-stores/SUfvnaFLd9z9eBCtV/records/bulk-image-downloader-input.png)

### What does the Bulk Image Downloader do?

Give it hundreds or thousands of image URLs and it fetches each one in parallel, saves the bytes to your run storage, and records a metadata row per image. The result is a clean dataset you can filter, deduplicate by hash, or wire into a downstream media pipeline.

### What data do you get per image?

| Data point | Description |
| --- | --- |
| Source | `url`, `finalUrl` |
| Status | `ok`, `error` |
| File info | `contentType`, `sizeBytes` |
| Dimensions | `width`, `height` |
| Hash | `sha256` |
| Storage | `key`, `storedUrl` |

### What you get

Each image produces one metadata row plus the stored file itself. Export the dataset to JSON, CSV, Excel or XML.

![Bulk Image Downloader output example — image rows with content type, size, dimensions and hash as structured JSON](https://api.apify.com/v2/key-value-stores/SUfvnaFLd9z9eBCtV/records/bulk-image-downloader-output.png?v=1)

```json
{
  "url": "https://example.com/a.jpg",
  "finalUrl": "https://example.com/a.jpg",
  "ok": true,
  "contentType": "image/jpeg",
  "sizeBytes": 84213,
  "width": 1200,
  "height": 800,
  "sha256": "9f86d081884c7d659a2feaa0c55ad015a3bf4f1b2b0b822cd15d6c15b0f00a08",
  "key": "image-000000-9f86d0817640.jpg",
  "storedUrl": "https://api.apify.com/v2/key-value-stores/<id>/records/image-000000-9f86d0817640.jpg",
  "error": null
}
```

#### Output schema

| Field | Type | Description |
| --- | --- | --- |
| `url` | string (URL) | The image URL you supplied. |
| `finalUrl` | string (URL) | The URL after any redirects were followed. |
| `ok` | boolean | Whether the download succeeded. |
| `contentType` | string | MIME type of the file (e.g. `image/jpeg`, `image/png`, `image/webp`). |
| `sizeBytes` | integer | File size in bytes. |
| `width` | integer | Image width in pixels, read from the file header. |
| `height` | integer | Image height in pixels, read from the file header. |
| `sha256` | string | SHA-256 hash of the file contents, useful for deduplication. |
| `key` | string | The record key of the stored file in the run's key-value store. |
| `storedUrl` | string | Direct link to the stored file in your run's key-value store. |
| `error` | string | Failure reason when a download did not succeed; empty otherwise. |

### Use cases

- Build labelled image datasets for machine learning or research.
- Mirror and back up image assets from a list of URLs.
- Deduplicate creative libraries using the SHA-256 content hash.
- Feed a media processing or thumbnailing pipeline.
- Validate that a set of image links are live and return the expected files.

### How to download images in bulk

1. Add the Bulk Image Downloader to your Apify account and open its input.
2. Paste your image URLs under `imageUrls`, one per line.
3. Set `store`, `maxBytes`, `maxConcurrency` and `maxItems` to suit your run.
4. Click **Run** and let it fetch and store every image.
5. Export the metadata dataset as JSON, CSV, Excel or XML, and download the stored files as a zip from the run's Storage tab.

### Input

```json
{
  "imageUrls": ["https://example.com/a.jpg", "https://example.com/b.png"],
  "store": true,
  "maxConcurrency": 10
}
```

| Field | Description |
| --- | --- |
| `imageUrls` | Direct image URLs, one per line. |
| `store` | Save the bytes and return a link (default on). Off = metadata only. |
| `maxBytes` | Skip images larger than this size. |
| `maxConcurrency` | Number of parallel downloads (default 10). |
| `maxItems` | Global cap on the number of images processed. |
| `proxyConfiguration` | Optional proxy settings for the run. |

### Related tools

- [Bulk URL Status Checker](https://apify.com/hipersoft/bulk-url-checker) — check thousands of links for broken status, redirects and SSL.
- [Website Contact Scraper](https://apify.com/hipersoft/website-contact-scraper) — pull emails, phones and social links from any site.
- [Website Content Crawler](https://apify.com/hipersoft/website-content-crawler) — crawl a site into clean text and discover asset URLs.
- [Wayback Machine Scraper](https://apify.com/hipersoft/wayback-machine-scraper) — list archived snapshots of a URL or domain.

### FAQ

**Do I need an account or API key?**
No API key is needed to run it. Downloaded files are saved to your run's key-value store, which you open in the Apify Console or fetch with your own API token.

**How many images can I download per run?**
As many as you supply. `maxItems` sets a global cap, `maxConcurrency` controls parallel downloads (default 10), and `maxBytes` skips files larger than a chosen size.

**What export formats are supported?**
A JSON/CSV/Excel/XML dataset with one metadata row per image, plus the stored files themselves. Bulk-download the whole store as a zip from the run's Storage tab.

**Can I filter or limit results?**
Yes. Use `maxItems`, `maxBytes` and `maxConcurrency`, and set `store` to false to return metadata only without saving the bytes.

**How does billing work?**
You pay per item you get, so cost scales with the number of images you actually process. See the **Pricing** tab for current rates.

**Can I connect this to other tools?**
The Bulk Image Downloader can be connected with almost any cloud service or web app thanks to [integrations on the Apify platform](https://apify.com/integrations). It works with [Make](https://apify.com/integrations/make), [Zapier](https://apify.com/integrations/zapier), [Slack](https://docs.apify.com/platform/integrations/slack), [Airbyte](https://docs.apify.com/platform/integrations/airbyte), [GitHub](https://docs.apify.com/platform/integrations/github), [Google Drive](https://docs.apify.com/platform/integrations/drive) and [many more](https://apify.com/integrations), plus the [Apify API](https://docs.apify.com/api/v2), JavaScript/Python clients and MCP. Or use [webhooks](https://docs.apify.com/platform/integrations/webhooks) to trigger an action whenever a run finishes.

**Is bulk image downloading legal?**
Only download images you have the right to use. You are responsible for the copyright and terms of the sources.

### Related Actors

- [Bulk URL Status Checker](https://apify.com/hipersoft/bulk-url-checker)
- [Website Contact Scraper](https://apify.com/hipersoft/website-contact-scraper)
- [Website Content Crawler](https://apify.com/hipersoft/website-content-crawler)
- [Wayback Machine Scraper](https://apify.com/hipersoft/wayback-machine-scraper)

### Notes

Original clean-room implementation. Files are saved to your run's key-value store and are private to your account, as with all Apify runs. Only download images you have the right to use.

# Actor input Schema

## `imageUrls` (type: `array`):

Direct image URLs to download (jpg, png, gif, webp, svg, …). One per line.

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

Alternative field name for the same list of image URLs.

## `store` (type: `boolean`):

Save each downloaded image in the key-value store and return a public link. Turn off to only collect metadata (type/size/dimensions/hash) without storing bytes.

## `maxBytes` (type: `integer`):

Skip images larger than this (bytes).

## `maxConcurrency` (type: `integer`):

How many images to download in parallel.

## `maxItems` (type: `integer`):

Cap total images processed (0 = all).

## `proxyConfiguration` (type: `object`):

Optional. Enable if a host blocks datacenter IPs.

## Actor input object example

```json
{
  "imageUrls": [
    "https://upload.wikimedia.org/wikipedia/commons/a/a9/Example.jpg"
  ],
  "store": true,
  "maxBytes": 25000000,
  "maxConcurrency": 10,
  "maxItems": 0,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# 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 = {
    "imageUrls": [
        "https://upload.wikimedia.org/wikipedia/commons/a/a9/Example.jpg"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("hipersoft/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 = { "imageUrls": ["https://upload.wikimedia.org/wikipedia/commons/a/a9/Example.jpg"] }

# Run the Actor and wait for it to finish
run = client.actor("hipersoft/bulk-image-downloader").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "imageUrls": [
    "https://upload.wikimedia.org/wikipedia/commons/a/a9/Example.jpg"
  ]
}' |
apify call hipersoft/bulk-image-downloader --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=hipersoft/bulk-image-downloader",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/7bDUJCtAwJBHVhVkm/builds/NFvpYVCojkSBwxpZb/openapi.json