# Yandex Maps Reviews Scraper — Ratings, Replies & AI Summary (`nice_dev/yandex-maps-reviews-scraper`) Actor

Scrape Yandex Maps reviews of any place, by URL, place ID or keyword + city: rating, full text, date, author, owner reply, photos, translations, plus the place's details and Yandex AI summary on every row. Well past the 600-review limit. Monitor new reviews. Export JSON, CSV, Excel.

- **URL**: https://apify.com/nice\_dev/yandex-maps-reviews-scraper.md
- **Developed by:** [Nice Dev](https://apify.com/nice_dev) (community)
- **Categories:** Lead generation, MCP servers
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.18 / 1,000 reviews

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

### 💬 What is Yandex Maps Reviews Scraper?

**Yandex Maps Reviews Scraper** extracts the **reviews of any place on [Yandex Maps](https://yandex.com/maps/)** — Russia, the CIS and Turkey: **stars, full text, date, author and author level, likes, photos and videos, Yandex translations and the owner's reply** — with the **place's details on every row** (name, address, city, category, rating, phone, website) and **Yandex's AI summary** of the place. Use it for reputation monitoring, competitor research, customer-feedback analysis or local SEO.

Paste **place links or IDs**, or type a **keyword** and a **city** (`dentist` in `Moscow`, `кафе` in `Санкт-Петербург`) to get the reviews of every place found. Click **Start** and download the reviews in JSON, CSV or Excel: one row per review, nothing to join. No login, nothing to set up. It goes **well past the 600 reviews Yandex shows per sort order**: 86 % of the 2,727 reviews of a busy restaurant, 7,844 reviews of Gorky Park.

### 📋 What data can you extract from Yandex Maps reviews?

One row per review, 52 fields:

| Category | What you get |
| --- | --- |
| ⭐ **Review** | stars, full text, date, language, Yandex translations, likes and dislikes, pinned or not, link to the review |
| 👤 **Author** | name, public ID and profile link, avatar, contributor level (`Local Expert level 12`) |
| 🖼️ **Media** | photos and videos of the review, with their date, size, moderation status and reactions |
| 🏪 **Owner's reply** | the business's answer and its date — find the reviews nobody answered |
| 🏷️ **Place, on every row** | name, category, address, city, postal code, country, GPS coordinates, phone, website, status, rating, number of ratings and reviews |
| 🤖 **AI summary and topics** | the sentence Yandex's AI picks to sum the place up, and the review topics (food, staff, parking…) with their positive, neutral and negative counts |
| 🔎 **Where it came from** | the keyword and location that found the place, its search page |

Every field, with an example, is listed in the **Output** section below.

### ✅ Why use Yandex Maps Reviews Scraper?

- 📚 **Far past 600 reviews**: Yandex shows 600 reviews per sort order. The Actor merges the 4 orders, then reads the place's review topics one by one (**Deep reviews**): 2,338 of the 2,727 reviews of a busy restaurant instead of 1,283, and 7,844 reviews of Gorky Park instead of 1,703.
- 🏷️ **The place on every row**: name, address, city, category, rating, phone and website repeat on each review — open the CSV and filter, nothing to look up.
- 🔎 **Search, then reviews**: type a keyword and a city, and get the reviews of every place found (`Max places per search`), or paste your own list of places.
- 🔔 **Monitoring built in**: **Only new reviews** returns only what earlier runs did not deliver; with the newest first, a daily run reads about one page per place.
- 🎯 **Filters**: stars (`maxRating: 2` = complaints only), dates (`7 days`), text only, answered by the owner, words in the text.
- 🤖 **Yandex AI summary** and **review topics** of each place, included.
- 🔌 API, scheduling, integrations (Make, Zapier, n8n, Google Sheets…) and JSON / CSV / Excel export via the Apify platform.

### 🚀 How to scrape Yandex Maps reviews

1. Create a free Apify account.
2. Open **Yandex Maps Reviews Scraper** and paste Yandex Maps place links into **Place URLs** (e.g. `https://yandex.com/maps/org/1036014863/reviews/`), or place IDs into **Place IDs**.
3. Or leave them empty and type a **Search keyword** (e.g. `стоматология`) and a **Location** (e.g. `Москва`): the reviews of the first 20 places found are read (**Max places per search**).
4. Set **Max reviews per place** (100 by default, 0 = as many as possible) and the **Review order**, then click **Start**.
5. Download the dataset in JSON, CSV, Excel or via API.

### 💰 How much does it cost to scrape Yandex Maps reviews?

This Actor uses **pay per event** pricing: you pay for the reviews you get.

| What | Price |
| --- | --- |
| Review (one row) | **$0.23** per 1,000 reviews ($0.21 Bronze, $0.19 Silver, $0.18 Gold) |
| Filter check: a place dropped by a place filter of this Actor (`minPlaceRating`, `minReviewCount`, `requirePhone`, `requireWebsite`, `excludeKeywords`, `excludeBusinessIds`) | $0.18 per 1,000 places dropped ($0.17 Bronze, $0.16 Silver, $0.15 Gold) |
| Run start | $0.01 per run |

Platform usage (compute, proxy) is included in the price. The place details, the AI summary and the review topics come free with the reviews. A review the review filters drop (stars, dates, text, reply, words) is neither saved nor charged. With a maximum cost per run set, the run saves the reviews it can pay for and stops there — the last place may be cut short: never a review charged and not saved.

### ⚙️ Input

The reviews of one place, newest first:

```json
{
    "startUrls": [{ "url": "https://yandex.com/maps/org/1036014863/reviews/" }],
    "maxReviewsPerPlace": 200,
    "reviewSort": "newest"
}
```

The complaints of the last 30 days of every dentist found in Moscow:

```json
{
    "query": "стоматология",
    "location": "Москва",
    "maxItemsPerQuery": 50,
    "maxReviewsPerPlace": 0,
    "maxRating": 2,
    "postedAfter": "30 days"
}
```

A daily run that returns only the new reviews of your places:

```json
{
    "businessIds": ["1036014863", "19464848293"],
    "reviewSort": "newest",
    "maxReviewsPerPlace": 0,
    "onlyNew": true,
    "stateKey": "my-restaurants"
}
```

| Field | Notes |
| --- | --- |
| `startUrls` | Yandex Maps place pages (also their `/reviews/` tab, e.g. `https://yandex.com/maps/org/1036014863/reviews/`), short links or search pages (yandex.ru, .com, .com.tr, .kz, .by, .uz); given, they replace the search fields. |
| `businessIds` | Place IDs (e.g. `1036014863`, the `placeId` column of a previous run); given, they replace the search fields too. |
| `query`, `searchQueries` | What to look for, in any language (e.g. `dentist`, `кафе`); `searchQueries` adds more keywords (one search each). |
| `location`, `locations` | City, district, street or country (e.g. `Moscow`, `Istanbul`); every keyword is searched in every location (max 500 searches per run). |
| `coordinates`, `viewportSpan`, `radiusKm` | A map area instead of a named location: its center `longitude,latitude` (e.g. `37.6173,55.7558`), with a span or a radius in km. |
| `boundingBox` | A map rectangle `west,south,east,north` (e.g. `37.35,55.57,37.85,55.92`). |
| `splitArea`, `tileGrid` | For more than ~600 places per search: cut a full search into map tiles automatically; `tileGrid` cuts every area into N × N tiles from the start. |
| `maxItemsPerQuery`, `maxPlaces` | Places of each keyword search (`20` by default, `0` = all found) and of the whole run (`0` = no cap). Pasted places are not counted per search: `maxPlaces` caps them like the others. |
| `language` | Language of the place details and of the translations: `en`, `ru`, `tr`, `uk` or `kk`. The review text stays in its own language. |
| `maxReviewsPerPlace` | Reviews per place (`100` by default, `0` = as many as possible). |
| `reviewSort` | The order they are read in: `newest`, `relevance`, `highest` or `lowest`. |
| `deepReviews` | Past what the 4 sort orders give (1,283 and 1,703 reviews on two big places, never more than 2,400), read the place's review topics one by one (default on). |
| `maxItems` | Reviews of the whole run (`0` = no cap): the run stops there. |
| `minRating`, `maxRating` | Stars of the review, 1 to 5 (`maxRating` `2` = complaints only). |
| `postedAfter`, `postedBefore` | Dates of the reviews: `2026-09-01`, or `7 days`, `2 weeks`, `1 month` before now. |
| `onlyWithText`, `onlyWithBusinessReply`, `reviewKeywords` | Reviews with text only, answered by the owner only, containing one of these words. |
| `minPlaceRating`, `openNow`, `open24h`, `goodPlaceOnly`, `hasPhotos`, `categoryIds`, `chainIds` | Which places of a keyword search are read — Yandex's own filters: minimum place rating (`4.5`), open now, open 24 h, "Good place" award, with photos, category and chain IDs. |
| `customFilters` | Any other filter Yandex offers for the search, as `filterId:value` (e.g. `car_park:1`); `debugLog` lists them for each search. |
| `requirePhone`, `requireWebsite`, `minReviewCount`, `excludeKeywords`, `excludeBusinessIds` | Skip places without a phone or website, with few reviews, with a word in their name or category, or already known. |
| `onlyNew`, `stateKey`, `resetState` | Monitoring: only the reviews never delivered under this memory key (e.g. `my-restaurants`); `resetState` forgets it. |
| Advanced | `proxyConfiguration` (Apify proxy by default, included in the price; the residential proxy is not available), `maxConcurrency`, `maxRequestsPerMinute`, `minRequestIntervalMs`, `maxRequestRetries`, `debugLog`. |

### 📦 Output

A real row of a run (the first review saved for Tanuki, Moscow), shortened: lists keep their first entry, texts are cut.

```json
{
    "reviewId": "zzSW19y4gvxOSevw0uSWTblrVjxfwy",
    "reviewUrl": "https://yandex.com/maps/org/1036014863/reviews/?reviews%5BbusinessId%5D=1036014863&reviews%5BreviewId%5D=zzSW19y4gvxOSevw0uSWTblrVjxfwy",
    "rating": 5,
    "text": "Очень вкусно и быстро готовят, все отлично вернемся еще!",
    "hasText": true,
    "textLanguage": "unknown",
    "textTranslations": null,
    "publishedAt": "2026-09-26T12:40:10.895Z",
    "likes": 0,
    "dislikes": 0,
    "photos": [],
    "photoDetails": [],
    "photoCount": 0,
    "videos": [],
    "videoDetails": [],
    "videoCount": 0,
    "isPinned": false,
    "businessReply": null,
    "businessReplyAt": null,
    "hasBusinessReply": false,
    "authorName": "Семёнова Кристина",
    "authorId": "q4y1qedhajyq1r2k9upwtxg2wm",
    "authorProfileUrl": "https://reviews.yandex.ru/user/q4y1qedhajyq1r2k9upwtxg2wm",
    "authorAvatarUrl": "https://avatars.mds.yandex.net/get-yapic/25817/0l-9/islands-200",
    "authorLevel": "Level 4 Local Expert",
    "position": 1,
    "placeId": "1036014863",
    "placeName": "Тануки",
    "placeUrl": "https://yandex.com/maps/org/tanuki/1036014863/",
    "placeReviewsUrl": "https://yandex.com/maps/org/tanuki/1036014863/reviews/",
    "placeCategory": "Restaurant",
    "placeCategories": [
        "Restaurant",
        "sushi bar"
    ],
    "placeAddress": "Moscow, Bolshoy Zlatoustinsky Lane, 1с1",
    "placeCity": "Moscow",
    "placeCountry": "Russian Federation",
    "placePostalCode": "101000",
    "placeLatitude": 55.759743,
    "placeLongitude": 37.631658,
    "placePhone": "+7 (499) 649-22-23",
    "placeWebsite": "https://tanukifamily.ru/tanuki/",
    "placeRating": 5,
    "placeRatingCount": 15801,
    "placeReviewCount": 11416,
    "placeStatus": "open",
    "placeNeurosummary": "Замечательно место, красивое оформление , еда и напитки на высоте",
    "placeReviewAspects": [
        {
            "id": "3502043738",
            "name": "Meal",
            "count": 7923,
            "positive": 6969,
            "neutral": 146,
            "negative": 808,
            "isTrusted": true
        }
    ],
    "placeFirstRow": true,
    "searchQuery": null,
    "searchLocation": null,
    "searchUrl": null,
    "language": "en",
    "scrapedAt": "2026-09-26T14:57:15.059Z"
}
```

You can download the dataset in various formats such as JSON, HTML, CSV or Excel. The **Owner replies** view puts each review next to the answer of the business; the **Places** view shows the context of each place.

#### All 52 fields

| Fields | What you get |
| --- | --- |
| `reviewId`, `reviewUrl`, `position` | **Review**: Yandex ID (stable: the key for monitoring), link, rank among the reviews saved for its place |
| `rating`, `text`, `hasText`, `textLanguage`, `textTranslations`, `publishedAt` | stars 1-5, full text, text or star-only, language, Yandex translations, date written or edited |
| `likes`, `dislikes`, `isPinned` | readers' reactions, pinned on top by the place |
| `photos`, `photoDetails`, `photoCount`, `videos`, `videoDetails`, `videoCount` | **Media**: photo and video links, with date, size, status and reactions |
| `businessReply`, `businessReplyAt`, `hasBusinessReply` | **Owner's reply** and its date |
| `authorName`, `authorId`, `authorProfileUrl`, `authorAvatarUrl`, `authorLevel` | **Author**: name, public ID, profile, avatar, contributor level |
| `placeId`, `placeName`, `placeUrl`, `placeReviewsUrl`, `placeCategory`, `placeCategories` | **Place**: Yandex ID, name, page, Reviews tab, categories |
| `placeAddress`, `placeCity`, `placeCountry`, `placePostalCode`, `placeLatitude`, `placeLongitude` | address, city, country, postal code, GPS coordinates |
| `placePhone`, `placeWebsite`, `placeStatus` | first phone number, website (tracking removed), open or closed |
| `placeRating`, `placeRatingCount`, `placeReviewCount` | rating of the place, number of ratings and of reviews on Yandex |
| `placeNeurosummary`, `placeReviewAspects`, `placeFirstRow` | **AI summary** of the place, review topics with positive / neutral / negative counts (on the first row of each place, `placeFirstRow`) |
| `searchQuery`, `searchLocation`, `searchUrl`, `language`, `scrapedAt` | the search that found the place, the run's language, ISO timestamp of the extraction |

### 💡 Tips

#### How to get more results

Set **Max reviews per place** to `0` and keep **Deep reviews** on: the Actor merges the 4 sort orders, then reads each review topic of the place, the smallest first. For a keyword search, raise **Max places per search** (`0` = every place found) and tick **Split big areas automatically** above 600 places.

#### How to reduce costs

You pay per review: cap them with **Max reviews per place** and **Max reviews**, and use the review filters — a review they drop is not charged. Turn **Deep reviews** off when what the 4 sort orders give is enough (1,283 and 1,703 reviews on two big places, never more than 2,400). For recurring runs, **Only new reviews** never charges twice for the same review. A date bound (**Reviews posted after**) stops reading a place at its first older review newest first, and **Maximum review rating** / **Minimum review rating** at the first review past the bound in the lowest / highest order — once the **Review order** asked is read: with **Newest first** (the default), a "last 7 days" run reads one page per place, not all of them.

#### Several searches in one run

Fill `searchQueries` and / or `locations`: the Actor runs one search per keyword × location (3 keywords × 4 cities = 12 searches, up to 500 per run), and **Max places per search** applies to each. A place found by several searches is read once.

#### Monitoring: only the new reviews

Tick **Only new reviews** (`onlyNew`) and schedule the Actor: each run returns, and charges, only the reviews no previous run delivered under the same `stateKey` — with **Newest first**, reading a place stops at its first known review, so a daily run reads about one page per place. The memory lives in a named key-value store of your account (`yandex-maps-reviews-scraper-seen-reviews`, up to 150,000 ids per key), updated only with what really reached the dataset. Give each schedule its own `stateKey`, and tick `resetState` once to start over.

#### Filter reviews by date

`postedAfter` and `postedBefore` apply to the reviews: `2026-09-01` (the whole day is included, Moscow time) or a period before now (`7 days`, `2 weeks`, `1 month`; via the API also `24 hours` or a full ISO date-time). A review without a date is dropped as soon as a bound is set.

### 🔌 Integrations and API

Call the Actor via the Apify API, the JavaScript or Python clients, or connect it with integrations and webhooks (Make, Zapier, n8n, Google Sheets, Slack, Airtable…). The dataset can be fetched as JSON or CSV from any tool, one row per review.

### 🤖 Use with AI agents (MCP)

AI agents (Claude, ChatGPT, Cursor…) can find and run this Actor through the [Apify MCP server](https://mcp.apify.com), billed to their Apify account like any run. It returns one row per Yandex Maps review, with its place on every row. Actor id: `nice_dev/yandex-maps-reviews-scraper`; MCP server with this Actor only: `https://mcp.apify.com/?tools=fetch-actor-details,nice_dev/yandex-maps-reviews-scraper`.

Smallest input, for a cheap first call:

```json
{
    "businessIds": ["1036014863"],
    "maxReviewsPerPlace": 20
}
```

Key output fields: `rating`, `text`, `publishedAt`, `authorName`, `businessReply`, `placeName`, `placeRating` and `placeNeurosummary`.

Cost: $0.23 per 1,000 reviews (Gold: $0.18), plus $0.01 per run start. Cap each call with `maxItems` (reviews of the run) and, through the API, with the run option `maxTotalChargeUsd`.

### ❓ FAQ

#### Is it legal to scrape Yandex Maps reviews?

The Actor only reads what Yandex Maps shows publicly to any anonymous visitor. It logs in to nothing and solves no captcha. Reviews carry the names and photos of their authors, which are personal data protected by GDPR: do not store them without a legitimate reason. You are responsible for using the data in compliance with Yandex's Terms of Use and applicable law. This Actor is not affiliated with Yandex.

#### Does it need a login or a proxy?

No login. The proxy is included in the price: leave the default setting (the residential proxy is not available). A request the site turns away is retried at once on a new proxy session, up to 10 times on top of the retries (without a proxy, after a pause of 5 seconds, doubled at each retry up to 150 seconds).

#### Why does a place give fewer reviews than Yandex shows?

Yandex shows 600 reviews per sort order and per topic. Deep reviews reach most of them — 86 % on a restaurant of 2,727 reviews — but the reviews tied to no topic and past the 600 of every order cannot be reached. Star ratings without text count in the place's rating, not in its reviews.

#### Is the data safe to open in Excel or to show on a web page?

Reviews are their authors' own words, copied as they are. A text can begin with `-`, `+`, `=` or `@` (a review such as `+1 for the staff`): Excel and Google Sheets may read such a cell of a CSV file as a formula or as a number. The Actor leaves the text as it is, so that the JSON and the API give the real value: when you open a CSV, import these columns as text. Every URL field holds an http(s) URL or `null`. On a web page, escape every field like any text written by a stranger.

#### Known limitations

- Reviews beyond 600 come from Yandex's 4 sort orders merged, then from the place's review topics: a very popular place gives thousands, never necessarily all of them.
- A place with thousands of reviews takes minutes: Deep reviews reads 5 to 13 reviews per request instead of 50. Its reviews are saved page by page as they are read, not once the place is done.
- `onlyNew` remembers review ids, not their content: a review edited since is not returned again.
- Two runs sharing the same `stateKey` at the same time may both return the same new review.

**A run that reaches its timeout** stops itself about 45 seconds before it: no new page is asked, what it read is saved and, with `onlyNew`, remembered, and the run ends *Succeeded* with "Stopped before the run's timeout". A place still reading its reviews then keeps the pages it read; resurrect the run and it reads the rest, no review saved or charged twice. Resurrect it to go on from there, or give the next run a longer timeout (Run options).

**A run the platform stops without warning** (out of memory)

- Resurrect it: it goes on from where it stood at most a minute before the stop. What it had read since is read again, and the reviews already saved are skipped (a place saved half-way goes on with the rest): no review is delivered or charged twice, and **Max reviews** still counts them. Only the reviews read in the last 5 seconds before the stop may be missing: never charged, and read again only if their place was still being read.
- With `onlyNew`, the memory is saved once a minute: resurrect the stopped run and the reviews it had saved meanwhile join the memory; leave it stopped for good, and the next run may return up to a minute of them once more.

#### Something doesn't work?

The last line of the log counts the reviews saved, the places read, filtered out and no longer on Yandex Maps, and the requests that failed after every retry. Those requests are listed, with the reason, in the `FAILED_REQUESTS` record of the run's key-value store. A page of reviews lost for good leaves its place with the reviews of the other pages, counted in the log. A run that saved nothing and had failed requests fails, and its last message gives the cause (a location Yandex does not know, a filter it ignored for the search).

If Yandex changes its data, you are told instead of paying for blank rows: if the first 20 reviews read all lack their stars, date or text, or the places announce reviews and give none, or the first places read (5 to 20) all lack their name, category, address or coordinates, the run saves nothing more, stops and fails, and its last message names the missing field. A shorter run (a single pasted place, a few new reviews) is checked at its end the same way, from 5 reviews or places: it then fails instead of ending green.

### 🛟 Support

Open an issue in the **Issues** tab with a link to your run: the run log and the `FAILED_REQUESTS` record of the key-value store show exactly which requests failed and why.

# Actor input Schema

## `startUrls` (type: `array`):

Yandex Maps place pages (`https://yandex.com/maps/org/<name>/<id>/`, also its `/reviews/` tab), short links (`https://yandex.ru/maps/-/CDabc123`) or search result pages (`https://yandex.com/maps/213/moscow/search/dentist/`: the reviews of the places found, capped by **Max places per search**). yandex.ru, .com, .com.tr, .kz, .by, .uz are accepted. When this list or **Place IDs** is not empty, the search fields below are ignored. Max 1 000 URLs.

## `businessIds` (type: `array`):

Yandex Maps place IDs (the number at the end of a place URL, e.g. `1036014863`), for instance the `placeId` column of a previous run or of a places scraper. Added to **Place URLs**: the search fields below are then ignored.

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

Find the places by keyword instead of pasting them: what to look for on Yandex Maps, in any language (e.g. `dentist`, `стоматология`, `кафе`, `kuaför`), with a **Location**. The reviews of each place found are read, up to **Max places per search**.

## `searchQueries` (type: `array`):

Several keywords in one run: one search per keyword (times each location below). Added to **Search keyword**; places found by several searches are saved once.

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

City, district, street or country of the keyword search, as typed on Yandex Maps (e.g. `Moscow`, `Санкт-Петербург`, `Istanbul`, `Almaty`). Empty = the map area below, or Moscow.

## `locations` (type: `array`):

Several locations in one run: every keyword is searched in every location (3 keywords × 4 locations = 12 searches, max 500). Added to **Location**.

## `coordinates` (type: `string`):

Search around this point instead of a named location: `longitude,latitude` in decimal degrees, longitude FIRST as in Yandex URLs (e.g. `37.6173,55.7558` = Moscow center). Used with **Map span** or **Radius**; ignored when a location is given.

## `viewportSpan` (type: `string`):

Size of the searched area around **Map center**, in degrees: `width,height` (e.g. `0.2,0.1` ≈ 12 × 11 km in Moscow). Default `0.2,0.1`.

## `radiusKm` (type: `integer`):

Search a square of this half-size around **Map center** instead of **Map span** (e.g. `5` = 10 × 10 km). 0 = use Map span.

## `boundingBox` (type: `string`):

Search this rectangle: `west,south,east,north` in decimal degrees (e.g. `37.35,55.57,37.85,55.92` = Moscow inside the ring road). Wins over Map center; ignored when a location is given.

## `splitArea` (type: `boolean`):

One Yandex search shows at most ~650 distinct places. On: a search that fills up is cut into 4 map tiles, searched again, so a whole city can be covered (for **Max places per search** above 600). Off = one search per keyword × location.

## `tileGrid` (type: `integer`):

Cut every searched area into N × N tiles from the start (e.g. `4` = 16 searches), before any automatic split. 1 = one search per area.

## `maxItemsPerQuery` (type: `integer`):

How many places EACH keyword search (keyword × location, or search URL) contributes; their reviews are then read. 0 = every place found. Places pasted as URLs or IDs are not counted here (**Max places** caps them).

## `maxPlaces` (type: `integer`):

Cap on the number of places read in the run, all inputs together. 0 = no cap.

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

Language of the place details (name, address, categories) and of the review translations Yandex gives. Review text is always in its original language.

## `maxReviewsPerPlace` (type: `integer`):

Maximum number of reviews per place, in the order below. Yandex shows 600 reviews per sort order; 0 = as many as Yandex gives (the 4 sort orders merged, then the review topics with **Deep reviews**). Popular places have thousands: set **Max reviews** or a maximum cost of the run.

## `reviewSort` (type: `string`):

Order in which reviews are read (and cut by Max reviews per place).

## `deepReviews` (type: `boolean`):

When a place has more reviews than the 4 sort orders give (1 283 and 1 703 on two big places, never more than 4 × 600 = 2 400) and **Max reviews per place** asks for more: read the place's review topics (food, staff, parking…) one by one. Gorky Park: 7 844 distinct reviews instead of 1 703. Slower (5 to 13 reviews per request instead of 50); each review is charged the same.

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

Cap on the reviews saved in the run, all places together (the run stops there). 0 = no cap. This is the budget stop: 1 review = 1 row = 1 charge.

## `minRating` (type: `integer`):

Only reviews rated at least this many stars (1-5). 0 = all.

## `maxRating` (type: `integer`):

Only reviews rated at most this many stars (1-5): `2` = complaints only. 0 = all.

## `postedAfter` (type: `string`):

Only reviews written (or last edited) on or after this date: `2026-09-01`, or a period before now such as `7 days`, `2 weeks`, `1 month` (API: `24 hours` and full ISO date-times work too).

## `postedBefore` (type: `string`):

Only reviews written on or before this date (the whole day is included), or older than a period such as `30 days`.

## `onlyWithText` (type: `boolean`):

Drop the ratings without any text.

## `onlyWithBusinessReply` (type: `boolean`):

Keep only the reviews the business answered.

## `reviewKeywords` (type: `array`):

Keep only the reviews whose text contains one of these words (case and accents ignored).

## `minPlaceRating` (type: `string`):

Only places rated at least this (Yandex filter, then checked on each place by the Actor: a place it drops is charged as a *Filter check*).

## `openNow` (type: `boolean`):

Only places open at the time of the run (Yandex filter).

## `open24h` (type: `boolean`):

Only places open around the clock (Yandex filter).

## `goodPlaceOnly` (type: `boolean`):

Only places with the Yandex "Good place" award (Yandex filter).

## `hasPhotos` (type: `boolean`):

Only places that have photos (Yandex filter).

## `categoryIds` (type: `array`):

Only places of these Yandex categories (rubric IDs, e.g. `184106132` = dental clinic: the last number of a Yandex Maps category link, `.../category/dental_clinic/184106132/`). Yandex filter.

## `chainIds` (type: `array`):

Only the branches of these chains (chain ID: the `chainId` column of a places scraper). Yandex filter.

## `customFilters` (type: `array`):

Any other filter shown by Yandex for the search, as `filterId:value` (e.g. `car_park:1`, `wheelchair_accessability:1`, `payment_by_credit_card:1`, `type_cuisine:georgian_cuisine`). Tick **Debug log** to see the filters Yandex offers for each search in the run log; they are also listed when a filter is refused. A filter Yandex does not know for the search is reported and the search stops, instead of returning unfiltered places.

## `requirePhone` (type: `boolean`):

Drop the places without a phone number.

## `requireWebsite` (type: `boolean`):

Drop the places without a website (the Yandex "has website" filter is sent too).

## `minReviewCount` (type: `integer`):

Only places with at least this many reviews on Yandex. 0 = no minimum.

## `excludeKeywords` (type: `array`):

Drop the places whose name or category contains one of these words (case and accents ignored).

## `excludeBusinessIds` (type: `array`):

Never save these places (e.g. your own branches, or places you already have).

## `onlyNew` (type: `boolean`):

Return only the reviews a previous run with the same **Memory key** did not deliver. With **Newest first**, reading stops at the first review already known: a daily run reads one page per place.

## `stateKey` (type: `string`):

Name of the memory used by **Only new reviews**. Give each schedule / task its own key (e.g. `my-clinics`) so that they do not share their memory. Letters, digits, `-` and `_`.

## `resetState` (type: `boolean`):

Forget the reviews remembered under the **Memory key** before this run.

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

Apify Proxy or your own proxies. Keep the default: it is included in the price. The residential Apify proxy is not available in this Actor.

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

Maximum number of requests processed in parallel.

## `maxRequestsPerMinute` (type: `integer`):

Most requests to Yandex Maps in any 60 seconds, all of them counted: search pages, places, pages of reviews, session tokens. A budget, not an even pace: up to this many can leave at once when the minute starts (spread them with the minimum delay below).

## `minRequestIntervalMs` (type: `integer`):

Wait at least this long between two requests. 0 = no delay.

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

Retries per request before it is marked as failed. Behind a proxy, a request the site turns away is also retried on a new proxy session up to 10 times without using up these retries.

## `debugLog` (type: `boolean`):

Verbose log.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://yandex.com/maps/org/1036014863/reviews/"
    }
  ],
  "businessIds": [],
  "searchQueries": [],
  "locations": [],
  "radiusKm": 0,
  "splitArea": false,
  "tileGrid": 1,
  "maxItemsPerQuery": 20,
  "maxPlaces": 0,
  "language": "en",
  "maxReviewsPerPlace": 100,
  "reviewSort": "newest",
  "deepReviews": true,
  "maxItems": 0,
  "minRating": 0,
  "maxRating": 0,
  "onlyWithText": false,
  "onlyWithBusinessReply": false,
  "reviewKeywords": [],
  "minPlaceRating": "",
  "openNow": false,
  "open24h": false,
  "goodPlaceOnly": false,
  "hasPhotos": false,
  "categoryIds": [],
  "chainIds": [],
  "customFilters": [],
  "requirePhone": false,
  "requireWebsite": false,
  "minReviewCount": 0,
  "excludeKeywords": [],
  "excludeBusinessIds": [],
  "onlyNew": false,
  "stateKey": "default",
  "resetState": false,
  "proxyConfiguration": {
    "useApifyProxy": true
  },
  "maxConcurrency": 8,
  "maxRequestsPerMinute": 600,
  "minRequestIntervalMs": 0,
  "maxRequestRetries": 5,
  "debugLog": false
}
```

# Actor output Schema

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

No description

# 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 = {
    "startUrls": [
        {
            "url": "https://yandex.com/maps/org/1036014863/reviews/"
        }
    ],
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("nice_dev/yandex-maps-reviews-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 = {
    "startUrls": [{ "url": "https://yandex.com/maps/org/1036014863/reviews/" }],
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("nice_dev/yandex-maps-reviews-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 '{
  "startUrls": [
    {
      "url": "https://yandex.com/maps/org/1036014863/reviews/"
    }
  ],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call nice_dev/yandex-maps-reviews-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,nice_dev/yandex-maps-reviews-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/P3p6CF7yznnaErvfN/builds/q43K8V7vruPs8stYD/openapi.json