All Image Scraper

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.

• 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. 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:

{
  "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:

{
  "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:

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:

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:

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.

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.

MCP

Connect to the authenticated Apify MCP server, 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.

---

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, Bing Images, Yahoo Search, Brave Image Search, or Yandex Images 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 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 as structured append-only result storage and key-value stores 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 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 — compare demand for a keyword before using it as this Actor's keyword.
• All Video Scraper — extend research from still images to public video metadata using the same topic.
• All Shopping Scraper — follow image-led product research with product listings, prices, and marketplace records.

Browse more tools on the AgentX page.

---

Support and Community

Ask about image search, original-file storage, per-image metadata, or format conversion in the AgentX community on Telegram; for a reproducible bug, open an Issue with the run ID and the exact input.

AgentX is an Arcyton brand — arcyton.com.

Last Updated: October 31, 2026