# 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
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 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?

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

**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 30 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, four of them reading past the first result window.** Pick any combination of Google, Bing, Yahoo, Brave, and Yandex while keeping the same Dataset shape; Brave answers from one 200-result window and the other four keep requesting deeper windows until the request is filled.
- **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.
- **Thirty 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 row.** Every 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.04400** on the FREE tier, and a 10-image run costs **$0.08000**.

***

### 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, and depth is not capped at the first page.** Changing `platforms` changes the search sources without changing the 30 output keys, so a pipeline can compare engines side by side in one run — every row records the engine that produced it — or run a fallback strategy without maintaining five result parsers of its own. Selected engines are read one after another, and an image two of them both surface is downloaded and billed once, against whichever engine reached it first. Google, Bing, Yahoo, and Yandex request successive result windows until the run has what it asked for; Brave is the one engine with no second window, and it is also the widest single window of the five at 200 results. Google is the slow one: across 20 measured requests on 2026-09-02 a Google window answered in a median of 64 seconds, while Bing, Yahoo, and Yandex answered in a median of 2 to 3 seconds.

**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 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. 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 and arrive prefilled with the tested `red panda wildlife`, `["bing"]`, `webp`, and `1` example.

#### Step 2: Run the Actor

Click **Start**. The Actor searches each selected engine in turn, examines candidate image URLs, and publishes only files it can download, decode, store, and convert 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. 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.

***

### 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; a longer phrase is rejected before the run starts | `red panda wildlife` |
| `platforms` | array of enum | Yes | One or more of 5 values: `google`, `bing`, `yahoo`, `brave`, `yandex`. Four of the five read deeper result windows on request; a Google window takes about a minute to answer, the other four answer in seconds | `["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 return up to 30 rows, and it carries no ceiling — each engine's own supply of usable candidates is the real limit, and the run reports how many images it delivered against how many were requested. There is no engine-specific configuration object.

How deep a request can go is the one behavior that differs by engine:

| Engine | Candidates in one window | Deeper windows | New images the next window added, over five keywords | Median request time |
| --- | ---: | --- | ---: | ---: |
| `google` | 100 | yes | 77-94 | 64 s |
| `bing` | 35 | yes | 21-28 | 2.4 s |
| `yahoo` | 60 | yes | 39-60 | 2.6 s |
| `yandex` | 30 | yes | 18-30 | 3.0 s |
| `brave` | 200 | no | none | 2 s |

Those figures come from 20 paged requests per engine across five keywords on 2026-09-02, counting only images that had not already appeared. Brave is the only one of the five with no second window, so 200 candidates is where a Brave run stops however large `max_results` is; two full Brave scans of that window saved 198 and 199 files.

***

### Output Data Schema

One Dataset row represents one image that was successfully downloaded, decoded, stored, and either preserved byte-exactly or converted; the complete row contains 30 fields.

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

| Field | Type | Meaning |
| --- | --- | --- |
| `platform` | string or null | Search engine used |
| `keyword` | string or null | Exact search keyword supplied 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 | Publisher display name or domain reported by the source |
| `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 or null | Actor URL that processed the row |
| `processed_at` | string or null | UTC processing timestamp |

Abbreviated example — 14 of the real row's 30 fields are shown, and `creators` and `variants` are truncated to one entry each:

```json
{
  "platform": "bing",
  "keyword": "red panda wildlife",
  "rank": 1,
  "title": "Red panda in a forest",
  "publisher": "Wikipedia",
  "creators": ["Ganga Raj Sunuwar"],
  "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"
}
```

An engine may omit `title`, `description`, `publisher`, `creators`, `variants`, `page_url`, or `thumbnail_url`; those values stay null instead of being inferred. 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 the Actor name `agentx/all-image-scraper` with the same four-field JSON in HTTP, Python, JavaScript, Make.com, n8n, or an Apify MCP workflow, and read results through the asynchronous run flow.

#### Actor ID

Use the public Actor name form:

```text
agentx/all-image-scraper
```

The immutable API ID is filled after first publication; the name form works across every example on this page.

#### HTTP API

Start the run, poll it until it succeeds, then read its Dataset:

```bash
RUN=$(curl -s -X POST "https://api.apify.com/v2/acts/agentx~all-image-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"keyword":"red panda wildlife","platforms":["bing"],"format":"webp","max_results":1}')
RUN_ID=$(echo "$RUN" | jq -r .data.id)

curl -s "https://api.apify.com/v2/actor-runs/$RUN_ID?token=$APIFY_TOKEN" | jq -r .data.status

curl -s "https://api.apify.com/v2/datasets/$(echo "$RUN" | jq -r .data.defaultDatasetId)/items?token=$APIFY_TOKEN"
```

Repeat the `GET /v2/actor-runs/{runId}` call until `status` reads `SUCCEEDED`, or register an `ACTOR.RUN.SUCCEEDED` webhook and skip polling entirely.

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("agentx/all-image-scraper").start(run_input={
    "keyword": "red panda wildlife",
    "platforms": ["bing"],
    "format": "webp",
    "max_results": 1,
})
finished = client.run(run["id"]).wait_for_finish()
items = client.dataset(finished["defaultDatasetId"]).list_items().items
print(items[0]["image_url"])
```

#### JavaScript

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

const client = new ApifyClient({ token: 'YOUR_APIFY_TOKEN' });
const run = await client.actor('agentx/all-image-scraper').start({
  keyword: 'red panda wildlife',
  platforms: ['bing'],
  format: 'webp',
  max_results: 1,
});
const finished = await client.run(run.id).waitForFinish();
const { items } = await client.dataset(finished.defaultDatasetId).listItems();
console.log(items[0].image_url);
```

#### Make.com

Add **Apify → Run an Actor**, enter `agentx/all-image-scraper`, and map `keyword`, `platforms`, `format`, and `max_results` to `red panda wildlife`, `["bing"]`, `webp`, and `1`. Leave the module's "wait until finished" option on so it returns only on `SUCCEEDED`, then follow it with **Get Dataset Items** and pass each `image_url` or `metadata_url` to the next module.

#### n8n

Use an HTTP Request node with `POST https://api.apify.com/v2/acts/agentx~all-image-scraper/runs`, Bearer authentication, and the same four-key JSON body. Take `data.id` and `data.defaultDatasetId` from the response, poll `GET https://api.apify.com/v2/actor-runs/{runId}` on a Wait loop until `status` is `SUCCEEDED`, then fetch `GET https://api.apify.com/v2/datasets/{datasetId}/items`.

#### MCP

Through the Apify MCP server, call `agentx/all-image-scraper` with `{"keyword":"red panda wildlife","platforms":["bing"],"format":"webp","max_results":1}`. The server starts the run and reports completion; read the default Dataset afterwards and use `image_url` as the converted asset or `original_url` when the original bytes are required.

***

### Pricing

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

| Plan | Actor Start per run | Result: one published image |
| --- | ---: | ---: |
| FREE | $0.04000 | $0.00400 |
| BRONZE | $0.04000 | $0.00360 |
| SILVER | $0.04000 | $0.00320 |
| GOLD | $0.04000 | $0.00300 |
| PLATINUM | $0.04000 | $0.00300 |
| DIAMOND | $0.04000 | $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 4 GB, so every run begins with 4 × $0.01000 = $0.04000 whatever it returns. A one-image FREE run is `$0.04000 + 1 × $0.00400 = $0.04400`; a 10-image run is `$0.04000 + 10 × $0.00400 = $0.08000`.

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.04000 + 100 × $0.00400 = $0.44000`, which is $0.00440 per image against $0.04400 for a single-image run. Failed candidates do not create result rows, so the result event is tied to delivered Dataset items. 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, more than the 200 images a Brave run returns from its single result window, or guaranteed availability from an external image host.

***

### Limits and Troubleshooting

- **Fewer rows than `max_results` → an external file could not be published.** Search indexes may reference an image that was removed, blocks automated retrieval, exceeds the 40 MB source-file limit, decodes to more than 100 megapixels, or is not a decodable image. Try the same keyword later, or add another engine to `platforms`.
- **A Brave run stops at 200 images → that engine exposes one result window.** Google, Bing, Yahoo, and Yandex answer a deeper request with further windows; Brave does not. Select another engine alongside Brave when a keyword needs more than 200 files.
- **No rows → the search or candidate set was temporarily unusable.** Confirm that `keyword` is specific but not overly narrow, then retry with a broader phrase or another engine.
- **`title`, `description`, `publisher`, `creators`, or `variants` is null → the engine did not report that value.** 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 Dataset 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.

Every completed row follows the same 30-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.04000 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?

As many as `max_results` asks for from every engine you selected — three engines at 10 return up to 30 rows — with a minimum of 1 and no upper bound. Google, Bing, Yahoo, and Yandex read successive result windows to fill a large request, and each further window measurably added images that had not appeared before; Brave answers from a single 200-result window, of which two full scans saved 198 and 199 files. The delivered count can be lower when the engine exposes fewer usable candidates or an external host no longer serves a valid image, and the run then reports the delivered count against the requested one.

#### 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, and an image two selected engines both surface is delivered once.

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

Every published 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 while the original file, selected output, raw response, source URL, dimensions, sizes, and hashes remain available.

***

### Related AgentX Actors

AgentX currently has 79 published Actors, grouped below by workflow; the three closest choices are listed first and the generated catalog then includes every direct published Actor exactly once.

Closest to this Actor:

- **[Google Keyword Trends](https://apify.com/agentx/google-keyword-trends)** — validate keyword demand and compare search interest before collecting visual references.
- **[All Video Scraper](https://apify.com/agentx/all-video-scraper)** — extend a multimedia research workflow from still images to normalized public video metadata.
- **[All Shopping Scraper](https://apify.com/agentx/all-shopping-scraper)** — enrich image-led product research with normalized listings, prices, and marketplace records.

#### Business and Market Intelligence

- **[All Web Search Scraper](https://apify.com/agentx/all-web-search-scraper)** — multi-engine web search across ten independent indexes
- **[Google Keyword Trends](https://apify.com/agentx/google-keyword-trends)** — Google Trends keyword interest, compared five at a time
- **[Google Trends Scraper](https://apify.com/agentx/google-trends-scraper)** — Google Trends trending searches
- **[Google Maps Store Scraper](https://apify.com/agentx/google-maps-store-scraper)** — Google Maps business listings
- **[LinkedIn Company Lookup](https://apify.com/agentx/linkedin-company-lookup)** — LinkedIn company records
- **[LinkedIn Profile Lookup](https://apify.com/agentx/linkedin-profile-lookup)** — LinkedIn profile records
- **[Weather Forecast API](https://apify.com/agentx/weather-forecast-api)** — forecast and historical weather data

#### Jobs and Hiring

- **[All Jobs Scraper](https://apify.com/agentx/all-jobs-scraper)** — multi-platform job listings
- **[Bayt Jobs Scraper](https://apify.com/agentx/bayt-jobs-scraper)** — Bayt job listings
- **[Glassdoor Jobs Scraper](https://apify.com/agentx/glassdoor-jobs-scraper)** — Glassdoor job listings
- **[Indeed Jobs Scraper](https://apify.com/agentx/indeed-jobs-scraper)** — Indeed job listings
- **[JobStreet Company Profile](https://apify.com/agentx/jobstreet-company-profile)** — JobStreet employer records
- **[Jooble Jobs Scraper](https://apify.com/agentx/jooble-jobs-scraper)** — Jooble job listings
- **[LinkedIn Jobs Scraper](https://apify.com/agentx/linkedin-jobs-scraper)** — LinkedIn job listings
- **[Naukri Jobs Scraper](https://apify.com/agentx/naukri-jobs-scraper)** — Naukri job listings
- **[Talent Jobs Scraper](https://apify.com/agentx/talent-jobs-scraper)** — Talent.com job listings
- **[ZipRecruiter Jobs Scraper](https://apify.com/agentx/ziprecruiter-jobs-scraper)** — ZipRecruiter job listings

#### Social Media

- **[All Forums Thread Scraper](https://apify.com/agentx/all-forums-thread-scraper)** — multi-platform forum and Q\&A threads
- **[Instagram Creator Scraper](https://apify.com/agentx/instagram-creator-scraper)** — Instagram creator profiles
- **[Instagram Reels Scraper](https://apify.com/agentx/instagram-reels-scraper)** — Instagram Reels metadata
- **[Instagram Trending Scraper](https://apify.com/agentx/instagram-trending-scraper)** — Instagram trending content
- **[Medium Scraper](https://apify.com/agentx/medium-scraper)** — Medium articles
- **[Medium Profile Scraper](https://apify.com/agentx/medium-profile-scraper)** — Medium author profiles
- **[Reddit Profile Scraper](https://apify.com/agentx/reddit-profile-scraper)** — Reddit user profiles
- **[Reddit Viral Scraper](https://apify.com/agentx/reddit-viral-scraper)** — Reddit viral posts
- **[SubReddit Info Scraper](https://apify.com/agentx/subreddit-info-scraper)** — subreddit metadata
- **[Subreddit Members Scraper](https://apify.com/agentx/subreddit-members-scraper)** — subreddit member lists
- **[Subreddit Posts Scraper](https://apify.com/agentx/subreddit-posts-scraper)** — subreddit post feeds
- **[Telegram Chat Scraper](https://apify.com/agentx/telegram-chat-scraper)** — Telegram chat messages
- **[Telegram Info Scraper](https://apify.com/agentx/telegram-info-scraper)** — Telegram channel metadata
- **[Telegram Member Adder](https://apify.com/agentx/telegram-member-adder)** — Telegram group membership management
- **[Telegram Member Scraper](https://apify.com/agentx/telegram-member-scraper)** — Telegram group members
- **[Telegram Private Group Scraper](https://apify.com/agentx/telegram-private-group-scraper)** — private Telegram group data
- **[TikTok Creator API](https://apify.com/agentx/tiktok-creator-api)** — TikTok creator profiles
- **[TikTok User Lookup](https://apify.com/agentx/tiktok-user-lookup)** — TikTok account records
- **[X Twitter Community API](https://apify.com/agentx/x-twitter-community-api)** — X community data
- **[X Twitter Profile Lookup](https://apify.com/agentx/x-twitter-profile-lookup)** — X profile records
- **[YouTube Creator Email Scraper](https://apify.com/agentx/youtube-creator-email-scraper)** — YouTube creator contact data

#### Video, Transcripts and Downloads

- **[All Video Scraper](https://apify.com/agentx/all-video-scraper)** — multi-platform video metadata
- **[Video Transcript](https://apify.com/agentx/video-transcript)** — multi-platform transcripts
- **[Video Captions Downloader](https://apify.com/agentx/video-captions-downloader)** — caption files
- **[Video to Social Post](https://apify.com/agentx/video-to-social-post)** — video repurposed into social copy
- **[YouTube Transcript](https://apify.com/agentx/youtube-transcript)** — YouTube transcripts
- **[TikTok Transcript](https://apify.com/agentx/tiktok-transcript)** — TikTok transcripts
- **[X Twitter Transcript](https://apify.com/agentx/x-twitter-transcript)** — X video transcripts
- **[Facebook Transcript](https://apify.com/agentx/facebook-transcript)** — Facebook video transcripts
- **[Bilibili Transcript](https://apify.com/agentx/bilibili-transcript)** — Bilibili transcripts
- **[Dailymotion Transcript](https://apify.com/agentx/dailymotion-transcript)** — Dailymotion transcripts
- **[Rutube Transcript](https://apify.com/agentx/rutube-transcript)** — Rutube transcripts
- **[Loom Transcript](https://apify.com/agentx/loom-transcript)** — Loom transcripts
- **[Wistia Transcript](https://apify.com/agentx/wistia-transcript)** — Wistia transcripts
- **[Instagram Reels Downloader](https://apify.com/agentx/instagram-reels-downloader)** — Reels downloads
- **[Kick Clip Downloader](https://apify.com/agentx/kick-clip-downloader)** — Kick clip downloads
- **[Linkedin Video Downloader](https://apify.com/agentx/linkedin-video-downloader)** — LinkedIn video downloads
- **[Pinterest Video Downloader](https://apify.com/agentx/pinterest-video-downloader)** — Pinterest video downloads
- **[Reddit Video Downloader](https://apify.com/agentx/reddit-video-downloader)** — Reddit video downloads
- **[Snapchat Video Downloader](https://apify.com/agentx/snapchat-video-downloader)** — Snapchat video downloads
- **[TED Talk Downloader](https://apify.com/agentx/ted-talk-downloader)** — TED talk downloads
- **[TikTok Live Downloader](https://apify.com/agentx/tiktok-live-downloader)** — TikTok live downloads
- **[Twitch VOD Downloader](https://apify.com/agentx/twitch-vod-downloader)** — Twitch VOD downloads
- **[Zoom Recording Downloader](https://apify.com/agentx/zoom-recording-downloader)** — Zoom recording downloads

#### E-Commerce and Retail

- **[All Shopping Scraper](https://apify.com/agentx/all-shopping-scraper)** — multi-platform product data
- **[AliExpress Product Scraper](https://apify.com/agentx/aliexpress-product-scraper)** — AliExpress products
- **[Amazon Storefront Scraper](https://apify.com/agentx/amazon-storefront-scraper)** — Amazon Brand Store pages
- **[Bol Product Scraper](https://apify.com/agentx/bol-product-scraper)** — Bol.com products
- **[eBay Seller Leads API](https://apify.com/agentx/ebay-seller-leads-api)** — eBay seller records
- **[Hepsiburada Product Scraper](https://apify.com/agentx/hepsiburada-product-scraper)** — Hepsiburada products
- **[Kakaku Product Scraper](https://apify.com/agentx/kakaku-product-scraper)** — Kakaku.com products
- **[Rakuten Product Scraper](https://apify.com/agentx/rakuten-product-scraper)** — Rakuten products

#### Classifieds and Automotive

- **[All Vehicle Scraper](https://apify.com/agentx/all-vehicle-scraper)** — multi-platform vehicle listings
- **[AutoTrader Vehicle Search](https://apify.com/agentx/autotrader-vehicle-search)** — AutoTrader US listings
- **[AutoTrader UK Vehicle Search](https://apify.com/agentx/autotrader-uk-vehicle-search)** — AutoTrader UK listings

#### Real Estate

- **[All Property Scraper](https://apify.com/agentx/all-property-scraper)** — multi-platform property listings
- **[Homes Property Scraper](https://apify.com/agentx/homes-property-scraper)** — Homes.com listings
- **[MagicBricks Property Scraper](https://apify.com/agentx/magicbricks-property-scraper)** — MagicBricks listings
- **[NoBroker Property Scraper](https://apify.com/agentx/nobroker-property-scraper)** — NoBroker listings
- **[Property24 Property Scraper](https://apify.com/agentx/property24-property-scraper)** — Property24 listings
- **[Realtor Property Scraper](https://apify.com/agentx/realtor-property-scraper)** — Realtor.com listings
- **[Zillow Property Scraper](https://apify.com/agentx/zillow-property-scraper)** — Zillow listings

***

### 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:** September 4, 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`):

Which image search engines to read. Pick one or more of Google, Bing, Yahoo, Brave, and Yandex; a run reads the ones you select one after another, and every row records the engine it came from. Google, Bing, Yahoo, and Yandex read deeper result windows to fill a large request; Brave answers from a single 200-result window. A Google window takes about a minute; the other four answer in seconds.

## `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.

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

How many successfully downloaded output images to return from each engine you select — three engines at 10 return up to 30. The minimum is 1 and there is no upper bound; Google, Bing, Yahoo, and Yandex read deeper result windows to fill a large request, while Brave stops at its single 200-result window. An image two engines both surface is delivered once, against whichever engine reached it first, and the run reports how many images were delivered against how many were asked for.

## Actor input object example

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

# Actor output Schema

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

One row per saved image with original and output links, source description and variants, dimensions, animation frame counts, and metadata and raw search artifacts.

# 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/LUJeu6iLzAQVelcjK/openapi.json