# Yandex Reverse Image Search — Find Where Images Appear (`cheapapi/yandex-reverse-image-search`) Actor

Yandex reverse image search API: find pages that use an image and visually similar images, with page title, site, size and text. Bulk, paging.

- **URL**: https://apify.com/cheapapi/yandex-reverse-image-search.md
- **Developed by:** [CheapAPI](https://apify.com/cheapapi) (community)
- **Categories:** SEO tools, Marketing, Developer tools
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event + usage

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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

## Yandex Reverse Image Search — Find Where Images Appear

Search **Yandex Images by image** in bulk (JPEG, PNG, GIF or WebP) and get clean JSON: for every image URL you give, the **web pages that show the same or a visually similar image**, with the page title and URL, the website, the matching image's URL, size and format, and the text next to it. Yandex's reverse image search is known for finding re-uploads, crops and edits that other engines miss. Up to **about 1,480 matches per image** (37 pages × 40 for popular images), **5,000 images per run**, no browser, proxy, captcha or Yandex account needed.

| Quick facts | |
|---|---|
| Price | $11.40 per 1,000 matches on the Free plan, $8.50 on Gold+; no start fee |
| Depth | about 40 matches per results page, up to ~1,480 per image (37 pages, popular images) |
| Input | direct image URLs (JPEG, PNG, GIF, WebP); up to 5,000 per run |
| Filters | only one website (e.g. `etsy.com`), safe search |
| Speed | 3–20 seconds per results page in our tests (occasionally up to ~60 s); 5 images in parallel |

Jump to [Pricing](#pricing) · [FAQ](#faq) · [Limitations](#limitations)

**Why this Actor**

- **15% cheaper per match than the most-used Yandex reverse image Actor on every plan** — $0.0114 per match on Free and $0.0085 on Gold+, with no start fee (a results page with fewer than 2 matches costs one flat $0.0097 instead).
- **Bulk and deep:** thousands of images per run and up to ~1,480 matches per image, fetched page by page through Yandex's own image handle (no re-uploads).
- **Works with images Yandex cannot reach:** when Yandex fails to download an image URL, the Actor downloads it and sends the image itself (up to 2.3 MB).
- **Find copies on one site:** set **Only this site** to check whether a marketplace, competitor, stock site or social network uses your photo.
- **Fair billing:** charged per delivered match; an image with no matches costs one flat $0.0097 page fee, images that cannot be searched are free, and your maximum cost per run is always respected.

### Compared with alternatives

Typical job: **100 images × 40 matches** (4,000 matches). Actor fees of public Apify Store listings (Free plan / Gold plan), checked October 2026:

| Option | 100 images × 40 matches | Price per match | Notes |
|---|---|---|---|
| **This Actor** | **$45.60 / $34.00** | $0.0114 / $0.0085 | pages and similar images; site filter |
| Most-used Yandex reverse image Actor (~200 users) | $54.00 / $40.00 | $0.0135 / $0.01 | also tags, other sizes, products; crop box |
| Per-item Actor (~13 users) | $17.60 / $13.20 | $0.0044 / $0.0033 | small listing |
| Free Actor (~27 users) | platform usage only | — | small listing |

We are **15% cheaper per match than the most-used listing on every plan** (a page with 0–1 matches is one flat $0.0097, still below one match at the leader's price). Two small listings are cheaper per row; compare their output fields and limits with your job before choosing.

### Not included

- **Image tags, "other sizes" lists, shopping products and the knowledge card** shown on the Yandex Images website — the official image search returns pages and images only.
- **Separate "exact copy" and "similar image" groups** — matches come in Yandex's single ranking (exact copies usually rank first).
- **Cropping a part of the image** — crop the image yourself and search the cropped URL.
- **Uploading local files** — give a public URL (any file host or an Apify key-value store record works).
- **Face recognition or identification of people** — see [Is it legal?](#faq).

### What data you get

One row per match:

| Field | Type | Example |
|---|---|---|
| `id` | string | `cd6be40556e43a13` (stable across runs) |
| `searchedImageUrl` | string | the image URL from your input |
| `position` | integer | `45` (1 = best match) |
| `resultsPage` | integer | `2` (about 40 matches per page) |
| `pageUrl` | string | `https://www.shopify.com/stock-photos/photos/the-eiffel-tower-paris?c=trip` |
| `pageTitle` | string | `Picture of The Eiffel Tower Paris - Free Stock Photo` |
| `site` | string | `shopify.com` |
| `imageUrl` | string | `https://upload.wikimedia.org/wikipedia/commons/a/aa/TourEiffel%28Paris%29.JPG` |
| `imageWidth` / `imageHeight` | integer | `925` / `1387` |
| `imageFormat` | string | `jpeg`, `png` or `gif` (null when Yandex does not say) |
| `passage` | string | `Image of The Eiffel Tower Paris.` (text next to the image) |
| `availablePages` | integer | `37` (results pages Yandex has for this image) |
| `siteFilter`, `safeSearch`, `scrapedAt` | string | your filters and the run time |

The dataset has two views — **Matches** (with image previews) and **Pages and sites**. Every run also saves a `RUN_SUMMARY` record in its key-value store: images requested, completed, without matches (and a `noMatchImages` list of them — each was charged one flat page fee), failed, uploaded by the Actor and skipped by your cost limit, results pages searched, matches delivered, flat page fees charged, waits at the hourly limit, and a `problems` list with the reason for every image that was skipped or failed.

### How to use

1. Open the Actor and click **Try for free**.
2. Paste your **Image URLs**, one per line (direct links to image files).
3. Set **Matches per image** (40 = one results page).
4. Optionally enter **Only this site** (e.g. `pinterest.com`).
5. Click **Start** and download the matches as JSON, CSV, Excel or HTML, or read them through the API.

Ready-to-paste input:

```json
{
    "imageUrls": [
        "https://upload.wikimedia.org/wikipedia/commons/thumb/8/85/Tour_Eiffel_Wikimedia_Commons_%28cropped%29.jpg/500px-Tour_Eiffel_Wikimedia_Commons_%28cropped%29.jpg"
    ],
    "maxResultsPerImage": 20,
    "safeSearch": "moderate"
}
```

**API (curl)** — runs the Actor and returns the matches when it finishes:

```bash
curl -X POST "https://api.apify.com/v2/acts/cheapapi~yandex-reverse-image-search/run-sync-get-dataset-items?token=<YOUR_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"imageUrls": ["https://example.com/photo.jpg"], "maxResultsPerImage": 40}'
```

**JavaScript** (`npm install apify-client`):

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

const client = new ApifyClient({ token: '<YOUR_TOKEN>' });
const run = await client.actor('cheapapi/yandex-reverse-image-search').call({
    imageUrls: ['https://example.com/photo.jpg'],
    maxResultsPerImage: 40,
    site: 'etsy.com',
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items.map((m) => m.pageUrl));
```

**Python** (`pip install apify-client`):

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_TOKEN>")
run = client.actor("cheapapi/yandex-reverse-image-search").call(run_input={
    "imageUrls": ["https://example.com/photo.jpg"],
    "maxResultsPerImage": 40,
})
for match in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(match["position"], match["site"], match["pageUrl"])
```

### Use cases

- **Copyright and photo theft:** find websites and shops that use your product photos, artwork or stock images without a licence.
- **Brand protection:** check marketplaces (`site: etsy.com`, `aliexpress.com`) for listings that reuse your product images.
- **Fact-checking and OSINT on content:** find earlier uploads and the original source of a picture before you share it.
- **Backlink and PR outreach:** find pages that use your images without linking to you and ask for credit.
- **Dropshipping and sourcing research:** see where a product photo appears to find suppliers and competing sellers.
- **Dataset building:** collect visually similar images (with their pages) for a topic.

### Advanced options

| Option | Default | What it does |
|---|---|---|
| `imageUrls` | — (required) | Direct image URLs (JPEG, PNG, GIF, WebP), up to 5,000 per run; duplicates removed. |
| `maxResultsPerImage` | 40 | Matches per image, 1–1,500, best first (Yandex has at most ~1,480; asking for more returns everything it has). Each is a charged match; a results page with fewer than 2 matches (e.g. asking for 1, or 41 = 40 + 1) is one flat $0.0097 page fee instead. |
| `site` | — | Only matches from this website and its subdomains, e.g. `pinterest.com` (international domains like `пример.рф` work too). |
| `safeSearch` | `moderate` | `moderate` (hide adult images), `strict` (also profanity) or `off`. |
| `maxWaitMinutes` | 15 | Minutes to wait each time Yandex's hourly image search limit is reached (0–120) before stopping. |

### Output example

Real rows from a platform run for the Eiffel Tower photo above with `"site": "pinterest.com"` and `"maxResultsPerImage": 41` (October 2026; 41 rows, first and last shown). That run was charged 40 matches plus one flat page fee for the single match on page 2:

```json
[
  { "id": "488a1879c4836ef7", "searchedImageUrl": "https://upload.wikimedia.org/wikipedia/commons/thumb/8/85/Tour_Eiffel_Wikimedia_Commons_%28cropped%29.jpg/500px-Tour_Eiffel_Wikimedia_Commons_%28cropped%29.jpg",
    "position": 1, "resultsPage": 1, "pageUrl": "https://ca.pinterest.com/ideas/eiffel-tower-high-resolution-photo/903938408451/",
    "pageTitle": "Eiffel Tower High Resolution Photo", "site": "ca.pinterest.com",
    "imageUrl": "https://images.pexels.com/photos/33320737/pexels-photo-33320737.jpeg?cs=srgb&dl=pexels-dylan-linders-2152031237-33320737.jpg&fm=jpg",
    "imageWidth": 720, "imageHeight": 1280, "imageFormat": "jpeg", "passage": "Eiffel tower high resolution photo", "availablePages": 37,
    "siteFilter": "pinterest.com", "safeSearch": "moderate", "scrapedAt": "2026-10-05T14:51:28.424Z" },
  { "id": "19b82761339fd03f", "searchedImageUrl": "https://upload.wikimedia.org/wikipedia/commons/thumb/8/85/Tour_Eiffel_Wikimedia_Commons_%28cropped%29.jpg/500px-Tour_Eiffel_Wikimedia_Commons_%28cropped%29.jpg",
    "position": 41, "resultsPage": 2, "pageUrl": "https://ru.pinterest.com/pin/mine--666180969856214896/",
    "pageTitle": "Пин от пользователя Дарья Козлова на доске Mine", "site": "ru.pinterest.com",
    "imageUrl": "https://upload.wikimedia.org/wikipedia/commons/a/aa/TourEiffel%28Paris%29.JPG", "imageWidth": 736, "imageHeight": 981,
    "imageFormat": "jpeg", "passage": "COP21 : One Heart One Tree, une forêt à la Tour Eiffel", "availablePages": 37,
    "siteFilter": "pinterest.com", "safeSearch": "moderate", "scrapedAt": "2026-10-05T14:51:28.424Z" }
]
```

### Pricing

Pay per event — **you pay per delivered match, or one flat $0.0097 for a results page with 0–1 new matches**, with no start fee. Apify platform usage is billed separately by Apify. This Actor uses 256 MB of memory; our test runs used about $0.0006 of platform usage per run (1 image, 2 results pages).

| Event | Free | Bronze | Silver | Gold, Platinum, Diamond |
|---|---|---|---|---|
| Image match (`image-match`) | $0.0114 | $0.0106 | $0.0095 | $0.0085 |
| Results page with 0–1 matches (`page-with-few-matches`) | $0.0097 | $0.0097 | $0.0097 | $0.0097 |

- **Results page with 0–1 matches:** charged **instead of** per-match fees when a Yandex results page gives fewer than 2 matches to deliver — an image with no matches, a last page with a single match left (for example 41 matches = 40 matches + one $0.0097 page), or a later page whose matches were all (or all but one) repeats of matches already delivered. It covers the search Yandex still made.
- **Free:** invalid URLs, duplicates, images that cannot be downloaded or read, and failed searches. If an image fails after some results pages, the matches already delivered are kept and charged as usual.

**Worked examples (Free / Gold):**

- **100 images × 40 matches** (4,000 matches): **$45.60 / $34.00**.
- **1,000 images × 10 matches** (10,000 matches): **$114 / $85**.
- **One image, all ~1,480 matches** (37 pages): **$16.87 / $12.58**.

Set **Maximum cost per run** in the run options to cap any run; the Actor stops cleanly at the limit and tells you what was skipped.

**Apify Free plan:** up to **$0.25 of results per month** (enough to try the prefilled input — 1 image × 20 matches costs $0.23). Any paid Apify plan removes this limit.

### Integrations

- **Google Sheets, Excel, CSV:** export the dataset or use the Google Sheets integration.
- **Make, Zapier, n8n:** start the Actor from a scenario and receive matches.
- **Webhooks:** get a call when a run finishes.
- **Scheduling:** re-check your images weekly or monthly; every row has a stable `id`, so new matches are easy to spot.
- **API and MCP:** call it from code (see above) or from AI agents through Apify's MCP server.

### FAQ

**Is it legal?** The Actor uses Yandex's official image search service and returns public web pages. Use it for your own images, copyright, brand protection and content verification. **Do not use it to identify or track private individuals from photos of them** — that may be illegal (e.g. under the GDPR) and is not allowed with this Actor.

**How fresh is the data?** Every search is made live at run time against Yandex's current image index.

**Why did I get fewer matches than I asked for?** Yandex has fewer matches for rare or new images, the site filter removes the rest, and repeated matches are dropped. `availablePages` shows how many pages Yandex had.

**Why are some matches only similar, not the same image?** Yandex ranks exact copies and visually similar images in one list. Exact copies usually come first; check `imageWidth`/`imageHeight` and the page to confirm.

**Why was I charged for an image with no matches?** Yandex still made the search, so one flat $0.0097 page fee applies — less than one match. The same fee applies to a later results page that only repeated matches you already got. Images that could not be searched are free.

**My image URL is behind a login or on my computer — what can I do?** Upload it to any public host (or an Apify key-value store record) and use that URL. If Yandex cannot download a public URL itself, the Actor sends the image directly.

**The run says it is waiting at the hourly limit — is something wrong?** No. Yandex limits image searches per hour; the run waits and continues automatically (up to **Maximum wait**), and nothing is charged while it waits — only for results pages that were searched.

**Do I need a Yandex account or API key?** No. Everything is included in the price.

### Support

Found a problem or need a feature? Open an issue on the Actor's **Issues** tab with the run ID; we aim to answer within one working day.

### Limitations

- Image URLs only (JPEG, PNG, GIF, WebP); images Yandex cannot reach are uploaded only up to 2.3 MB.
- About 40 matches per results page; the total depends on the image (popular images ~1,480, rare ones a few or none).
- If Yandex does not answer a search within 90 seconds, that image is listed in `RUN_SUMMARY.problems` (not charged) and can simply be searched again in a new run; the request is not repeated automatically because Yandex may already have processed it.
- Yandex allows a limited number of image searches per hour (shared by all users of this Actor); large runs may wait at the limit.
- Matches are not split into "exact" and "similar"; tags, other sizes and shopping products from the Yandex website are not available.
- Results reflect Yandex's index, which is strongest for Russian and international sites and may miss very new pages.

# Actor input Schema

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

Direct links to the images to search for (JPEG, PNG, GIF or WebP), one per line. Up to 5,000 per run; duplicates are removed. If Yandex cannot download an image itself, the Actor downloads it and sends the image directly (up to 2.3 MB).

## `maxResultsPerImage` (type: `integer`):

How many matches to return for each image, best first. Yandex returns about 40 per results page and up to about 1,480 in total (37 pages) for popular images. Each match is a charged result, so this is the main cost control; a results page that gives fewer than 2 matches (for example when you ask for 1 match, or 41 = 40 + 1) is charged one flat page fee instead. Apify Free plan: about 21 matches fit in the monthly $0.25 allowance.

## `site` (type: `string`):

Only return matches from this website and its subdomains, e.g. <code>pinterest.com</code> or <code>etsy.com</code>. Useful for checking whether a marketplace, competitor or stock site uses your image.

## `safeSearch` (type: `string`):

Filter adult content out of the matches.

## `maxWaitMinutes` (type: `integer`):

Yandex limits image searches per hour. When the limit is reached the run waits and continues automatically, up to this many minutes per wait (0–120); after that it stops and keeps what it has.

## Actor input object example

```json
{
  "imageUrls": [
    "https://upload.wikimedia.org/wikipedia/commons/thumb/8/85/Tour_Eiffel_Wikimedia_Commons_%28cropped%29.jpg/500px-Tour_Eiffel_Wikimedia_Commons_%28cropped%29.jpg"
  ],
  "maxResultsPerImage": 20,
  "safeSearch": "moderate",
  "maxWaitMinutes": 15
}
```

# Actor output Schema

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

No description

## `sites` (type: `string`):

No description

## `runSummary` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "imageUrls": [
        "https://upload.wikimedia.org/wikipedia/commons/thumb/8/85/Tour_Eiffel_Wikimedia_Commons_%28cropped%29.jpg/500px-Tour_Eiffel_Wikimedia_Commons_%28cropped%29.jpg"
    ],
    "maxResultsPerImage": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("cheapapi/yandex-reverse-image-search").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "imageUrls": ["https://upload.wikimedia.org/wikipedia/commons/thumb/8/85/Tour_Eiffel_Wikimedia_Commons_%28cropped%29.jpg/500px-Tour_Eiffel_Wikimedia_Commons_%28cropped%29.jpg"],
    "maxResultsPerImage": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("cheapapi/yandex-reverse-image-search").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 '{
  "imageUrls": [
    "https://upload.wikimedia.org/wikipedia/commons/thumb/8/85/Tour_Eiffel_Wikimedia_Commons_%28cropped%29.jpg/500px-Tour_Eiffel_Wikimedia_Commons_%28cropped%29.jpg"
  ],
  "maxResultsPerImage": 20
}' |
apify call cheapapi/yandex-reverse-image-search --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,cheapapi/yandex-reverse-image-search"
        }
    }
}
```

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/JbOGbAu4XVHeHEZCY/builds/LcKGpfXFiOEE2c50S/openapi.json