# Apify Yandex Scraper Bulk Serp

> A yandex scraper for bulk SERP collection where the bill is predictable, powered by the Apify Yandex Search per-result Actor (johnvc/yandex-scrape-yandex-search-results-at-scale---per-result). Run a keyword list through Yandex across 6 domains, 19 languages, and any lr region, and get structured items back with organic rows (position, title, link, displayed_link, snippet) plus optional ads, knowledge graph, and inline media, each result type billed as its own item so you pay only for what you collect. Use when the user wants a yandex scraper, wants yandex data or Yandex search results as JSON or CSV in volume, wants to scrape many Yandex queries at scale, needs a per-result cost model instead of per-run fees, or is building a Russian-market SERP dataset. Pay-per-result billing, MCP-ready for Claude and other AI agents.

- Skill: `johnisanerd/apify-yandex-scraper-bulk-serp` (Agent Skill, multi-file: 3 files)
- Install (CLI): `npx skillmds@latest add johnisanerd/apify-yandex-scraper-bulk-serp`
- Raw SKILL.md: https://api.skillmd.com/api/skills/johnisanerd/apify-yandex-scraper-bulk-serp/raw
- Safety review: pending
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: Data & Analytics
- License: MIT
- Author: johnisanerd (https://skillmd.com/u/johnisanerd)
- Updated: 2026-09-17
- Page: https://skillmd.com/skills/johnisanerd/apify-yandex-scraper-bulk-serp

---


# Yandex Scraper: Bulk SERP Collection, Billed Per Result

Collect Yandex search results in volume with a cost you can predict before you start. Every item you get is one page of one result type, and that item is exactly what you pay for, which makes a keyword list easy to budget.

## When to use this skill

- The user wants a Yandex scraper for many queries, not a single lookup.
- They want Yandex data as JSON or CSV for a keyword list, a market, or a research dataset.
- They want the bill to scale with results collected rather than with runs started.
- They are building a Russian-market or CIS-market SERP dataset and want organic results plus, where useful, ads, knowledge graph, or inline media.

Not for: tracking one keyword's position over time (use the companion Yandex rank tracker skill), reverse image lookups (use the Yandex Reverse Image Search Actor), or Google SERPs.

## What you get (one dataset item per page, per result type)

A run returns one item per page for each result type you turned on, tagged with `item_type` (`organic` on a default run). The rows live in a nested array on that item. `organic_results` rows carry `position`, `title`, `link`, `displayed_link`, and `snippet`. The other type arrays are `ads_results`, `knowledge_graph`, `inline_images`, `inline_videos`, `image_results`, and `video_results`, and they come back empty when that type is off or absent from the SERP.

Every item also carries the query context and pagination state, which is what makes bulk output joinable: `text`, `yandex_domain`, `lang`, `lr`, `max_pages`, `sort_mode`, `period`, `search_timestamp`, `search_domain`, `search_domain_description`, `search_language`, `search_language_description`, `search_location`, `page_number`, `total_pages`, `pages_processed`, `results_per_page`, `result_count`, `total_results_found`, `pagination_limit_reached`, `max_pages_set`, and `pagination_stopped_by_limit`.

## Prerequisites

- Apify account (sign up at https://apify.com?fpr=9n7kx3&fp_sid=skillrepo).
- Authentication via `apify login`, or an `APIFY_TOKEN` environment variable (Apify Console, Settings, Integrations).

## The Actor

- Store page: https://apify.com/johnvc/yandex-scrape-yandex-search-results-at-scale---per-result?fpr=9n7kx3&fp_sid=skillrepo
- Actor ID: `johnvc/yandex-scrape-yandex-search-results-at-scale---per-result`
- Pricing: pay per result, meaning per dataset item, plus a negligible start fee (see `references/gotchas.md`).

## Run it with the Apify CLI

One query, two pages of organic results, which is two billable items:

```bash
apify actors call "johnvc/yandex-scrape-yandex-search-results-at-scale---per-result" -i '{"text":"crm software","yandex_domain":"yandex.com","lang":"en","lr":"84","max_pages":2}' \
  --json \
  --user-agent apify-awesome-skills/apify-yandex-scraper-bulk-serp \
  2>/dev/null
```

A commercial Russian query with ads and knowledge graph added, which bills the extra types as their own items:

```bash
apify actors call "johnvc/yandex-scrape-yandex-search-results-at-scale---per-result" -i '{"text":"доставка цветов","yandex_domain":"yandex.ru","lang":"ru","lr":"213","include_ads":true,"include_knowledge_graph":true,"max_pages":1}' \
  --json \
  --user-agent apify-awesome-skills/apify-yandex-scraper-bulk-serp \
  2>/dev/null
```

Pull a finished run's dataset for export, at no extra charge:

```bash
apify datasets get-items <DATASET_ID> --format json --user-agent apify-awesome-skills/apify-yandex-scraper-bulk-serp 2>/dev/null
```

Every call carries the three flags this repo expects, `--json` (or `--format json`), `--user-agent apify-awesome-skills/apify-yandex-scraper-bulk-serp`, and `2>/dev/null`.

## Run it from Claude or another AI agent (MCP)

The Actor is MCP-ready. Add the hosted server URL:

`https://mcp.apify.com/?tools=actors,docs,johnvc/yandex-scrape-yandex-search-results-at-scale---per-result`

Then ask, for example, "Collect the first page of yandex.ru results for these ten keywords in Moscow and give me one CSV row per link." MCP setup docs: https://docs.apify.com/platform/integrations/mcp

## Workflow

1. Write the keyword list first. `text` takes one query per run, so a list of 30 keywords is 30 runs. Build the list before you spend anything.
2. Fix the market once and reuse it. Set `yandex_domain`, `lang`, and `lr` the same way across the whole batch so the collected rows are comparable.
3. Decide which result types you actually need. Organic is on by default. Each of `include_ads`, `include_knowledge_graph`, `include_inline_images`, `include_inline_videos`, `include_image_search`, and `include_video_search` adds its own items per page, so each one multiplies the bill.
4. Do the arithmetic before the batch. Items are roughly keywords times pages times result types enabled. Multiply by the live per-item price in `references/gotchas.md`, then confirm with the user if the batch is large.
5. Run the batch, then read every dataset. Re-reading datasets is free, so collect once and export as many times as you like.
6. Flatten for analysis. Filter items by `item_type`, walk the nested array, and emit one row per result with the parent item's `text`, `search_timestamp`, `search_location`, and `page_number` copied down. That is your CSV.

## Inputs

- `text` (string, required): the query, supporting the operators yandex.com supports such as `site:`
- `yandex_domain` (enum, 6 domains, default `yandex.com`)
- `lang` (enum, 19 languages) and `lr` (region ID string, for example `213` Moscow, `225` Russia, `84` USA)
- `include_organic_results` (default true), plus `include_ads`, `include_knowledge_graph`, `include_inline_images`, `include_inline_videos`, `include_image_search`, `include_video_search` (booleans, each billed as its own items)
- `max_pages` (integer, default 2, max 100, 0 for no cap): the main cost lever
- `sort_mode` (`relevance` or `date`) and `period` (`all`, `day`, `last_two_weeks`, `month`) for a fresher slice
- Image filters (`image_type`, `image_color`, `image_orientation`, `image_file_type`, `image_width`, `image_height`, `image_site`, `image_recent`) and video filters (`video_duration`, `video_hd`) apply only to the dedicated verticals

## Cost

Billing is per dataset item, and an item is one page of one result type. Organic-only, one page per keyword, means one item per keyword, which is the cheapest way to sweep a large list. Turning on two extra result types roughly triples the item count for the same pages. Estimate as keywords times pages times enabled types, then price it with the live per-item figure in `references/gotchas.md`.

## Honest limits

- One query per run. Batching a keyword list means orchestrating multiple runs from your side.
- Results are not flat. Rows are nested inside `organic_results` and friends, so a CSV export needs the flattening step in the workflow.
- Ads, knowledge graph, and inline media appear only when Yandex shows them for that query, so enabling a type does not guarantee items of that type.
- Positions and result sets vary by region and shift over time. A bulk collection is a snapshot with a `search_timestamp`, not a stable index.
- Only the fields listed above are guaranteed. Anything extra shows up only when Yandex includes it.

## Troubleshooting

- Bill higher than expected: count enabled result types, not just pages. Each type on each page is a separate item.
- Empty dataset for a keyword: check the query manually on the chosen `yandex_domain`, and broaden it.
- Wrong-market results: `lr` alone does not switch language. Set `yandex_domain`, `lang`, and `lr` together.
- Fewer pages than `max_pages`: Yandex ran out of results. Check `pagination_limit_reached` and `pages_processed`.
- Do not re-run the Actor just to re-export. Read the existing dataset again with the export command above, which costs nothing.

See `references/gotchas.md` for cost guardrails and error recovery, and `references/actor-index.md` for the Actor routing table.

## Related Yandex and international SERP Actors

- Yandex Search Scraper, pay per event edition (per-run start fee plus per page): https://apify.com/johnvc/Scrape-Yandex?fpr=9n7kx3&fp_sid=skillrepo
- Yandex Reverse Image Search API: https://apify.com/johnvc/yandex-reverse-image-search?fpr=9n7kx3&fp_sid=skillrepo
- Baidu Search Scraper (Chinese market): https://apify.com/johnvc/Baidu-Search-Scraper?fpr=9n7kx3&fp_sid=skillrepo
- Naver Search API (Korean market): https://apify.com/johnvc/naver-search-api?fpr=9n7kx3&fp_sid=skillrepo