# Yandex Maps Reviews Scraper ⭐ (past the 600 cap, only-new mode) (`tagadanar/yandex-maps-reviews-scraper`) Actor

Yandex Maps reviews by place link, id or search: stars, text, date, author name, likes, owner reply and photos, plus the place's name, address and rating on every row. Reads past Yandex's 600-review limit and can return only new reviews. No login.

- **URL**: https://apify.com/tagadanar/yandex-maps-reviews-scraper.md
- **Developed by:** [Tagada Data](https://apify.com/tagadanar) (community)
- **Categories:** SEO tools, Lead generation, Travel
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.70 / 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

## Yandex Maps Reviews Scraper: past the 600-review limit, with only-new monitoring

Get the reviews of any place on **Yandex Maps** as clean rows: stars, full text, date, the author's public name and contributor level, likes and dislikes, the owner's reply with its date, and photo links, with the place's name, address, category and rating on every row. Paste place links or ids, or search a city (dentist in Kazan, кафе in Moscow) and read the reviews of the places found.

Yandex Maps lists at most 600 reviews per sort order. For a place with more, this actor reads all four orders the site offers (newest, relevance, lowest and highest rating) and merges them without duplicates: on a Moscow cafe with 872 written reviews it returned 825 in October 2026, where one order stops at 600.

$1 per 1,000 reviews (Free plan; $0.70 on Gold), platform usage included. In only-new mode each monitored place also returns one row per run at the same price. No login, no API key, no proxy to set up.

### Why this one

| | This actor | Typical Yandex Maps reviews scraper on the Store |
| --- | --- | --- |
| Reviews per place | past Yandex's 600-per-order limit (4 orders merged, 825 of 872 on our test place) | 600 at most, often less |
| Only new reviews | built in: schedule it, each run returns one up-to-date row per place (rating, review count) plus only the reviews posted since the last run | rare |
| Negative reviews only, last 30 days only | star and date filters, read in the order that lets the run stop early (left-out reviews are free) | varies |
| Owner replies | text and date on the same row | varies |
| Price per 1,000 reviews | $1 ($0.70 on Gold), all-in | $0.25 to $5 |

### What you get

One row per review (`rowType` = `review`):

| Field | Description |
| --- | --- |
| `reviewId` | Yandex's id of the review |
| `rating` | Stars, 1 to 5 |
| `text`, `language`, `translations` | The review as written, its language, and the translations Yandex provides (by language code) |
| `date` | The date Yandex shows for the review (written or last edited), ISO 8601 |
| `authorName`, `authorAvatarUrl`, `authorLevel` | The author's public display name, avatar and Yandex contributor level, as shown on the review |
| `likes`, `dislikes` | Reactions from other users |
| `ownerReply`, `ownerReplyDate` | The business's answer and its date (null when it did not answer) |
| `photoCount`, `photoUrls`, `videoCount`, `videoUrls` | Media attached to the review |
| `pinned` | Pinned to the top by Yandex |
| `placeId`, `placeName`, `placeAddress`, `placeCategory`, `placeRating`, `placeRatingCount`, `placeReviewCount`, `placeUrl` | The place the review belongs to |
| `sortOrder`, `scrapedAt` | Which Yandex sort order the review was read in, and when |

In only-new mode every run also returns one row per monitored place (`rowType` = `place`): the place fields above with today's `placeRating`, `placeRatingCount` and `placeReviewCount`, plus `newReviews`, the number of new reviews this run found for it. The review fields are empty on those rows.

#### Example row (real, 2026-10-23)

```json
{
  "reviewId": "nFwGRuDlbgRC_Jm6a_OwfF5v-geTm8o",
  "placeId": "153620140001",
  "placeName": "Shibainu fusion cafe",
  "placeAddress": "Moscow, Leningradskiy Avenue, 29к4",
  "placeCategory": "Restaurant",
  "placeRating": 5,
  "placeRatingCount": 1545,
  "placeReviewCount": 872,
  "placeUrl": "https://yandex.com/maps/org/shibainu_fusion_cafe/153620140001/",
  "rating": 5,
  "text": "Очень вкусные ланчи и вежливое обслуживание. Понравилось, будем приходить еще!",
  "language": "ru",
  "translations": { "tr": "Çok lezzetli öğle yemekleri ve güler yüzlü hizmet. Beğendim, tekrar geleceğiz!" },
  "date": "2026-09-22T13:01:55.538Z",
  "authorName": "Анастасия Ерошкина",
  "authorLevel": "Level 3 Local Expert",
  "likes": 0,
  "dislikes": 0,
  "ownerReply": "Анастасия, очень рады, что вам понравились ланчи и вежливое обслуживание! Будем ждать вас снова.",
  "ownerReplyDate": "2026-09-23T07:31:40.221Z",
  "photoCount": 1,
  "photoUrls": ["https://avatars.mds.yandex.net/get-altay/20858623/2a000001a0c9354ef269cf3abbac2b79b544/XXXL"],
  "sortOrder": "newest"
}
```

### Who uses it

- **Reputation and review-management agencies**: a daily feed of new reviews for every client location, with the owner's reply status, without opening Yandex Maps.
- **Restaurant, clinic and retail chains**: all branches' reviews in one table; filter the 1 and 2 star ones and see which got no answer.
- **Market and competitor research**: what customers praise and complain about at competitors, with dates and stars, ready for sentiment analysis or an LLM.
- **Data teams**: review text in Russian, Turkish, Kazakh and more, for training and evaluating language models on real customer feedback.

### How to use it

1. Paste place links (any Yandex domain, any tab of the place card) or organisation ids in **Places**. Or put a **Search term** and **Locations** and choose how many **Places per search**.
2. Set **Reviews per place** and the **Sort** order (newest first by default).
3. Optionally keep only some stars (**Minimum stars**, **Maximum stars**) or recent reviews (**Reviews since**: a date or a period like 30 days).
4. For monitoring, turn on **Only new reviews** and schedule the run (daily or weekly).
5. Export as CSV, Excel or JSON, or send it to your CRM, Google Sheets or Slack with an Apify integration.

#### Input examples

The 20 newest reviews of one place (the prefill):

```json
{
  "startUrls": ["https://yandex.com/maps/org/shibainu_fusion_cafe/153620140001/reviews/"],
  "maxReviewsPerPlace": 20
}
```

Every review Yandex shows for two places, by id:

```json
{
  "startUrls": ["153620140001", "1063914691"],
  "maxReviewsPerPlace": 5000
}
```

Negative reviews of the last 90 days for the first 10 car washes in Kazan:

```json
{
  "searchTerms": ["car wash"],
  "locations": ["Kazan"],
  "maxPlacesPerSearch": 10,
  "maxRating": "2",
  "reviewsSince": "90 days",
  "maxReviewsPerPlace": 200
}
```

Daily monitoring of your branches (schedule this input):

```json
{
  "startUrls": ["https://yandex.ru/maps/org/shibainu_fusion_cafe/153620140001/"],
  "onlyNew": true,
  "maxReviewsPerPlace": 200
}
```

### FAQ

**How many reviews can I get for one place?**
Yandex Maps lists at most 600 reviews in each of its four sort orders. When a place has more and you ask for more, the run reads the other orders too and keeps each review once. How far that goes depends on the place: on a Moscow cafe with 872 written reviews it reached 825 (95%) in October 2026. The run's status says how many it reached out of Yandex's count.

**How does "Only new reviews" work?**
The actor remembers, per place and per star filter, the newest review it has handled. The next run reads newest first and stops at that point, so you get only what was posted (or edited) since. The first run returns the newest reviews up to your limit. Each run returns one up-to-date row per place plus only the new reviews, so you can also track the rating and the review count over time. A run with no new review returns just the place rows ($0.001 per place, $0.0007 on Gold).

**Why is the review count on Yandex higher than the number of ratings with text?**
Yandex counts ratings (stars only) and reviews (with text) separately; `placeRatingCount` is the first and `placeReviewCount` the second. This actor returns the written reviews, which is what Yandex lists.

**Is the date the posting date?**
It is the date Yandex shows on the review, which is the last edit when the author edited it.

**Which countries work?**
Every country Yandex Maps covers: Russia, Kazakhstan, Belarus, Uzbekistan, Turkey, Armenia, Georgia and more.

**What does a place with no reviews cost?**
Only the run start (and, in only-new mode, its place row). The run says when a place has no written reviews, when no review matched your filters, when a place link no longer exists or when nothing is new, so a zero is always explained.

**Is it legal? What about personal data?**
The actor reads the public reviews anyone sees on Yandex Maps without logging in, and keeps only what the review card shows: the author's public display name, avatar and contributor level. It does not open author profiles. Reviews contain personal data under GDPR and similar laws: you are responsible for having a lawful purpose and for how you store and use them.

### Related actors

- [Yandex Maps Scraper](https://apify.com/tagadanar/yandex-maps-scraper): the businesses themselves, with phones, websites, messengers, addresses and hours.
- [All our scrapers](https://apify.com/tagadanar).

Keywords: yandex maps reviews scraper, yandex reviews api, export yandex maps reviews, yandex business reviews, отзывы яндекс карт, парсер отзывов яндекс карт, выгрузка отзывов, мониторинг отзывов, review monitoring Russia, Kazakhstan reviews.

# Changelog

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

# Actor input Schema

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

Yandex Maps place links copied from any Yandex domain (yandex.ru, yandex.com, yandex.com.tr, yandex.kz), any tab of the place card, or bare organisation ids like 153620140001. A search or category link works too: its first places are read (see Places per search).

## `searchTerms` (type: `array`):

Optional, instead of links: what you would type into Yandex Maps (dentist, car wash, кафе). Every term is searched in every location below and the reviews of the first places found are read.

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

Cities or regions for the search terms, as you would type them into Yandex Maps (Moscow, Kazan, Almaty, Istanbul, Москва), or a Yandex region number such as 213.

## `maxPlacesPerSearch` (type: `integer`):

How many places to take from each search (in Yandex's own order), at most 200.

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

The most reviews to bring back for each place, at most 5000. Yandex Maps lists at most 600 reviews per sort order; for places with more, the run also reads the other sort orders and merges them without duplicates.

## `sort` (type: `string`):

The order Yandex Maps lists the reviews in, which decides which reviews you get first when a place has more than your limit.

## `minRating` (type: `string`):

Only reviews with at least this many stars. Reviews left out are not charged.

## `maxRating` (type: `string`):

Only reviews with at most this many stars (set 2 to get only the negative reviews). Reviews left out are not charged.

## `reviewsSince` (type: `string`):

Only reviews written (or last edited) on or after this date: a date like 2026-01-31 or a period like 30 days. Reviews are then read newest first and the run stops at the first older one.

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

Schedule the same input and get only the reviews that appeared since the previous run, per place. The first run brings back the newest reviews up to your limit; a run with nothing new succeeds with no rows and costs only the run start.

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

The language Yandex Maps uses for place names, addresses and categories. Review texts stay in the language they were written in.

## Actor input object example

```json
{
  "startUrls": [
    "https://yandex.ru/maps/org/shibainu_fusion_cafe/153620140001/",
    "1063914691"
  ],
  "searchTerms": [
    "car wash"
  ],
  "locations": [
    "Kazan"
  ],
  "maxPlacesPerSearch": 5,
  "maxReviewsPerPlace": 20,
  "sort": "newest",
  "minRating": "",
  "maxRating": "",
  "onlyNew": false,
  "language": "en"
}
```

# Actor output Schema

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

One item per Yandex Maps review in the default dataset.

# 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": [
        "https://yandex.com/maps/org/shibainu_fusion_cafe/153620140001/reviews/"
    ],
    "maxReviewsPerPlace": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("tagadanar/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": ["https://yandex.com/maps/org/shibainu_fusion_cafe/153620140001/reviews/"],
    "maxReviewsPerPlace": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("tagadanar/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": [
    "https://yandex.com/maps/org/shibainu_fusion_cafe/153620140001/reviews/"
  ],
  "maxReviewsPerPlace": 20
}' |
apify call tagadanar/yandex-maps-reviews-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,tagadanar/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/wcYFFyUeTihg5DIcN/builds/5OT3i10zfrpBb5U5n/openapi.json