Image Search Download API

Image Search Download API is an image download api that takes a keyword instead of a URL list, searches one or several of five engines in the same run, and hands back the image files themselves with 30 fields of provenance around each one.

• A keyword goes in, files come out. Nothing upstream discovers URLs first: the run searches, downloads, decodes, and stores.
• Both representations are kept. The byte-exact original always, a JPEG, PNG, or WebP copy beside it when requested, a SHA-256 over each.
• Thirty fields per row, including the engine's own description, publisher, creator credits, and alternate variants, plus the decoded geometry and frame counts of both files.
• Nothing is billed that was not delivered. A row exists only once its original, output, JSON metadata record, and raw search response are all stored.

Run a one-result test · View API

One image on the FREE tier costs $0.04000 of Actor Start plus $0.00500, so the smallest useful test is $0.04500; the prefilled two-image test is $0.05000.

What does Image Search Download API do?

It turns an image-search keyword into stored files and a record of where each came from. A run picks any combination of Google, Bing, Yahoo, Brave, and Yandex, reads each selected engine's result windows in turn, downloads and decodes each candidate, stores the original bytes untouched, optionally writes a JPEG, PNG, or WebP copy, and publishes one Dataset row per delivered file carrying the engine it came from.

What it is not: a URL-list downloader, a site crawler, or a reverse-image lookup. It takes no image as input, walks no website for image tags, decides nothing about reuse rights, and authenticates as nobody. The five engines are read as public search sources — no account, no key, no affiliation with Google, Microsoft, Yahoo, Brave, or Yandex.

How do I run Image Search Download API?

1. Enter keyword — one phrase, up to 200 characters, sent to every selected engine exactly as typed.
2. Pick platforms — one or more of google, bing, yahoo, brave, yandex.
3. Pick format — original for the source bytes alone, or jpeg, png, webp to add a converted copy.
4. Set max_results — how many downloaded images to return from each selected engine. Minimum 1, no upper bound.
5. Start the run and read the default Dataset.

The smallest useful input, and the one the inputs arrive prefilled with:

{
  "keyword": "vintage travel poster",
  "platforms": ["yandex"],
  "format": "png",
  "max_results": 2
}

max_results counts delivered rows per selected engine, not candidates examined — three engines at 10 return up to 30 rows. A candidate that 404s, refuses automated retrieval, or fails to decode is skipped and another is tried, so the number you set is the number of usable files you are asking to pay for from each engine. An image two selected engines both surface is downloaded, delivered, and billed once, against whichever engine reached it first.

What data does Image Search Download API return?

One row per image downloaded, decoded, stored, and either preserved byte-exactly or converted. Every row carries the same 30 fields.

Group	Fields
Search context	platform, keyword, rank, title, description, publisher, creators, variants
External links	search_url, source_url, page_url, thumbnail_url
Stored artifacts	raw_url, original_url, image_url, metadata_url
Decoded properties	original_format, output_format, width, height, output_width, output_height, original_frames, output_frames, original_bytes, output_bytes, original_sha256, output_sha256
Provenance	processor, processed_at

variants lists alternate copies the engine reported, each with url, width, height, and bytes — that is how a job picks a resolution instead of taking whichever URL the result page exposed. creators holds credit strings the engine published: a lead for a licensing check, never a licence determination.

An illustrative row, abbreviated to 12 of the 30 fields:

{
  "platform": "yandex",
  "keyword": "vintage travel poster",
  "rank": 1,
  "title": "Swiss Alps travel poster, 1935",
  "publisher": "example-archive.org",
  "source_url": "https://example-archive.org/posters/alps-1935.jpg",
  "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.png",
  "metadata_url": "https://api.apify.com/v2/key-value-stores/example/records/image-metadata.json",
  "original_format": "jpeg",
  "output_format": "png",
  "output_sha256": "39f78f2c453b0b86fe99a760678f0f4549f737c37e55638fca30bd13d27ee0f4"
}

Where the engine reports no value the field stays null rather than being filled in from elsewhere. Rows export as JSON, CSV, Excel, XML, RSS, or HTML; the binaries stay reachable through the URLs in the row.

What inputs can I configure?

Four inputs, all required, in schema order.

Input	Type	Required	Notes
keyword	string	Yes	One phrase, 200 characters or fewer, sent unmodified
platforms	array of enum	Yes	One or more of 5: google, bing, yahoo, brave, yandex, read in turn
format	enum	Yes	One of 4: original, jpeg, png, webp
max_results	integer	Yes	Per selected engine; minimum 1, no maximum

No optional input, no per-engine configuration object, no filter beyond the four fields; the engine selection is the only thing that changes per run. Size, colour, licence, date, and safe-search facets are deliberately absent: the engines expose them inconsistently, and sending one an engine quietly ignores would make a filter look supported when it is not. max_results carries no ceiling on purpose — each engine's supply of usable candidates is the real limit, and the run reports what it delivered against what was asked for rather than refusing a large number up front.

What platforms and markets does Image Search Download API cover?

Five engines, any combination of them per run, each read through its own public result pages:

Engine	Candidates per window	Further windows	New images the next window added, over five keywords	Median request
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 numbers come from 20 paged requests per engine across five keywords on 2026-09-02, counting only images not already seen in an earlier window. Brave has no second window, so a Brave run stops at 200 candidates however large max_results is; two full scans of it saved 198 and 199 files.

Market coverage is whatever the engine returns for the phrase, in whatever language; non-Latin keywords went through unchanged in that measurement. There is no country or locale input, because none of the five honours one consistently across the result shapes this reads — Yandex's own documentation describes the image results page and the metadata it exposes.

Why use Image Search Download API?

Because the gap between "a search engine knows about this image" and "I have the file and can prove where it came from" is four separate jobs, and this closes all four in one call.

Capability	What it saves you
Keyword to stored file in one request	No discovery step, no URL list, no separate downloader
Original bytes plus a converted copy	No encoder in your pipeline, no lost fidelity when you need the source later
SHA-256 over both files	Exact-duplicate detection without re-hashing downloads
One row shape across five engines	Switching or falling back between engines changes no downstream code

The trade-off: this is search-driven, so it inherits the engine's opinion of the keyword, and no engine promises it indexes the largest version of a given image.

Who is Image Search Download API for?

Developers and data teams building something that consumes image files, not image links.

• Training and evaluation sets. Collect a subject across engines, deduplicate on original_sha256, keep source_url, publisher, and raw_url as the provenance record a dataset review asks for.
• Agent pipelines. An agent asks for a keyword and gets stored assets with dimensions, formats, and hashes already measured, so nothing downstream opens a file to learn what it is.
• Content tooling. Pull references in one fixed output format and filter on output_width and output_bytes before a layout step sees them.
• Monitoring. Re-run the four fields on a schedule and diff original_sha256 and rank.

Wrong tool for licence clearance, private or paywalled media, reverse-image matching, OCR, face detection, or any guarantee about a third-party host tomorrow.

How can I use Image Search Download API through the API or MCP?

Use the name form truefetch/image-search-download-api; the immutable API ID is issued at first publication and the name form works everywhere the ID does. Start the run, poll it, then read its Dataset — never a synchronous shortcut, because the platform cuts a sync connection at 300 seconds without stopping the run, and a retry starts a second billed one.

RUN=$(curl -s -X POST "https://api.apify.com/v2/acts/truefetch~image-search-download-api/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"keyword":"vintage travel poster","platforms":["yandex"],"format":"png","max_results":2}')
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 run-status call until status reads SUCCEEDED, or register an ACTOR.RUN.SUCCEEDED webhook and skip polling. Then fetch the Dataset items.

Through the Apify MCP server, call truefetch/image-search-download-api with {"keyword":"vintage travel poster","platforms":["yandex"],"format":"png","max_results":2}, then read the default Dataset and take image_url for the converted file or original_url for the source bytes. Generated SDK snippets and the OpenAPI definition are on the API page.

How much does Image Search Download API cost?

On the FREE tier each delivered image costs $0.00500, every run starts with $0.04000 of Actor Start, and the smallest useful one-image test totals $0.04500.

Plan	Actor Start per run	Result: one delivered image
FREE	$0.04000	$0.00500
BRONZE	$0.04000	$0.00450
SILVER	$0.04000	$0.00400
GOLD	$0.04000	$0.00375
PLATINUM	$0.04000	$0.00375
DIAMOND	$0.04000	$0.00375

Actor Start bills one event per gigabyte of run memory with a one-event minimum, and this Actor's 4 GB makes that 4 × $0.01000 = $0.04000 on every run whatever it returns. Everything else bills per delivered row: a candidate that could not be downloaded, decoded, or stored produces no row and no charge. Because the start is fixed and the rows are not, a 100-image run at $0.04000 + 100 × $0.00500 = $0.54000 costs $0.00540 per image against $0.04500 for a single-image run — batch the keyword rather than splitting it. Prices can change; current amounts are on the pricing page.

How does Image Search Download API compare with alternatives?

Doing it by hand is fine for a handful of files and better when a person judges each one before saving it. It stops scaling once the task also has to store originals, convert formats, hash files, and keep a provenance trail. Wiring it from separate pieces — search integration, downloader, encoder, hashing step — buys total control and four failure modes instead of one, which is right when the search side is already solved in your stack.

The engines' own interfaces win on exploration: facets this does not have, instant rendering, a human rejecting a bad candidate in a second. Microsoft's licence-filter documentation states plainly that the originating site must still be checked, which is why nothing here claims a reuse right. An official search API fits better when its engine, quota, and metadata contract match and you never needed the bytes; a stock library fits better when cleared commercial licensing outranks open-web coverage. Do not choose this for a URL list, a known site, reverse-image search, or when one engine facet is the whole requirement.

What are the limits and troubleshooting steps?

• Fewer rows than max_results. A candidate was removed at the source, refuses automated retrieval, exceeds the 40 MB source-file limit, decodes to more than 100 megapixels, or is not a decodable image. Retry later, or add another engine to platforms.
• A Brave run stops at 200, or a run returns nothing. Brave has one result window, so ask another engine for the remainder; an empty run means that phrase was temporarily unusable, so broaden it or switch engines.
• description, publisher, creators, or variants is null. The engine did not publish it. Alternate variants come from Yandex only; credits appear only where an engine exposes them.
• A JPEG came back with a white background. JPEG has no alpha channel, so transparency composites onto white. Ask for png or webp to keep it.
• output_frames is 1 while original_frames is higher. A conversion writes the first frame only; use original when the animation has to survive.
• Near-identical files survive deduplication. The hashes prove byte identity, not visual similarity. Add a perceptual hash downstream.

The smallest reproducible input is the prefilled vintage travel poster / yandex / png / 2. For a defect report, open an Issue with the run ID, the exact input, the affected rank, and which artifact URL failed. Never paste a token into an issue.

Frequently asked questions

How do I download image search results as files?

Set keyword, pick one or more engines in platforms, pick a format, set max_results, and start the run. Each Dataset row links to the stored original and, when a conversion was requested, to the converted copy beside it.

Is there an image download api with sha-256 hashes?

Yes — every row carries original_sha256 over the stored source bytes and output_sha256 over the requested output, with original_bytes and output_bytes beside them, so both files verify independently after download.

Is there a free image search API?

Not an unlimited one. Runs can be tested with Apify credits, but FREE-tier billing is $0.04000 of Actor Start per run plus $0.00500 per delivered image.

Can I schedule runs to monitor image results over time?

Yes. Save the four fields as an Apify task, attach a schedule, and compare rank, source_url, and the two hashes between snapshots.

Does the row tell me who owns an image?

It tells you what the engine said: publisher and creators are reported values and page_url points at the context page when one was exposed. Treat all three as the start of a licensing check, never as permission.

Can it reach private, paid, or locked images?

No. Public search results and publicly retrievable image URLs only — no authentication, no guessed addresses, no working around access controls.

Related TrueFetch Actors

• Multi Engine Search API — the same keyword-to-many-engines shape for web results instead of images, when you need the pages rather than the pictures.
• Best Video Downloader — the file-delivery counterpart for video, when a media pipeline needs moving assets stored the same way.
• Google Trends Explore — check whether a phrase is worth collecting for before spending a run on it.

Support

The API reference and pricing page cover configuration and billing. Ask about keyword coverage, stored artifacts, formats, or hashing in the TrueFetch community on Telegram, and open an Issue for anything reproducible.

Run a one-result test · View API

Last Updated: September 4, 2026