# Yandex Maps Scraper | Парсер Яндекс Карт - Places & Reviews (`s-r/yandex-maps-scraper`) Actor

Collect Yandex Maps business places, addresses, phones, websites, ratings and optional reviews for Russia, CIS markets and Turkey. Search by term and city, map region, coordinates, URL or organization ID, and export linked place and review rows.

- **URL**: https://apify.com/s-r/yandex-maps-scraper.md
- **Developed by:** [SR](https://apify.com/s-r) (community)
- **Categories:** Lead generation, Business
- **Stats:** 1 total users, 0 monthly users, 96.2% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 1,000 places

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/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 Maps Scraper

Yandex Maps Scraper collects business places, contact details, ratings and optional reviews from Yandex Maps. Search businesses in Russia, CIS markets and Turkey, then export linked place and review records for local SEO, lead research and market analysis. Russian-speaking teams know this kind of tool as a парсер Яндекс Карт: give it a business term and a city, and it returns a clean table of organizations with phones, websites, coordinates and ratings, plus their reviews when you ask for them.

### What the Yandex Maps scraper returns

Each business appears as a place row. The record includes its Yandex organization ID, public page URL, name, full address, coordinates, categories, average rating, review count, phone number, website and available opening hours. Extra fields include social links, chain name, rating count, advertised placement status and the language-specific address components supplied by Yandex.

When reviews are enabled, each review appears as a separate row. It contains a stable review ID, the organization ID, place name and URL, rating, original text, author display name, date, likes and any owner reply. You can join reviews to their business records using `place_id`. This structure works with spreadsheets and databases without unpacking a nested reviews column.

### Input: choose businesses and scope for the Yandex Maps scraper

Provide at least one search term, organization URL or organization ID. The `queries` array accepts business terms such as the Russian word for cafes. Add `location` to resolve a city to its map area, include the city directly in the term, or use `region_id` to select a Yandex Maps region. Explicit coordinates take precedence over the region ID, and the region ID takes precedence over the city name. A region ID comes from the numeric segment in the city's Maps URL. For example, Moscow uses 213 and Saint Petersburg uses 2.

For a specific map area, use `ll` with longitude followed by latitude and optionally `zoom`. Coordinates take precedence over `region_id`. If you do not specify a city or map area, Moscow is the initial map center. A city included in the search text can still direct the search elsewhere, so provide explicit scope when building a regional business list.

Use `start_urls` for existing Yandex Maps searches or organization pages. Organization URLs ending in `/reviews/` also identify the business; enable `include_reviews` to collect its reviews. Use `place_ids` when you already know the numeric organization IDs. Every organization is looked up before reviews are collected.

The three source arrays can contain up to 50 entries in total. `max_places` defaults to 100 unique businesses per search and accepts values from 1 to 1000. `language` accepts `ru`, `en` or `tr`. It controls the business names, addresses and categories returned by Yandex. Reviews retain their original text rather than receiving an automatic translation.

To collect reviews, set `include_reviews` to true. `max_reviews` defaults to 20 per business and accepts values from 0 to 600. Set `reviews_sort` to `newest`, `relevance`, `rating_asc` or `rating_desc`. A value of zero disables review collection even when the review switch is enabled.

### Output: business rows and review rows

Every row includes `row_type`, `_type`, `row_id`, `source`, `platform` and `fetched_at`. Place rows have `row_type: "place"` and `_type: "local.place"`. Review rows have `row_type: "review"` and `_type: "local.review"`. Filter on this discriminator before counting businesses or calculating review statistics.

Missing optional values are null. Some organizations have no website or phone number. The source does not expose business email addresses in these responses, so the actor does not supply an email field. Review counts and rating counts are separate: a person can leave a rating without writing a review, and the two totals may differ.

Website URLs have Yandex advertising tracking parameters removed. The original URL list remains available in `urls`. Opening hours use seven daily lists, beginning with Sunday at index zero. Each interval has `from` and `to` strings in 24-hour format; midnight appears as `00:00`. The `is_open_now` field is a snapshot taken when Yandex returns the business record.

Review `published_at` uses the last update timestamp supplied by Yandex. It can represent an edit, because the source does not provide a separate original publication timestamp here. Owner reply dates follow the same rule. Read these fields as the platform's available timestamps when studying review activity.

Download dataset rows as JSON, CSV, Excel or another export format supported by Apify. Use JSON when retaining arrays such as categories, opening hours and social links. The run output also contains summary counts, warnings and continuation information for an unfinished collection.

### Example output from Yandex Maps

A run with `place_ids: ["19464848293"]`, `include_reviews: true` and `max_reviews: 10` returns the restaurant first, then its reviews. Below is the place row, shortened to its main fields:

```json
{
  "_type": "local.place",
  "row_type": "place",
  "place_id": "19464848293",
  "name": "Рыба моя",
  "url": "https://yandex.com/maps/org/ryba_moya/19464848293/",
  "address": "Москва, Славянская площадь, 2",
  "postal_code": "109012",
  "country_code": "RU",
  "lat": 55.753391,
  "lng": 37.633956,
  "categories": ["Ресторан", "кафе", "бар"],
  "rating": 4.9,
  "reviews_count": 2735,
  "ratings_count": 6116,
  "phone": "+7 (495) 784-68-58",
  "website": "https://rybamoya.ru/",
  "opening_hours_text": "ежедневно, 12:00–00:00",
  "social_links": [{"type": "telegram", "url": "https://t.me/perelmanrestaurants"}],
  "is_verified_owner": true
}
```

One of the review rows from the same run, with the owner's reply:

```json
{
  "_type": "local.review",
  "row_type": "review",
  "review_id": "Qs_25TigSlfs1chDCLTL30CTRi-nFg9",
  "place_id": "19464848293",
  "place_name": "Рыба моя",
  "rating": 5,
  "text": "Здравствуйте.\nОтмечала день рождения🤗\nВсе было на высшем уровне: еда, напитки, сервис и атмосфера👍👍👍🙏🙏🙏\n",
  "author_name": "Kaen",
  "published_at": "2026-09-27T12:58:47.376Z",
  "language": "ru",
  "likes": 3,
  "reply_text": "Добрый день!\nСпасибо за вашу высокую оценку! Нам приятно быть частью Ваших приятных моментов. Обязательно заходите снова — будем рады порадовать Вас новыми блюдами и атмосферой.\nС уважением, команда «Рыба моя»\n",
  "reply_at": "2026-09-28T10:09:15.463Z"
}
```

### Use cases for a Yandex Maps scraper

- **Local SEO in Russia, CIS and Turkey.** Track how your clients and their competitors rank for a business term in a city, compare ratings and review counts, and watch how quickly owners answer reviews.
- **Lead generation.** Build lists of dentists in Almaty, cafes in Kazan or restaurants in Istanbul with phone numbers, websites and social links, ready for a CRM import.
- **Market research.** Count businesses per category and city, map them with latitude and longitude, and compare chains with independent venues.
- **Reputation monitoring.** Collect the newest reviews for a set of organization IDs on a schedule and alert on low ratings or unanswered complaints.
- **Data enrichment.** Add Yandex ratings, categories and opening hours to an existing list of companies you already identified by organization ID.

### Compared with other ways to get Yandex Maps data

| approach | business details | reviews | effort |
|---|---|---|---|
| Copying from the Yandex Maps website by hand | yes | yes | slow, a few businesses per hour |
| Official Yandex Maps developer APIs | geocoding, map display and an organization search API | no review export | own API key and commercial terms |
| Browser extensions and desktop parsers | yes | varies | runs on your own computer, manual exports |
| Separate place and review tools | yes | in a second tool | two runs, joining the results yourself |
| **This actor** | full place rows | optional, linked by `place_id` | one run, one dataset, JSON, CSV or Excel |

The main difference is that places and reviews come out of a single run as flat rows that share the same organization ID, so you do not have to merge two exports.

### Pricing for places and reviews

The actor uses separate result events named `place` and `review`. A place event corresponds to a delivered business row, and a review event corresponds to a delivered review row. Duplicate organizations and duplicate reviews are removed. Empty searches produce no result events, and this actor has no custom run-start event.

Consult the actor's current Pricing tab for the event prices before starting a run. The non-paying user trial is capped at ten dataset rows across places and reviews together. A large input does not increase that cap. Ordinary Apify platform usage follows your account's plan and settings.

### Collection limits and larger requests

Yandex exposes at most 1000 raw search results for one term and map area. Search pages can overlap, so requesting 1000 unique businesses can yield fewer than 1000. Use different business terms or deliberate geographic scopes when researching a wider market. A reported search total is not a promise that every listed business can be collected.

Yandex also exposes at most 600 reviews per organization for one ranking. This actor uses the single ranking you choose; it does not combine several rankings to claim complete historical coverage. Businesses with no written reviews still produce their place record.

Large runs are collected in resumable parts. The Apify actor follows continuation automatically while its run budget permits. If collection stops early, check `partial`, warnings and `next_cursor`. A continuation token lasts 24 hours and requires the same remaining input settings. Keep the original queries, review options and limits when resuming.

### FAQ

#### Can I collect only businesses without reviews?

Yes. Keep `include_reviews` false, which is the default. The dataset then contains only place rows. This is useful for business directories, competitor mapping and contact research.

#### Can I collect reviews for an organization I already know?

Yes. Supply its numeric organization ID in `place_ids` or its Maps page in `start_urls`, then enable reviews. The actor returns the business row followed by its available reviews, up to your chosen review limit.

#### Why are there fewer results than my requested limit?

The business search may have fewer matches, overlapping pages, or reach Yandex's raw-result ceiling. Some results are editorial collections or city names rather than businesses. Review availability and the run budget can also limit collection. Read the warnings and summary before interpreting a smaller dataset as complete coverage.

#### Does language translate the reviews?

No. Language selects the supported locale for place information. Review text stays as Yandex supplies it, and the review language field records the language reported by the platform when available.

#### Is this the official Yandex Maps API?

No. It is an independent tool that reads the public Yandex Maps pages, the same information any visitor sees. The official developer APIs from Yandex focus on map display and geocoding and need their own key and contract; this actor returns business listings and reviews without one.

#### Which countries and cities are supported?

Any city or region that Yandex Maps covers. The actor is tested on Moscow, Saint Petersburg, Kazan, Minsk, Almaty and Istanbul; Russia, the CIS markets and Turkey are where Yandex Maps has the most complete business listings. Use `location`, `region_id` or `ll` coordinates to aim the search, and `language` to receive names and addresses in Russian, English or Turkish.

#### Is there a free trial?

Yes. Users on the free Apify plan can test the actor with up to ten rows per run, places and reviews counted together. Paying users have no row cap beyond the limits they set in the input.

#### Can I use the results in recurring research?

Yes. Keep organization IDs to link observations across runs and use `fetched_at` to distinguish collection dates. Ratings, opening status, review counts and contact details can change, so treat each dataset as a snapshot of the source at collection time.

# Actor input Schema

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

Business search terms. Add a city in the term, location, region_id or ll.

## `location` (type: `string`):

City or region name resolved by Yandex to a map area for queries. Explicit ll and region_id take precedence.

## `region_id` (type: `integer`):

Yandex Maps region ID, for example 213 for Moscow or 2 for Saint Petersburg.

## `ll` (type: `string`):

Map center as longitude,latitude. Overrides region_id.

## `zoom` (type: `integer`):

Map zoom when ll is supplied, or an override for the region map area.

## `start_urls` (type: `array`):

Yandex Maps search or organization URLs, including organization review URLs.

## `place_ids` (type: `array`):

Numeric Yandex organization IDs. Each ID is validated through a place lookup before loading reviews.

## `max_places` (type: `integer`):

Maximum unique places per search. Yandex allows at most 1000 raw results; overlap can reduce the unique total.

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

Language sent to Yandex for place names, addresses and categories. Review text stays in its original language.

## `include_reviews` (type: `boolean`):

Return reviews as separate rows alongside their places.

## `max_reviews` (type: `integer`):

Maximum unique reviews per place. Yandex exposes at most 600 per ranking.

## `reviews_sort` (type: `string`):

Review ranking: newest, relevance, lowest rating first or highest rating first.

## `cursor` (type: `string`):

Opaque continuation token returned as next_cursor. Resubmit the same input with this token; valid for 24 hours.

## Actor input object example

```json
{
  "queries": [
    "кафе"
  ],
  "location": "Москва",
  "max_places": 100,
  "language": "ru",
  "include_reviews": false,
  "max_reviews": 20,
  "reviews_sort": "newest"
}
```

# Actor output Schema

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

One row per place, plus one row per review when reviews are enabled. Filter on row_type.

## `output` (type: `string`):

Status, delivered rows, charged events, free-tier status, warnings and next_cursor.

# 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": [
        "кафе"
    ],
    "location": "Москва"
};

// Run the Actor and wait for it to finish
const run = await client.actor("s-r/yandex-maps-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": ["кафе"],
    "location": "Москва",
}

# Run the Actor and wait for it to finish
run = client.actor("s-r/yandex-maps-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": [
    "кафе"
  ],
  "location": "Москва"
}' |
apify call s-r/yandex-maps-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,s-r/yandex-maps-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/4tTdANM3foD8jFeBs/builds/QvBhD1pdDn2oVMkyT/openapi.json