# Yandex Images Scraper (`apt_marble/yandex-images-scraper`) Actor

Search Yandex Images and get every result as a clean row: full-size picture address, pixel size, file size, thumbnail, title and the page it appears on. Filter by size, shape and picture type. Around 1,200 different pictures per search term, with repeats reported once.

- **URL**: https://apify.com/apt\_marble/yandex-images-scraper.md
- **Developed by:** [Hamza](https://apify.com/apt_marble) (community)
- **Categories:** SEO tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$0.30 / 1,000 image founds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#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

## Yandex Images Scraper

Type in what you are looking for and get Yandex's picture results as a clean table. Every row is one picture: where the full-size file lives, how many pixels wide and tall it is, how many bytes it weighs, a thumbnail, its title, and the web page it appears on. Filter by size, by shape and by kind of picture. Nothing to configure, no account to create — enter your search terms and run it.

Yandex is the strongest picture index for Russian, Cyrillic and CIS content, and it indexes a very different slice of the web from the search engines most tools cover. If your work depends on finding pictures that Western indexes simply do not hold, this is the shortest route to them.

### What you can do with it

- **Build a picture set for machine learning.** Thousands of full-size addresses with exact pixel and byte sizes, so you can select by resolution before you download anything.
- **Find where your photography has been re-used.** Search your product or brand names and see every page that publishes a matching picture, with its domain.
- **Source product shots.** Search a model name and get every listing photo the index holds, ranked as shoppers see them, with the shop page each one sits on.
- **Audit picture visibility.** See which sites own the picture results for your category, and where your own pictures rank against them.
- **Prospect for links and partners.** The domain column turns a picture search into a list of sites publishing about your subject.
- **Feed a design or moodboard pipeline.** Filter to large landscape photographs, or to line drawings only, and get a ready-made table of candidates.

### What you get

One row per picture. An abridged real example:

```json
{
  "query": "кошка",
  "position": 1,
  "page": 1,
  "imageUrl": "https://biosfera.vet/wp-content/uploads/2017/02/081.jpg",
  "width": 730,
  "height": 486,
  "fileSizeBytes": 96185,
  "thumbnailUrl": "https://avatars.mds.yandex.net/i?id=fc43601ccabad6df317f586f0b47c2229789132e-13307699-images-thumbs&n=13",
  "thumbnailWidth": 480,
  "thumbnailHeight": 320,
  "title": "В мире животных Ветклиника БИОСФЕРА",
  "description": "Ученые рассказал, что у кошек несколько типов личности.",
  "sourcePageUrl": "https://biosfera.vet/v-mire-zhivotnyh/",
  "sourceDomain": "biosfera.vet",
  "requestedRegionId": null,
  "regionId": null,
  "regionName": null,
  "collectedAt": "2026-08-17T11:44:02.000Z"
}
```

Results also come as a ready-made table view and as a spreadsheet download.

### Input reference

| Field | Type | Default | What it does |
| --- | --- | --- | --- |
| **Search terms** | list of text | — | The terms to look up. One row is produced for each different picture found. Terms in Russian return the richest results, but any language works. |
| **Images per search term** | whole number | 100 | How many different pictures to collect for each term. Maximum 1500; in practice the source makes roughly 1,200 different pictures available for any one term. |
| **Image size** | choice | Any size | Keep only large, medium or small pictures. Large is roughly 1,200 px wide and up, medium roughly 700 px, small roughly 250 px. |
| **Orientation** | choice | Any orientation | Keep only landscape, portrait or square pictures. |
| **Image type** | choice | Any type | Keep only photographs, clipart, line drawings, or captioned poster pictures. |
| **Market** | choice | Source default | Rank results the way people in one market see them — Moscow, Saint Petersburg, sixteen other Russian regions, Belarus and Kazakhstan. On picture search this is a ranking preference rather than a strict filter. |
| **Search terms at a time** | whole number | 3 | How many terms to work through at once. Higher finishes a long list sooner; lower is gentler on the source. Maximum 10. |

### Output fields

| Field | What it is |
| --- | --- |
| `query` | The search term this picture was found for. |
| `position` | Where the source ranked it, counted from 1. Gaps appear where a repeat was removed. |
| `page` | Which result page it came from. |
| `imageUrl` | Address of the full-size picture. |
| `width` / `height` | Its size in pixels. |
| `fileSizeBytes` | Its weight in bytes. |
| `thumbnailUrl` | A small preview version. |
| `thumbnailWidth` / `thumbnailHeight` | The preview's size in pixels. |
| `title` | The title the source shows for the result. |
| `description` | The short text the source shows underneath it. |
| `sourcePageUrl` | The web page the picture appears on. |
| `sourceDomain` | That page's domain. |
| `requestedRegionId` | The market you chose, or empty if you chose none. |
| `regionId` | The market this row belongs to: the one you chose, or — when you chose none — the one the source picked by itself. |
| `regionName` | The English name of that market. Filled when you chose a market; empty when you did not, because the market the source picks by itself has no name to show. |
| `collectedAt` | When the row was collected. |

Any field the source does not publish for a given picture comes back empty. It is never filled with a zero, a guess, or a value taken from another row.

### Pricing

You pay per picture collected — nothing else.

| What you pay for | Price |
| --- | --- |
| Each picture collected (one row) | $0.30 per 1,000 |

**Worked example.** Ten search terms, 100 pictures each, is 1,000 rows and costs **$0.30**. Taking one broad term all the way to the bottom of what the source publishes — around 1,200 different pictures — costs about **$0.36**.

A search term that genuinely returns nothing costs you nothing, because nothing was collected. Repeats the source shows more than once are reported once and charged once.

### Limits & what this actor cannot do

- **The source publishes a limited number of results for any one search term.** It stops at roughly 1,200 different pictures, and it repeats some of them along the way. Repeats are reported once, so a term taken to full depth typically yields between 1,000 and 1,300 rows, not more. Asking for more than that returns everything the source makes available.
- **Results are a snapshot at the moment of collection.** The source's own picture results change continuously, and the same term run tomorrow will not return an identical list.
- **No licence, copyright, author or capture date is available.** The source does not publish rights information, photographer names, upload dates or camera details for picture results, so this actor cannot report them. Check the rights on each picture at its source page before you use it.
- **Addresses point at other people's sites.** A picture can be moved or taken down by whoever publishes it, so an address collected today may stop working later. The actor reports what the source publishes at the time of the run and does not download the picture files themselves.
- **This is a text search, not a picture-matching search.** You search with words. You cannot upload a picture and ask what it looks like.
- **A term the source cannot match closely is answered with loosely related pictures rather than with nothing.** Nonsense and very unusual terms still come back full. The source does not reliably say when it has widened a search, so a term returning results is not by itself proof that the results are a close match. Check a sample before you rely on an unusual term.
- **The market setting nudges ranking rather than filtering.** Choosing a market changes which pictures rank highest and does genuinely change the result set, but pictures from elsewhere still appear. **The source does not report back which market it actually used on picture search**, so this actor cannot tell you when it has ignored your choice, and it does not pretend to: `regionId` is the market you chose. If you pick no market, the source picks one and the row records that one — and in practice `regionName` is then empty on every row, because the market the source picks by itself is not one of the markets offered here and no English name is known for it. Pick a market if you want that column filled.
- **A search that stops before the source runs out is reported as incomplete**, with the pictures it did collect kept, rather than being presented as the whole of what the source holds.
- **Square is approximate.** Landscape and portrait are applied strictly by the source; square includes pictures that are close to square rather than exactly square.
- **Only what the public can see.** The actor does not sign in, sees nothing behind a login, and cannot reveal anything the source keeps private.
- **A search the source refuses to complete is reported as a failed search, never as "no results found".** The run summary counts searches that produced pictures, searches that genuinely found nothing, and searches that could not be completed as three separate figures.
- **Incomplete results are detected and re-read automatically**, so a result page the source hands back empty by mistake does not silently cut a collection short.
- **Speed depends on the size of the job and on the source's own response times.** No fixed speed is promised.
- **The source's terms govern automated access.** You are responsible for using the data lawfully and in line with those terms, and for handling any personal data in line with applicable privacy law, including GDPR and Russian personal data law where they apply.

### FAQ

**Do I need an account on the source site?**
No. There is nothing to sign up for and nothing to connect.

**Does it need my login or password?**
No. It never asks for one and could not use one.

**Can I schedule it?**
Yes. Run it on any schedule and each run produces a fresh snapshot you can compare against the last.

**Why did I get fewer pictures than I asked for?**
Because the source ran out. It publishes a limited number of different pictures for any one term, and it repeats some of them across its own result pages. Repeats are reported once, so the honest count is lower than the raw number of results the source hands over.

**Are the picture files themselves downloaded?**
No. You get the address of each full-size picture, its dimensions and its weight in bytes, so you can decide what to fetch and fetch only that.

**Does it tell me whether a picture is free to use?**
No, and no picture search on this source can. Rights information is not published alongside the results. Use the source page address in each row to check the terms yourself.

**Do the filters actually change the results?**
Yes. Every filter offered here was verified to change the result set: size shifts the typical width from roughly 250 px to roughly 1,200 px, orientation applies to every row returned, and each picture type returns a substantially different set from the same term. Filters that did nothing were left out rather than offered.

# Actor input Schema

## `queries` (type: `array`):

The terms to search for, up to 200 in one run. One row is produced for each different picture found. Terms in Russian return the richest results, because this is the largest Russian-language picture index — but any language works.

## `maxResultsPerQuery` (type: `integer`):

How many different pictures to collect for each search term. The source publishes about 1,200 different pictures for any one search, so a higher number simply collects everything it makes available.

## `imageSize` (type: `string`):

Keep only pictures in this size class. Large returns roughly 1,200 px wide and up, medium roughly 700 px, small roughly 250 px. Leave on Any size to get the full mix.

## `orientation` (type: `string`):

Keep only pictures with this shape. Landscape and portrait are applied strictly; square is applied approximately, so a few near-square pictures can appear.

## `imageType` (type: `string`):

Keep only one kind of picture: photographs, clipart, line drawings, or captioned poster images. Each returns a noticeably different set from the same search term.

## `region` (type: `string`):

Rank results the way people in this market see them. On picture search this is a ranking preference rather than a strict filter, so pictures from elsewhere can still appear. Every row records the market the source itself stated it answered for. Leave empty to use the source's own default.

## `maxConcurrency` (type: `integer`):

How many search terms to work through at once. Raising this finishes a long list sooner; lowering it is gentler on the source and slightly more reliable on very large jobs.

## Actor input object example

```json
{
  "queries": [
    "ноутбук",
    "coffee shop interior"
  ],
  "maxResultsPerQuery": 100,
  "imageSize": "any",
  "orientation": "any",
  "imageType": "any",
  "region": "",
  "maxConcurrency": 3
}
```

# Actor output Schema

## `images` (type: `string`):

Every picture collected in this run, with all fields.

## `overview` (type: `string`):

The same pictures as a table, in the order the source ranked them.

## `spreadsheet` (type: `string`):

The pictures as a spreadsheet file.

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

How many search terms produced pictures, how many genuinely found nothing, and how many could not be completed.

# 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 = {
    "queries": [
        "ноутбук"
    ],
    "maxResultsPerQuery": 100,
    "imageSize": "any",
    "orientation": "any",
    "imageType": "any",
    "maxConcurrency": 3
};

// Run the Actor and wait for it to finish
const run = await client.actor("apt_marble/yandex-images-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 = {
    "queries": ["ноутбук"],
    "maxResultsPerQuery": 100,
    "imageSize": "any",
    "orientation": "any",
    "imageType": "any",
    "maxConcurrency": 3,
}

# Run the Actor and wait for it to finish
run = client.actor("apt_marble/yandex-images-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 '{
  "queries": [
    "ноутбук"
  ],
  "maxResultsPerQuery": 100,
  "imageSize": "any",
  "orientation": "any",
  "imageType": "any",
  "maxConcurrency": 3
}' |
apify call apt_marble/yandex-images-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,apt_marble/yandex-images-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/fvGO7GjePxvSD5r4X/builds/ZdNhWueDFxSl0gcVC/openapi.json