# Yandex Search Results Scraper (`automation-lab/yandex-search-results-scraper`) Actor

Collect ranked organic Yandex results by query and region for scheduled SEO tracking, domain visibility audits, and market research.

- **URL**: https://apify.com/automation-lab/yandex-search-results-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** SEO tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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/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 Search Results Scraper

Collect ranked **Yandex search results** for keywords and save titles, destination URLs, domains, snippets, positions, pages, regions, and collection timestamps.

Use the Actor for scheduled SEO tracking, domain visibility audits, competitor research, and repeatable SERP exports without maintaining your own crawler.

### What does Yandex Search Results Scraper do?

The Actor searches public Yandex web results for every supplied query.

It returns normalized organic records in the default Apify dataset.

Each record includes its source query and one-based rank, making output from recurring runs easy to compare.

The Actor supports:

- 1–50 search queries per run;
- up to 100 organic results per query;
- a run-wide cap of up to 1,000 records;
- numeric Yandex region IDs for localized ranking requests;
- numbered result-page traversal;
- CSV, JSON, Excel, XML, and other Apify dataset exports.

It does not return ads, images, videos, AI answers, or knowledge panels.

### Who is it for?

#### SEO specialists

Track where pages and competitors appear for target keywords on Yandex.

#### Growth and content teams

Find pages currently visible for a topic before planning content or outreach.

#### Market researchers

Export ranked domains and snippets for a repeatable view of a market or category.

#### Agencies

Run separate Tasks for clients, regions, and keyword groups, then schedule those Tasks in Apify Console.

#### Data engineers

Send typed SERP records to a webhook, data warehouse, spreadsheet, or downstream Actor.

### Why use this Actor?

- **Query-aware records:** every row retains the query that produced it.
- **Rank-ready output:** one-based organic positions need no post-processing.
- **Localized requests:** set a Yandex region ID instead of mixing markets silently.
- **Bounded spend:** control both results per query and total records.
- **Integration-ready:** output goes to the default dataset and standard Apify APIs.
- **Honest failures:** challenge pages and unknown upstream HTML are reported as errors, not empty successful runs.

### What data can I extract?

| Field | Type | Meaning |
| --- | --- | --- |
| `query` | string | Search phrase that produced the row |
| `title` | string | Organic result title shown by Yandex |
| `url` | string | Normalized destination URL |
| `domain` | string | Destination hostname without `www.` |
| `snippet` | string or null | Visible result description, when available |
| `rank` | integer | One-based organic position for this query |
| `page` | integer | One-based Yandex results page |
| `regionId` | integer | Yandex region ID used by the request |
| `resultType` | string | Currently always `organic` |
| `fetchedAt` | ISO timestamp | Time the result page was fetched |

### How to scrape Yandex search results

1. Open **Yandex Search Results Scraper** in Apify Console.
2. Add one or more real keywords under **Search queries**.
3. Choose how many organic results to collect per query.
4. Set the total-result cap for the run.
5. Keep region `84` for the United States or enter another Yandex numeric region ID.
6. Click **Start**.
7. Open the **Yandex organic results** dataset view.
8. Export the records or connect the run to another service.

A useful first run is:

```json
{
  "queries": ["yandex search api"],
  "maxResultsPerQuery": 10,
  "maxItems": 10,
  "regionId": 84
}
```

### Input parameters

#### `queries`

Required array of 1–50 non-empty search phrases.

Each phrase can be up to 300 characters.

Yandex operators such as `site:` can be included directly in a query.

Example:

```json
{
  "queries": [
    "seo rank tracker",
    "site:apify.com web scraping"
  ]
}
```

#### `maxResultsPerQuery`

Maximum number of records accepted for each query.

Allowed range: 1–100.

Default: 20.

#### `maxItems`

Run-wide maximum across all queries.

Allowed range: 1–1,000.

Default: 100.

If this cap is reached, later queries may return fewer records or may not run.

#### `regionId`

Numeric Yandex region identifier used to localize the request.

Default: `84` (United States).

For example, `213` represents Moscow.

Region IDs are a Yandex convention and may change independently of this Actor.

### Output example

This shortened record came from the documented `yandex search api` input:

```json
{
  "query": "yandex search api",
  "title": "Yandex Search API",
  "url": "https://yandex.cloud/ru/services/search-api",
  "domain": "yandex.cloud",
  "snippet": "компания Text.ru использует Yandex Search API для проверки уникальности текстов.",
  "rank": 1,
  "page": 1,
  "regionId": 84,
  "resultType": "organic",
  "fetchedAt": "2026-08-11T06:11:02.369Z"
}
```

Search results are live source data, so titles, snippets, URLs, counts, and ranks can change between runs.

### How much does it cost to scrape Yandex search results?

The Actor uses pay-per-event pricing:

- one `start` event per run;
- one `item` event for each accepted dataset record;
- no charge for duplicate, rejected, empty, or failed result rows.

The current price is a **$0.005 start fee** and a BRONZE item price of **$0.003464 per result**, with lower per-result prices on higher plans.

Example BRONZE totals:

| Useful output | Approximate Actor charge |
| ---: | ---: |
| 10 results | $0.03964 |
| 25 results | $0.09160 |
| 100 results | $0.35140 |

These examples describe Actor event charges, not subscription fees. Check the live pricing panel before a production run.

Set `maxItems` and `maxResultsPerQuery` to cap output and therefore control spend.

### Track Yandex rankings on a schedule

Create one Apify Task for a stable set of queries and region.

Run it on a schedule such as daily or weekly.

Keep the dataset or send each run to persistent storage.

Compare rows by `query`, `url`, and `rank` across `fetchedAt` timestamps.

The Actor emits snapshots; it does not maintain historical state or calculate position deltas itself.

### Audit a domain’s Yandex visibility

Use a real `site:` query such as:

```json
{
  "queries": ["site:apify.com web scraping"],
  "maxResultsPerQuery": 20,
  "maxItems": 20,
  "regionId": 84
}
```

Filter the resulting dataset by `domain` and inspect titles, snippets, and ranks.

A `site:` query reflects what Yandex returns for that operator; it is not a complete index export.

### Compare competitors and topics

Supply several commercially related terms in one run:

```json
{
  "queries": [
    "seo rank tracker",
    "serp api",
    "keyword research tool"
  ],
  "maxResultsPerQuery": 10,
  "maxItems": 30,
  "regionId": 84
}
```

Group output by query or domain to see which sites recur across the topic set.

For stable comparisons, keep the query spelling, region, and limits unchanged between scheduled runs.

### Export and integrations

The default dataset works with standard Apify integrations.

Common workflows include:

- export to CSV or Excel for an SEO review;
- send run completion webhooks to Make, Zapier, or n8n;
- append records to Google Sheets;
- load JSON into BigQuery, Snowflake, or a custom warehouse;
- call another Actor after a scheduled run;
- monitor selected domains in your own application.

### Run with the Apify API using cURL

Replace `YOUR_TOKEN` with an Apify API token:

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~yandex-search-results-scraper/runs?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "queries": ["yandex search api"],
    "maxResultsPerQuery": 10,
    "maxItems": 10,
    "regionId": 84
  }'
```

Fetch dataset items after the run finishes:

```bash
curl "https://api.apify.com/v2/datasets/DATASET_ID/items?format=json&clean=true"
```

### Run with JavaScript

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });

const run = await client.actor('automation-lab/yandex-search-results-scraper').call({
  queries: ['yandex search api'],
  maxResultsPerQuery: 10,
  maxItems: 10,
  regionId: 84,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### Run with Python

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ["APIFY_TOKEN"])

run = client.actor("automation-lab/yandex-search-results-scraper").call(run_input={
    "queries": ["yandex search api"],
    "maxResultsPerQuery": 10,
    "maxItems": 10,
    "regionId": 84,
})

items = client.dataset(run["defaultDatasetId"]).list_items().items
print(items)
```

### Use with Apify MCP

#### Claude Code

```bash
claude mcp add --transport http apify \
  "https://mcp.apify.com?tools=automation-lab/yandex-search-results-scraper"
```

#### Claude Desktop, Cursor, and VS Code

Add this HTTP MCP server in the client’s MCP JSON configuration:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/yandex-search-results-scraper"
    }
  }
}
```

Example prompts you can ask through MCP:

- “Run Yandex Search Results Scraper for `yandex search api`, return 10 US-region results, and summarize the top domains.”
- “Collect the first Yandex result page for `site:apify.com web scraping` and return title, URL, snippet, and rank.”
- “Compare domains ranking for `seo rank tracker`, `serp api`, and `keyword research tool`.”

### Tips for reliable tracking

- Use the same exact query text and `regionId` across comparison runs.
- Keep scheduled batches moderate instead of requesting the 1,000-record maximum by default.
- Preserve `fetchedAt` and run IDs in downstream storage.
- Compare canonical `url` values rather than titles alone.
- Expect natural ranking movement and personalization differences from interactive browser searches.
- Retry a failed upstream run later instead of treating it as an empty ranking snapshot.

### Limitations

- The Actor currently extracts organic web results only.
- It does not solve CAPTCHA challenges.
- It uses a public server-rendered Yandex search surface that can change without notice.
- The public source may return fewer results than the requested maximum.
- Numeric region IDs are accepted, but Yandex ultimately controls localization behavior.
- Results may differ from a logged-in, personalized, or differently located browser session.
- The Actor does not provide search volume, CPC, keyword difficulty, alerts, or historical storage.
- A successful run is a point-in-time snapshot, not proof of complete Yandex index coverage.

### Failure behavior and troubleshooting

#### Why did my run return fewer rows than requested?

Yandex may expose fewer organic records for a query, `site:` operator, region, or later page. The Actor stops normally when no more valid cards are available.

#### Why did the run fail with a CAPTCHA message?

Yandex challenged the request. The Actor fails explicitly to avoid producing a misleading empty dataset. Wait and rerun rather than immediately repeating many requests.

#### Why is my query rejected?

Check that `queries` is a non-empty string array, contains at most 50 entries, and has no blank value. Also verify numeric limits are within their documented ranges.

#### Why do ranks differ from my browser?

Browser login state, location, region, time, and personalization can influence results. Use the same Actor settings for consistent scheduled comparisons.

#### How do I inspect a failed run?

Open the run log in Apify Console. The final error distinguishes malformed input, an upstream challenge, an HTTP failure, and an unrecognized page shape.

### Responsible use and legality

This Actor collects publicly displayed search-result metadata.

You are responsible for ensuring that your use complies with applicable laws, contracts, website terms, and organizational policies.

Do not use output to profile people, evade access controls, overload Yandex, or republish protected content unlawfully.

Use conservative limits and schedules. Store only the data needed for a legitimate SEO, research, or automation purpose.

### Related Automation Lab Actors

- [Google Organic Rank Tracker](https://apify.com/automation-lab/seo-rank-tracker) for recurring Google position tracking.
- [Keyword Search Volume Checker Scraper](https://apify.com/automation-lab/bulk-keyword-metrics-checker) for keyword metrics rather than Yandex result pages.
- [Bing Search Scraper](https://apify.com/automation-lab/bing-search-scraper) for normalized Bing result records.

These Actors cover different sources or metrics; they are not automatic fallbacks for this Yandex Actor.

### FAQ

#### Does this Actor require a Yandex account or API key?

No. It uses a public Yandex results surface and does not ask for Yandex credentials.

#### Can I search multiple keywords?

Yes. Add up to 50 queries and use `maxItems` as the total run cap.

#### Can I collect more than one result page?

Yes. Set `maxResultsPerQuery` above 10, up to 100.

#### Does it return paid ads?

No. Every emitted row has `resultType: "organic"`.

#### Can I schedule rank tracking?

Yes. Save the input as an Apify Task and attach a schedule. Historical comparison remains a downstream workflow.

#### Can I choose a country?

Use the numeric `regionId`. The default is 84 for the United States. Yandex controls how the region affects the returned rankings.

#### Are results guaranteed to stay identical?

No. Search rankings and source snippets are live and can change at any time.

#### Where are the records stored?

In the run’s default Apify dataset, available through Console, API, downloads, and integrations.

# Actor input Schema

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

Keywords or phrases to search on Yandex. Each result keeps its query and rank so recurring runs can be compared.

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

Maximum organic Yandex results to collect for each query, across result pages.

## `maxItems` (type: `integer`):

Run-wide cap across all queries. Useful for controlling dataset size and spend.

## `regionId` (type: `integer`):

Numeric Yandex region ID used to localize rankings. The default 84 represents the United States; for example, 213 represents Moscow.

## Actor input object example

```json
{
  "queries": [
    "yandex search api"
  ],
  "maxResultsPerQuery": 20,
  "maxItems": 20,
  "regionId": 84
}
```

# Actor output Schema

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

Open the ranked organic result records in the overview table.

# 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": [
        "yandex search api"
    ],
    "maxResultsPerQuery": 20,
    "maxItems": 20,
    "regionId": 84
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/yandex-search-results-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": ["yandex search api"],
    "maxResultsPerQuery": 20,
    "maxItems": 20,
    "regionId": 84,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/yandex-search-results-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": [
    "yandex search api"
  ],
  "maxResultsPerQuery": 20,
  "maxItems": 20,
  "regionId": 84
}' |
apify call automation-lab/yandex-search-results-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,automation-lab/yandex-search-results-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/XHpXrhbdhhbfqDYtp/builds/xjjMtRMhN8TTVtrNe/openapi.json