# All Image Scraper (`agentx/all-image-scraper`) Actor

All-in-one image search and download for Google, Bing, Yahoo, Brave, and Yandex: search by keyword, download public images, and store byte-exact originals or JPEG/PNG/WebP conversions with raw search evidence and 22-field metadata.

- **URL**: https://apify.com/agentx/all-image-scraper.md
- **Developed by:** [AgentX](https://apify.com/agentx) (community)
- **Categories:** Developer tools, SEO tools, Automation
- **Features:** Limited permissions
- **Stats:** 5 total users, 1 monthly users, 100.0% runs succeeded, 2 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

**All Image Scraper is an image search downloader that searches Google, Bing, Yahoo, Brave, and Yandex for one keyword — one engine or several in the same run — and returns the image files themselves, byte-exact originals or JPEG, PNG, and WebP copies, with 36 documented fields per row.** Give it one keyword, the engines to read, one output format, and a per-engine result count instead of building a separate search, download, conversion, and provenance pipeline.

[![Apify Users](https://img.shields.io/badge/dynamic/json?url=https%3A%2F%2Fapi.apify.com%2Fv2%2Facts%2Fagentx~all-image-scraper\&query=%24.data.stats.totalUsers\&style=for-the-badge\&label=Apify%20Users\&color=ff9013)](https://apify.com/agentx/all-image-scraper) [![Apify Runs](https://img.shields.io/badge/dynamic/json?url=https%3A%2F%2Fapi.apify.com%2Fv2%2Facts%2Fagentx~all-image-scraper\&query=%24.data.stats.totalRuns\&style=for-the-badge\&label=Apify%20Runs\&color=ff9013)](https://apify.com/agentx/all-image-scraper) [![$0.00400 per image](https://img.shields.io/badge/%240.00400%20%2F%20image-4285f4?style=for-the-badge)](https://apify.com/agentx/all-image-scraper/pricing) [![5 search engines](https://img.shields.io/badge/5%20search%20engines-34a853?style=for-the-badge)](https://console.apify.com/actors/agentx~all-image-scraper/input) [![API + MCP ready](https://img.shields.io/badge/API%20%2B%20MCP%20ready-fbbc05?style=for-the-badge)](https://apify.com/agentx/all-image-scraper/api)

- **Five search engines in one input contract, selectable together.** Pick any combination of Google, Bing, Yahoo, Brave, and Yandex while keeping the same Dataset shape. Google, Bing, Yahoo, and Yandex follow available next-result links; Brave uses the results returned by its initial search page.
- **The original bytes and the converted copy are both stored and both hashed.** Select Original to keep the source file untouched, or request JPEG, PNG, or WebP and receive the conversion beside the preserved original. Images above 12 megapixels (width × height greater than 12,000,000) are skipped in every format.
- **Thirty-six documented fields per image.** Source description, publisher, creator credits, alternate variants, original and output dimensions, animation frame counts, byte sizes, SHA-256 hashes, rank, keyword, and processing provenance travel in one row.
- **Four verifiable artifact roles per successful image row.** Every successful image row links to the stored original image, the selected output, a per-image JSON metadata record, and the stored raw search response. In Original mode the first two roles reuse one byte-exact file.

The smallest useful run is one published image: one Actor Start plus one result costs **$0.01400** on the FREE tier, and a 10-image run costs **$0.05000**. These calculations use the Actor's fixed 1 GB memory setting.

***

### Why Choose All Image Scraper

**One request produces files instead of URL-only search metadata.** Each accepted search result is downloaded, decoded, and stored in its original byte representation. The Actor either returns those exact bytes or creates the requested JPEG, PNG, or WebP copy and links everything from one Dataset row.

**Five engines share one normalized result contract.** Changing `platforms` changes the search sources without changing the 36 output keys, so a pipeline can compare engines side by side in one run. Selected engines are searched concurrently. A matching source image URL found by several engines is delivered and billed once; the first accepted result determines its `platform`. Google, Bing, Yahoo, and Yandex follow available continuation links, while Brave uses its initial returned result set. Source availability, usable files, and the run's time and spending limits can reduce the delivered count.

**Content and provenance stay connected.** `source_url` identifies the external image location, `original_url` points to the stored original, `image_url` points to the selected output, and `raw_url` preserves the search response that produced the candidate. In Original mode, both artifact URLs and both SHA-256 values match.

**Output handling is explicit and independently checkable.** `output_format` records the decoded output format, not merely a filename extension, and `output_width`, `output_height`, and `output_frames` describe the file that was actually written. Original mode preserves bytes and format; JPEG composites transparency onto white, while PNG and WebP retain alpha. A conversion keeps the first frame of an animation and says so through `original_frames` and `output_frames` rather than pretending animation survived.

**A successful image row is counted only when every artifact exists.** `max_results` counts published rows per selected engine, not attempts: a row exists only after the original, the selected output, the JSON metadata, and the raw search response are all stored, so a candidate that cannot be downloaded or decoded is skipped rather than billed. A confirmed empty source returns one `not_found` row with null image facts; that row is pushed to the Dataset without a result charge. That keeps agent calls and cost calculations tied to files you actually received.

***

### Quick Start Guide

#### Step 1: Configure the search

[Open the Actor input](https://console.apify.com/actors/agentx~all-image-scraper/input). Enter one `keyword`, select one or more engines in `platforms`, select one `format`, and set `max_results`. All four fields are required. The form prefills are `red panda wildlife`, `["bing"]`, `webp`, and `1`; an API request must supply all four fields.

#### Step 2: Run the Actor

Click **Start**. The Actor searches the selected engines concurrently and publishes only images whose required files were saved successfully. A source host that rejects a download is skipped rather than represented as a successful image.

#### Step 3: Collect the artifacts

Open the default Dataset for one row per delivered image, plus an uncharged `not_found` row for any confirmed empty source. A useful image result has `status: "success"` and a non-null `image_url`. Use `original_url` for the byte-exact source file, `image_url` for the Original, JPEG, PNG, or WebP output, `metadata_url` for the per-image JSON record, and `raw_url` to inspect the stored search response. An empty Dataset means no rows were persisted; inspect the run status and log before retrying.

***

### Input Parameters

All Image Scraper requires exactly four inputs in schema order: one keyword, one or more of five search engines, one of four output formats, and how many images to return from each engine.

| Parameter     | Type          | Required | Description                                                                                                                                                                                                     | Example              |
| ------------- | ------------- | -------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------- |
| `keyword`     | string        | Yes      | Public image-search phrase of 200 characters or fewer                                                                                                                                                           | `red panda wildlife` |
| `platforms`   | array of enum | Yes      | One or more of `google`, `bing`, `yahoo`, `brave`, `yandex`; selected engines run concurrently                                                                                                                      | `["bing"]`           |
| `format`      | enum          | Yes      | One of 4 outputs: `original`, `jpeg`, `png`, `webp`                                                                                                                                                             | `webp`               |
| `max_results` | integer       | Yes      | Number of successfully downloaded output images per selected engine; minimum `1`, no upper bound                                                                                                                | `1`                  |

The shared example used throughout this page is:

```json
{
  "keyword": "red panda wildlife",
  "platforms": ["bing"],
  "format": "webp",
  "max_results": 1
}
```

A run uses one output format and any combination of the five engines. `max_results` is each selected engine's budget rather than the run total, so three engines at 10 can return up to 30 images. The input has no fixed maximum, but it is a requested quantity, not a delivery guarantee. Source exhaustion, duplicate URLs, unavailable files, storage failures, and time or spending limits can reduce the result count. There is no engine-specific configuration object.

The default run time limit is one hour. Increasing `max_results` does not extend that limit.

| Engines | Search depth | Scope of `max_results` |
| --- | --- | --- |
| Google, Bing, Yahoo, Yandex | Follow available native continuation links until the requested quantity or a source/run boundary is reached | Per selected engine |
| Brave | Read the result set returned by the initial search page; no further search page is requested | Per selected engine, limited by that returned set |

All engines support the same keyword, format, and quantity inputs. They expose different source metadata and candidate sets, and response times vary. The Actor offers no additional country, language, safe-search, license, size, or colour filter.

***

### Output Data Schema

Every complete Dataset row has 36 public fields, including `platform`, `rank`, `publisher`, `creators`, `variants`, artifact links, and file facts. The four public input fields are `keyword`, `platforms`, `format`, and `max_results`.

Source and outcome fields include `source_name` (engine display name), `source_domain` (reported content domain), `source_crawled_at` (reported crawl instant), `search_position` (source result position), `is_family_friendly` (source classification), and `status`. Nested `variants` contain `url`, `width`, `height`, and `bytes`. `processor` identifies the Actor; `processed_at` uses UTC seconds with `+00:00`, for example `2026-10-31T04:30:00+00:00`. A reported publisher display name is preserved. If `publisher` is null and `source_domain` is present, the domain fills `publisher` while `source_domain` remains available.

One Dataset row represents one image that was successfully downloaded, decoded, stored, and either preserved byte-exactly or converted; the complete row contains 36 fields. A source confirmed to contain no matching images returns one uncharged `not_found` row with null image facts; other rows have `status` equal to `success`.

Search-result context, exactly as the engine reported it:

| Field         | Type            | Meaning                                                                                                    |
| ------------- | --------------- | ---------------------------------------------------------------------------------------------------------- |
| `platform`    | string          | Search engine used                                                                                         |
| `keyword`     | string          | Search keyword used for this run                                                                           |
| `rank`        | integer or null | Delivered position within this run, starting at 1                                                          |
| `title`       | string or null  | Image title exposed by the search result                                                                   |
| `description` | string or null  | Image caption or description from the search-result record                                                 |
| `publisher`   | string or null  | Reported publisher display name; if null, uses `source_domain` when available                              |
| `creators`    | array or null   | Creator credits reported by the source; not a license determination                                        |
| `variants`    | array or null   | Alternate copies of the same image reported by the source, each with `url`, `width`, `height`, and `bytes` |

External links the engine exposed, then the four artifacts this run stored:

| Field           | Type           | Meaning                                                 |
| --------------- | -------------- | ------------------------------------------------------- |
| `search_url`    | string or null | Engine search URL for the keyword                       |
| `source_url`    | string or null | External original URL exposed by the engine             |
| `page_url`      | string or null | Associated external page when available                 |
| `thumbnail_url` | string or null | Search-result thumbnail when available                  |
| `raw_url`       | string or null | Stored raw search response                              |
| `original_url`  | string or null | Stored byte-exact original image                        |
| `image_url`     | string or null | Selected output; equals `original_url` in Original mode |
| `metadata_url`  | string or null | Stored per-image JSON metadata                          |

Decoded file properties measured on the stored files, and processing provenance:

| Field             | Type            | Meaning                                                     |
| ----------------- | --------------- | ----------------------------------------------------------- |
| `original_format` | string or null  | Decoded original format                                     |
| `output_format`   | string or null  | Verified selected output format                             |
| `width`           | integer or null | Original width in pixels                                    |
| `height`          | integer or null | Original height in pixels                                   |
| `output_width`    | integer or null | Output width after orientation correction                   |
| `output_height`   | integer or null | Output height after orientation correction                  |
| `original_frames` | integer or null | Frame count of the original file                            |
| `output_frames`   | integer or null | Frame count of the output; conversions keep the first frame |
| `original_bytes`  | integer or null | Original file size                                          |
| `output_bytes`    | integer or null | Selected output size                                        |
| `original_sha256` | string or null  | SHA-256 of original bytes                                   |
| `output_sha256`   | string or null  | SHA-256 of selected output bytes                            |
| `processor`       | string          | Existing AgentX provenance URL, preserved unchanged         |
| `processed_at`    | string          | UTC processing timestamp, seconds with `+00:00`             |

Additional source and outcome fields:

| Field                | Type            | Meaning                                                                           |
| -------------------- | --------------- | --------------------------------------------------------------------------------- |
| `source_name`        | string          | Search engine display name                                                        |
| `source_domain`      | string or null  | Reported content domain, retained unchanged when used as the `publisher` fallback |
| `source_crawled_at`  | string or null  | Brave-reported UTC crawl instant with `Z`; not this row's processing time         |
| `search_position`    | integer or null | One-based source position reported by Yandex; separate from `rank`                |
| `is_family_friendly` | boolean or null | Brave's reported family-friendly classification                                   |
| `status`             | string          | `success` for a saved image; uncharged `not_found` for a confirmed empty source   |

Illustrative partial example — 16 of the row's 36 fields are shown; creator and variant arrays contain one example each:

```json
{
  "platform": "bing",
  "keyword": "red panda wildlife",
  "rank": 1,
  "title": "Red panda in a forest",
  "publisher": "Wikipedia",
  "creators": ["Ganga Raj Sunuwar"],
  "variants": [
    {
      "url": "https://example.org/media/red-panda.jpg",
      "width": 1920,
      "height": 1080,
      "bytes": 524288
    }
  ],
  "source_url": "https://example.org/media/red-panda.jpg",
  "raw_url": "https://api.apify.com/v2/key-value-stores/example/records/raw-search.html",
  "original_url": "https://api.apify.com/v2/key-value-stores/example/records/original-image.jpg",
  "image_url": "https://api.apify.com/v2/key-value-stores/example/records/converted-image.webp",
  "metadata_url": "https://api.apify.com/v2/key-value-stores/example/records/image-metadata.json",
  "original_format": "jpeg",
  "output_format": "webp",
  "original_sha256": "a3c1d4492f7129907dbd7713a7a447e86214ec8abbe057bbf20d66a8e83f62c7",
  "processed_at": "2026-10-29T04:30:00+00:00"
}
```

An engine may omit `title`, `description`, `publisher`, `creators`, `variants`, `page_url`, or `thumbnail_url`; those values stay null, except that a null `publisher` uses the reported `source_domain` when available. Dataset rows export through Apify as JSON, CSV, Excel, XML, RSS, or HTML, while the binary artifacts remain available through their row URLs.

***

### Integration Examples

Use Actor ID `3Ch1tNXnU3e0hHagy` with the same one-image Bing input in each example. The SDK clients handle starting the Actor and waiting for the run.

#### Actor ID

`3Ch1tNXnU3e0hHagy` — alternatively, use `agentx/all-image-scraper`.

#### HTTP API

Set `APIFY_TOKEN`, then run this command to receive Dataset items directly:

```bash
curl --request POST \
  "https://api.apify.com/v2/actors/3Ch1tNXnU3e0hHagy/run-sync-get-dataset-items" \
  --header "Authorization: Bearer $APIFY_TOKEN" \
  --header "Content-Type: application/json" \
  --data '{"keyword":"red panda wildlife","platforms":["bing"],"format":"webp","max_results":1}'
```

#### Python

Using the [Apify Python client](https://docs.apify.com/api/client/python/docs):

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")
run_input = {
    "keyword": "red panda wildlife",
    "platforms": ["bing"],
    "format": "webp",
    "max_results": 1,
}

run = client.actor("3Ch1tNXnU3e0hHagy").call(run_input=run_input)
if run is not None:
    for item in client.dataset(run.default_dataset_id).iterate_items():
        print(item)
```

#### JavaScript

Using the [Apify JavaScript client](https://docs.apify.com/api/client/js/docs):

```javascript
import { ApifyClient } from "apify-client";

const client = new ApifyClient({ token: "YOUR_APIFY_TOKEN" });
const run = await client.actor("3Ch1tNXnU3e0hHagy").call({
  keyword: "red panda wildlife",
  platforms: ["bing"],
  format: "webp",
  max_results: 1,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### Make.com

Add **Apify → Run an Actor**, enter `3Ch1tNXnU3e0hHagy`, and paste the four-field input from this page. Set **Run synchronously: Yes**, then use **Get Dataset Items** with the returned Dataset ID. For longer runs, use the asynchronous **Watch Actor Runs** flow in [Apify's Make guide](https://docs.apify.com/integrations/make).

#### n8n

Add **Apify → Run Actor**, select `3Ch1tNXnU3e0hHagy`, paste the four-field JSON into **Custom input**, and enable **Wait for finish**. Follow it with **Get Dataset Items**, using the returned `defaultDatasetId`. See [Apify's n8n integration guide](https://docs.apify.com/integrations/n8n).

#### MCP

Connect to the authenticated [Apify MCP server](https://docs.apify.com/mcp), select `agentx/all-image-scraper`, and supply the same four-field input. With `call-actor`, use the returned Dataset ID with `get-dataset-items`; if the run is still active, check it with `get-actor-run` before reading its results.

**Run outcomes:** SDK `call()` waits for completion. The HTTP sync endpoint has a 300-second connection limit, and clients may time out sooner; the run can continue and incur charges, so check the existing run before retrying. For failed, timed-out, or aborted runs, inspect the run log and any partial results. An empty Dataset contains no persisted rows; uncharged `not_found` rows have null image links. Use `image_url` from rows with `status: "success"`.

***

### Pricing

On the FREE tier each published image costs $0.00400, every run starts with $0.01000 of Actor Start, and the smallest useful one-image run totals $0.01400.

| Plan     | Actor Start per run | Result: one published image |
| -------- | ------------------: | --------------------------: |
| FREE     |            $0.01000 |                    $0.00400 |
| BRONZE   |            $0.01000 |                    $0.00360 |
| SILVER   |            $0.01000 |                    $0.00320 |
| GOLD     |            $0.01000 |                    $0.00300 |
| PLATINUM |            $0.01000 |                    $0.00300 |
| DIAMOND  |            $0.01000 |                    $0.00300 |

Actor Start is billed at $0.01000 per gigabyte of run memory with a one-event minimum, and this Actor is fixed at 1 GB, so every run begins with 1 × $0.01000 = $0.01000 whatever it returns. A one-image FREE run is `$0.01000 + 1 × $0.00400 = $0.01400`; a 10-image run is `$0.01000 + 10 × $0.00400 = $0.05000`.

Because Actor Start is a fixed cost and results are not, one larger run is materially cheaper per image than many small ones: 100 images in a single FREE run cost `$0.01000 + 100 × $0.00400 = $0.41000`, which is $0.00410 per image against $0.01400 for a single-image run. Failed candidates do not create result rows. The result event is tied to successfully saved images; confirmed `not_found` rows are delivered without a result charge. Prices can change; confirm the current amounts on the [Pricing page](https://apify.com/agentx/all-image-scraper/pricing).

***

### Use Cases

**Build a traceable image dataset.** Search a subject on multiple engines in separate runs, download `original_url`, group rows by `keyword`, and deduplicate exact files with `original_sha256`. Keep `source_url`, `publisher`, and `raw_url` beside the asset for provenance review.

**Prepare assets for a fixed media pipeline.** Choose `original` for byte-exact preservation, `webp` for compact delivery, `png` when transparency matters, or `jpeg` for broad compatibility, then filter on `output_width`, `output_height`, and `output_bytes` before the next stage. Downstream jobs consume `image_url` without maintaining their own encoder.

**Compare visual coverage across engines.** Run the same keyword on Google, Bing, Yahoo, Brave, and Yandex. Compare `source_url`, `title`, and hashes to see which engine surfaces unique files and which ones converge on duplicates.

**Collect creative references with attribution to check.** Search a campaign theme, product style, destination, or editorial concept, then read `publisher`, `creators`, and `page_url` to find the party whose licensing terms actually apply before an asset is used.

**Pick the largest available copy of an image.** Where the engine reports alternates, `variants` lists each one with its reported width, height, and byte size, so a job can select a resolution instead of accepting whichever URL the result page happened to expose.

**Monitor search-result changes.** Schedule the same four-field input and compare `original_sha256`, `source_url`, and `rank` between runs. New hashes represent new bytes even when titles or source pages look similar.

***

### Alternatives

Manual image search is appropriate when you need only one or two files and want to review licensing, context, and creator attribution before saving anything. It becomes inefficient when the task also requires storing originals, converting formats, hashing files, and maintaining structured provenance.

The search engines' own image interfaces are the best choice for interactive exploration, visual refinement, and built-in filters. Choose [Google Images](https://images.google.com/), [Bing Images](https://www.bing.com/images/search?q=red%20panda%20wildlife), [Yahoo Search](https://search.yahoo.com/), [Brave Image Search](https://search.brave.com/images?q=red+panda+wildlife), or [Yandex Images](https://yandex.com/images/search?text=red+panda+wildlife) directly when a human will inspect every candidate and automation is unnecessary.

An official search API is preferable when its supported engine, quota, filters, and metadata contract exactly match the project and downloading the image bytes is out of scope. A stock-media library is preferable when verified reuse rights and curated commercial licensing matter more than open-web coverage. A webpage image crawler is preferable when the input is a known site or URL list rather than a search keyword.

Choose something else if you need private-account media, paywalled or locked assets, reverse-image matching, facial recognition, OCR, license adjudication, safe-search or size and colour facets, a guaranteed image count from any engine, or guaranteed availability from an external image host.

***

### Limits and Troubleshooting

- **Fewer images than `max_results` → inspect source coverage and file availability.** An engine can exhaust its results; another selected engine may have already delivered a matching URL. An external file may also be unavailable, invalid, or fail to save. Time or spending limits can stop a run. Check the run status and the default key-value store's `collection-report` before adjusting the input or retrying.
- **Brave stops before a large requested quantity → its initial returned set is exhausted.** This Actor does not request another Brave search page. Add another engine when you need broader coverage; the extra source may overlap with images already delivered.
- **No rows → check `collection-report` for the cause.** The search or candidate files may be unavailable, or every image may exceed the 12-megapixel limit. Review the reported scope before retrying with another keyword or engine.
- **`title`, `description`, `publisher`, `creators`, or `variants` is null → the engine did not report that value.** A null `publisher` means neither a display name nor `source_domain` was reported. Only Yandex currently reports alternate `variants`, and creator credits appear only where the engine publishes them. Use `source_url`, `original_url`, and `raw_url`; the Actor does not invent missing source values.
- **A JPEG has a white background → the source contained transparency.** JPEG has no alpha channel, so transparent pixels are composited onto white. Select PNG or WebP to retain transparency.
- **`output_frames` is 1 while `original_frames` is higher → an animation was converted.** Conversions write the first frame only. Select `original` when the animation itself must survive.
- **The converted byte size is larger → encoding goals differ by format.** PNG can be larger than JPEG or WebP for photographic content. Choose the format that matches downstream compatibility and transparency requirements.
- **Repeated-looking files remain → visual similarity is not byte identity.** The hashes identify exact duplicate bytes, not crops, recompressions, or resized versions. Use a perceptual-hash step downstream when visual deduplication is required.

For a reproducible defect, open an [Issue](https://apify.com/agentx/all-image-scraper/issues) and include the run ID, exact four-field input, affected rank, and which artifact URL failed.

***

### Trust and Reliability

The Actor publishes a successful image row only after the external file has been downloaded, decoded, and stored. Converted modes are decoded again after encoding and the written format is verified against the request; Original mode instead confirms that the stored output bytes, size, format, and hash match the source file. A confirmed empty source produces an uncharged `not_found` row with null image facts.

Every completed row follows the same 36-field Dataset contract. `original_bytes`, `output_bytes`, `original_sha256`, and `output_sha256` let consumers verify the stored files independently; `processed_at` and `processor` identify when and where the row was produced.

Binary files and raw responses are linked from the Dataset and stored through Apify's platform storage. Apify documents [Datasets](https://docs.apify.com/storage/dataset) as structured append-only result storage and [key-value stores](https://docs.apify.com/storage/key-value-store) as storage for records such as files and JSON, so the output separates queryable rows from downloadable artifacts.

Only public search results and publicly retrievable external files are in scope. The Actor does not request search-engine account credentials, fabricate source values, or claim that a search result grants reuse rights.

***

### Legal and Compliance

**Public-data scope.** The Actor works with public image-search results and public external image URLs. It does not access private accounts, bypass paywalls, defeat locked-media controls, or authenticate as the user on a source platform.

**Copyright and reuse.** A result's presence in image search is not permission to reuse it, and the `publisher` and `creators` fields are what the engine reported rather than a rights determination. [Microsoft Support](https://support.microsoft.com/en-us/bing/filter-images-by-license-type) explains Bing's license filter and states that the originating site must still be checked for the actual license; verify the original page, creator, license, and intended use before publishing or redistributing any file.

**Privacy and terms.** Use the Actor only for lawful purposes consistent with applicable privacy rules, the relevant search engine's terms, the external publisher's terms, and Apify's platform policies. Avoid collecting or distributing sensitive personal imagery without a valid legal basis.

***

### Frequently Asked Questions

#### How do I download images by keyword?

Enter the phrase in `keyword`, choose one or more engines in `platforms`, choose `original`, `jpeg`, `png`, or `webp` in `format`, set `max_results` to how many images you want from each engine, and start the run. Each successful Dataset row links to the stored original and the selected output.

#### Can I convert image search results to PNG WebP or JPEG?

Yes. Set `format` to `png`, `webp`, or `jpeg` for a converted copy, or `original` to return the byte-exact source through both artifact fields. The written file is decoded again and `output_format`, `output_width`, `output_height`, and `output_frames` describe what was actually produced.

#### Is there a free image search API?

The Actor can be tested with Apify account credits, but it is not an unlimited free API. FREE-tier billing is $0.01000 of Actor Start per run plus $0.00400 for each published image row.

#### Can I schedule runs to monitor image results over time?

Yes. Save the input as an Apify task, attach a schedule, and compare `rank`, `source_url`, and the two SHA-256 fields across Dataset snapshots.

#### How many images does one run return?

`max_results` is a per-engine request with a minimum of 1 and no fixed input maximum. Three engines at 10 can deliver up to 30 images. Google, Bing, Yahoo, and Yandex follow available continuation links; Brave uses its initial returned set. Duplicate URLs, source exhaustion, unavailable files, and time or spending limits can reduce the count. Compare the delivered count with your input and inspect `collection-report` for source outcomes and omissions.

#### Which search engines and formats are supported?

Five engines and four formats: Google, Bing, Yahoo, Brave, and Yandex; Original, JPEG, PNG, and WebP. A run selects one format and any combination of the engines. Matching source image URLs found by several selected engines are delivered once.

#### Does every row include a full-resolution original?

Every successful image row includes the exact bytes downloaded from the external `source_url`, but the source server decides what resolution that URL returns. Where the engine reports alternates, `variants` lists their reported dimensions and byte sizes so a larger copy can be chosen deliberately. The Actor does not upscale an image or promise that a search index points to the publisher's largest file.

#### Can it access private, paid, or locked images?

No. Only public search results and publicly retrievable external image URLs are supported. The Actor does not infer hidden media addresses, reuse protected signatures, or bypass access controls.

#### Why can some search metadata fields be empty?

An engine can omit a reliable one-to-one mapping for `title`, `description`, `publisher`, `creators`, `variants`, `page_url`, or `thumbnail_url`. Those fields stay null, except that a null `publisher` uses the reported `source_domain` when available; the original file, selected output, raw response, source URL, dimensions, sizes, and hashes remain available.

***

### Related AgentX Actors

- **[Google Keyword Trends](https://apify.com/agentx/google-keyword-trends)** — compare demand for a keyword before using it as this Actor's `keyword`.
- **[All Video Scraper](https://apify.com/agentx/all-video-scraper)** — extend research from still images to public video metadata using the same topic.
- **[All Shopping Scraper](https://apify.com/agentx/all-shopping-scraper)** — follow image-led product research with product listings, prices, and marketplace records.

Browse more tools on the [AgentX page](https://apify.com/agentx).

***

### Support and Community

Ask about image search, original-file storage, per-image metadata, or format conversion in the [AgentX community on Telegram](https://t.me/Apify_Actor); for a reproducible bug, open an Issue with the run ID and the exact input.

AgentX is an Arcyton brand — [arcyton.com](https://arcyton.com).

**Last Updated:** October 31, 2026

# Actor input Schema

## `keyword` (type: `string`):

Enter one public image-search phrase. Every engine you select is searched with that phrase exactly as typed, and the run returns as many successfully downloaded output images as 'max_results' asks for from each of them.

## `platforms` (type: `array`):

Choose one or more of Google, Bing, Yahoo, Brave, and Yandex. Selected engines are searched concurrently, and each row identifies its engine. Results depend on each engine's coverage and which image files can be downloaded.

## `format` (type: `string`):

Choose Original to keep the source bytes unchanged, or JPEG, PNG, or WebP for a converted copy delivered beside the untouched original. Images above 12 megapixels are skipped in every mode.

## `max_results` (type: `integer`):

How many successfully saved images to return from each selected engine. The minimum is 1, with no input maximum. Engines can return fewer usable images than requested; an image found by multiple engines is delivered once.

## Actor input object example

```json
{
  "keyword": "red panda wildlife",
  "platforms": [
    "bing"
  ],
  "format": "webp",
  "max_results": 1
}
```

# Actor output Schema

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

One successfully saved image per charged result row; a confirmed empty source returns an uncharged not_found row with null image facts.

# 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 = {
    "keyword": "red panda wildlife",
    "platforms": [
        "bing"
    ],
    "format": "webp",
    "max_results": 1
};

// Run the Actor and wait for it to finish
const run = await client.actor("agentx/all-image-scraper").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 = {
    "keyword": "red panda wildlife",
    "platforms": ["bing"],
    "format": "webp",
    "max_results": 1,
}

# Run the Actor and wait for it to finish
run = client.actor("agentx/all-image-scraper").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 '{
  "keyword": "red panda wildlife",
  "platforms": [
    "bing"
  ],
  "format": "webp",
  "max_results": 1
}' |
apify call agentx/all-image-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,agentx/all-image-scraper"
        }
    }
}
```

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/3Ch1tNXnU3e0hHagy/builds/xBhPzyyfmU90C7MXr/openapi.json