# Yandex Search Scraper (`searchapi/yandex-search-scraper`) Actor

Scrapes Yandex Search for any query. Extracts the full canonical search-vertical schema: title, URL, snippet, sitelinks, related links, passages, dates, thumbnail, language, ad/Yandex Direct flags, and more.

- **URL**: https://apify.com/searchapi/yandex-search-scraper.md
- **Developed by:** [Search API](https://apify.com/searchapi) (community)
- **Categories:** SEO tools, Developer tools, Other
- **Stats:** 4 total users, 0 monthly users, 12.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.99 / 1,000 search results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

Search Yandex using keywords and the same region, language, time, family, and site filters a visitor would choose. The Actor supports one query or a deduplicated list and enforces one global maximum across the run.

### Output

Each organic result can include stable identity and ranking fields, title and snippet text/HTML, canonical destination and displayed URLs, domain, favicon, thumbnail, highlighted terms, breadcrumbs, labels, sitelinks, rich-result ratings/reviews/prices, date information, advertising/official flags, search context, extraction method, and timestamp.

Optional values are omitted when Yandex does not expose them. Records never contain placeholder `null`, empty strings/arrays, CAPTCHA pages, or raw transport responses.

### Inputs

| Field | Purpose | Default |
| --- | --- | --- |
| `query` | Primary Yandex query | `artificial intelligence` |
| `queries` | Additional deduplicated queries | `[]` |
| `site` | Optional `site:` domain filter | empty |
| `lr` | Numeric Yandex region code | automatic |
| `country` | Optional proxy-country alignment | automatic |
| `language` | Search/interface language | `en` |
| `timeRange` | Any time, past day, week, or month | any |
| `familyFilter` | Off, moderate, or strict | `moderate` |
| `maxItems` | Global unique-record limit | `20` |
| `maxPages` | Maximum pages per query | `5` |
| `maxConcurrency` | Parallel pages | `2` |
| `proxyConfiguration` | Apify or user-provided proxies | Residential |

Example:

```json
{
  "query": "machine learning",
  "queries": ["large language models"],
  "lr": "213",
  "language": "en",
  "timeRange": "7",
  "familyFilter": "moderate",
  "maxItems": 30,
  "maxPages": 3,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"]
  }
}
```

### Reliability

The Actor validates status and content type before parsing, uses country/language-consistent desktop fingerprints, short-lived persistent sessions, stable canonical-URL deduplication, and bounded retries for temporary HTTP/proxy/browser failures. Explicit CAPTCHA or robot-verification pages are terminal, marked `TARGET_BLOCKED`, and never stored or bypassed. Confirmed no-result searches finish successfully with an empty dataset; selector drift fails visibly.

### Local development

```bash
npm ci
npm test
apify run
```

The checked-in `INPUT.json` disables proxy use for local diagnosis. Cloud runs use the input schema's Residential default.

# Changelog

This Actor's version history is a separate document: https://apify.com/searchapi/yandex-search-scraper/changelog.md

# Actor input Schema

## `query` (type: `string`):

Primary query to search on Yandex.

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

Optional additional searches processed during the same run. Duplicates are removed.

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

Optional domain to restrict results, such as example.com. The Actor adds Yandex's site: query operator.

## `lr` (type: `string`):

Numeric Yandex region code, for example 213 for Moscow or 84 for the United States.

## `country` (type: `string`):

Optional two-letter country code. It aligns an unspecified Residential proxy country with the requested market.

## `language` (type: `string`):

Yandex interface/search language code.

## `timeRange` (type: `string`):

Restrict results using Yandex's within filter.

## `familyFilter` (type: `string`):

Family/safe-search filtering sent to Yandex.

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

Maximum unique results across all queries.

## `maxPages` (type: `integer`):

Maximum result pages planned for each query.

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

Maximum parallel Yandex page requests.

## `maxRequestRetries` (type: `integer`):

Retries temporary HTTP, proxy, and browser failures. Explicit CAPTCHA pages are terminal.

## `navigationTimeoutSecs` (type: `integer`):

Maximum initial-navigation duration.

## `requestHandlerTimeoutSecs` (type: `integer`):

Maximum duration for one Yandex result page.

## `resultsWaitSecs` (type: `integer`):

Maximum wait for results, an empty result, or explicit blocking.

## `proxyConfiguration` (type: `object`):

Supports Apify Proxy, proxy country/groups, or user-provided proxy URLs.

## Actor input object example

```json
{
  "query": "artificial intelligence",
  "queries": [],
  "site": "",
  "lr": "",
  "country": "",
  "language": "en",
  "timeRange": "",
  "familyFilter": "moderate",
  "maxItems": 20,
  "maxPages": 5,
  "maxConcurrency": 2,
  "maxRequestRetries": 2,
  "navigationTimeoutSecs": 45,
  "requestHandlerTimeoutSecs": 90,
  "resultsWaitSecs": 12,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# 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 = {
    "query": "artificial intelligence",
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("searchapi/yandex-search-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 = {
    "query": "artificial intelligence",
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("searchapi/yandex-search-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 '{
  "query": "artificial intelligence",
  "maxItems": 20
}' |
apify call searchapi/yandex-search-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,searchapi/yandex-search-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/08n3bMfGIL8qvduzG/builds/lbR8cybpH4LuhvX3H/openapi.json