# Yandex Maps Scraper: Places & Reviews (privacy-safe) (`kyungminlee/yandex-maps-places-reviews-scraper`) Actor

Unofficial Yandex Maps scraper, no login. Search places by query and city, coordinates or bounding box, or paste place URLs. Address, coordinates, phones, website, hours, rating, features and reviews with owner replies. No reviewer names, IDs or avatars.

- **URL**: https://apify.com/kyungminlee/yandex-maps-places-reviews-scraper.md
- **Developed by:** [Kyungmin Lee](https://apify.com/kyungminlee) (community)
- **Categories:** Lead generation, Travel, Marketing
- **Stats:** 1 total users, 0 monthly users, 94.4% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

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

### What does Yandex Maps Scraper: Places & Reviews do?

**Yandex Maps Scraper: Places & Reviews** collects public business listings and reviews from **Yandex Maps (Яндекс Карты)**, the main map and local search service in Russia and much of the CIS, without a Yandex account, API key or browser. It is an **unofficial** tool and is not affiliated with, endorsed by or sponsored by Yandex.

In one run you can:

- **Search places** by query — e.g. `кофейня`, `стоматология`, `hotel` — in a **city** (55 major cities built in, any other city looked up on Yandex Maps), around **coordinates**, or strictly inside a **bounding box**.
- **Look up specific places** by Yandex Maps URL (`yandex.ru/maps/org/…`, `yandex.com`, `yandex.com.tr`, `yandex.kz` and other domains), share link (`yandex.ru/maps/-/…`) or numeric organisation ID.
- Get the **place data the business publishes**: name, categories, address and postcode, coordinates, phones, website and social links, opening hours (text and structured), rating, rating and review counts, nearest metro, chain, verified-owner flag, "Good Place" award, price examples, amenities (`features`) and Yandex's **review topic sentiment** (`reviewAspects`: e.g. "Coffee — 381 mentions, 314 positive").
- Collect **reviews** with star rating, text, publication date, likes and the **business owner's reply** — in relevance, newest, highest or lowest order, with star and date filters.
- Choose the language of categories, addresses and hours: Russian, English, Turkish, Ukrainian, Kazakh or Uzbek.

**Privacy by design:** reviewer names, user IDs, avatars, profile links, "local expert" levels and photo author credits are **never collected**. When an owner's reply (or the review itself) contains the reviewer's own name, it is replaced with `[name]`, and e-mail addresses and phone numbers in review texts and replies are masked. Most other Yandex Maps scrapers export reviewer identities; this one does not.

### Why use this Yandex Maps scraper?

- **Lead generation and market research** — list every clinic, café or car service in a city or a map rectangle, with phones, websites, hours and coordinates.
- **Reputation monitoring** — schedule a run for your own locations with `reviewSort: newest` and `reviewsSince`, and get only the reviews published since the last run.
- **Competitor and review analytics** — compare ratings, review counts and Yandex's positive/negative topic mentions, or feed review texts into dashboards and AI summaries.
- **Local SEO** — track where a business ranks for a query (`searchRank`).
- **Safer data handling** — no personal data about reviewers to store, secure or delete.

Places and reviews come from **one Actor and one dataset**, so you don't need to chain separate tools.

### How to scrape Yandex Maps places and reviews

1. Enter one or more **Search queries** and a **City** — or coordinates, or a bounding box. You can also (or instead) paste **Place URLs or IDs**.
2. Set **Max places per query** (1–500).
3. Set **Max reviews per place** (0 = no reviews, up to 600) and the **Review order**. Optionally add star filters or a "published on or after" date.
4. Click **Start** and download the results as JSON, CSV, Excel or via the API.

The Actor reads the same public pages and page data the Yandex Maps website loads for an anonymous visitor. It does not log in and never solves captchas. It sends about **one request every 1–2 seconds** with random jitter, uses Apify Proxy (datacenter is enough), moves to a new proxy session every 25 requests and immediately when Yandex shows a block or captcha page, and benches that session. Anything that fails after retries is logged and **never charged**.

Speed: one search page returns 25 places (about 500 places in 1.5 minutes); one review request returns 50 reviews (600 reviews of one place in about 20 seconds).

### Input

| Field | Description |
|---|---|
| `searchQueries` | Queries as typed into Yandex Maps. Russian terms are the most complete in Russia/CIS. |
| `city` | City in English or Russian (`Moscow`, `Санкт-Петербург`, `Almaty`, `Istanbul`…) or a Yandex region path like `213/moscow`. Unknown names are looked up on Yandex Maps. |
| `maxPlacesPerQuery` | 1–500 places per query (default 20). |
| `placeUrls` | Organisation URLs, share links or numeric IDs. |
| `latitude`, `longitude`, `zoom` | Search around a point instead of a city. |
| `boundingBox` | `lat,lon,lat,lon` of two opposite corners; places outside are skipped and not charged. |
| `maxReviewsPerPlace` | 0–600 reviews per place (default 0). |
| `reviewSort` | `relevance` (Yandex default), `newest`, `highest`, `lowest`. |
| `minReviewRating`, `maxReviewRating` | Keep only reviews with these stars (1–5). |
| `reviewsSince` | Keep only reviews published on or after this date. |
| `includeReviewPhotoUrls` | Add URLs of review photos (off by default). |
| `language` | `ru` (default), `en`, `tr`, `uk`, `kk`, `uz`. |
| `proxyConfiguration` | Apify Proxy settings (on by default). |

Example:

```json
{
  "searchQueries": ["стоматология", "кофейня"],
  "city": "Kazan",
  "maxPlacesPerQuery": 100,
  "maxReviewsPerPlace": 20,
  "reviewSort": "newest",
  "language": "en"
}
```

### Output

All results go to one dataset. Every item has a `type`:

- **`place`** — one item per organisation, with the `query` and `searchRank` that found it, or the `inputUrl` you entered. A place found by several queries is saved and charged only once per run.
- **`review`** — one item per review, linked to its place by `placeId`, `placeName` and `placeUrl`. Reviews follow their place item.

Use the **Places** and **Reviews** views in the Output tab, or filter on `type`. A `SUMMARY` record in the key-value store lists counts, failed inputs, skipped duplicates and request statistics.

Place example (shortened):

```json
{
  "type": "place", "query": "coffee", "searchRank": 1, "placeId": "69353267050",
  "name": "Surf Coffee x Flow", "categories": ["Coffee shop"],
  "address": "Strastnoy Boulevard, 8А", "locality": "Moscow", "postalCode": "107031",
  "latitude": 55.766219, "longitude": 37.610433,
  "rating": 4.9, "ratingCount": 1260, "reviewCount": 664,
  "phones": ["+7 (993) 337-56-86"], "websites": ["https://surfcoffee.ru/"],
  "workingHours": "Mon-Fri 8:00 AM–11:00 PM; Sat,Sun 10:00 AM–11:00 PM",
  "openingHours": [{"day": "Mon", "hours": ["08:00-23:00"]}, {"day": "Sat", "hours": ["10:00-23:00"]}],
  "nearestMetro": "Pushkinskaya", "nearestMetroDistanceM": 156, "chainName": "Surf Coffee",
  "features": {"wi_fi": true, "coffee_to_go": true, "payment_method": ["cash", "payment by card", "QR code"]},
  "reviewAspects": [{"aspect": "Coffee", "mentions": 381, "positive": 314, "neutral": 16, "negative": 51}],
  "url": "https://yandex.com/maps/org/surf_coffee_x_flow/69353267050/"
}
```

Review example (shortened):

```json
{
  "type": "review", "placeId": "69353267050", "placeName": "Surf Coffee x Flow",
  "reviewId": "a1B2c3D4e5F6g7H8i9J0kLmNoPqRsT-u", "rating": 5,
  "text": "Очень вежливые бариста, напитки готовятся быстро…", "language": "ru",
  "publishedAt": "2026-08-22T20:03:30.133Z", "likes": 1, "photoCount": 1,
  "ownerReply": "[name], добрый день! Спасибо за такой подробный отзыв…",
  "ownerReplyAt": "2026-08-27T12:43:05.577Z", "reviewSort": "relevance"
}
```

### Data fields

**Place:** `query`, `searchRank`, `placeId`, `name`, `shortName`, `url`, `categories`, `address`, `fullAddress`, `postalCode`, `country`, `locality`, `street`, `house`, `latitude`, `longitude`, `rating`, `ratingCount`, `reviewCount`, `phones`, `websites` (tracking parameters removed), `socialLinks`, `workingHours` (as Yandex writes it), `openingHours` (Monday first, 24-hour `HH:MM-HH:MM`), `isOpenNow` and `openStatusText` (at scrape time), `status` (Yandex's business status, e.g. `open`), `chainName`, `nearestMetro`, `nearestMetroDistanceM`, `hasVerifiedOwner`, `goodPlaceAward`, `isPromoted` (paid priority placement), `photoCount`, `priceExamples`, `features`, `reviewAspects`, `inputUrl`, `language`, `scrapedAt`.

**Review:** `placeId`, `placeName`, `placeUrl`, `reviewId`, `rating` (1–5, `null` when the review has no stars), `text`, `language` (of the text), `publishedAt` (date published or last edited, UTC), `likes`, `dislikes`, `photoCount`, `videoCount`, `ownerReply`, `ownerReplyAt`, `photoUrls` (optional), `reviewSort`, `scrapedAt`.

Not collected: reviewer name, user or public ID, avatar, profile link, expert level, photo author credits.

### Pricing

This Actor uses **pay per event** — you pay only for items that were saved:

| Event | Proposed price | What it covers |
|---|---|---|
| `place` | **$1.50 per 1,000 places** ($0.0015 each) | One place item with all its fields |
| `review` | **$0.50 per 1,000 reviews** ($0.0005 each) | One review item |

The prices shown on the Actor's Store page are the ones that apply. Failed searches, unknown places, blocked requests, duplicates, places outside your bounding box and reviews removed by your filters are never charged. The run's maximum charge is checked before every batch, so the Actor stops cleanly when your limit is reached.

Example: 500 cafés with 20 reviews each = 500 × $0.0015 + 10,000 × $0.0005 = **$5.75**.

### Tips

- **More places:** Yandex returns 25 places per page and widens the area on later pages. For dense, complete coverage, split a city into several bounding boxes or use narrower queries (`кофейня`, `кофе с собой`, `кондитерская`).
- **New reviews only:** schedule the Actor with your place URLs, `reviewSort: newest` and `reviewsSince` set to the last run date. With "newest" the Actor stops reading as soon as it reaches older reviews; with other orders it has to read further to find them.
- **Complaints only:** `reviewSort: lowest` with `maxReviewRating: 2`.
- **Language:** Russian gives the most complete categories and addresses in Russia and the CIS; English and Turkish transliterate addresses. Business names and review texts are never translated. Use `openingHours` for clean 24-hour times.
- Without a city, coordinates or bounding box, put the city into the query itself (`кофейня Казань`).

### FAQ

**Is this an official Yandex API?** No. It is an unofficial scraper of publicly visible Yandex Maps data and is not affiliated with Yandex. Yandex can change its website at any time; the Actor is maintained, but results may briefly break after such changes.

**Do I need a Yandex account or API key?** No. Nothing is logged in and no cookies or tokens of yours are used.

**Why at most 600 reviews per place?** Yandex Maps itself shows only about the first 600 reviews of any organisation, in every sort order. Use different orders (newest, lowest, highest) to reach different reviews.

**Why are reviewer names missing?** On purpose. Review text is public, but this Actor does not collect who wrote it, so you can analyse feedback without handling reviewers' personal data. Please do not use the text to identify or contact reviewers.

**Why does `workingHours` mix Russian with AM/PM?** Yandex formats that text for the visitor's location. The structured `openingHours` field always uses 24-hour times.

**Can I get all photos of a place?** Not yet — the place's `photoCount` and optional review photo URLs are included. Open an issue if you need more.

# Actor input Schema

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

What to search for on Yandex Maps, as you would type it, e.g. "кофейня", "стоматология", "hotel" or "Surf Coffee". Russian terms return the most complete results in Russia and the CIS. Each query is searched in the area set below.

## `city` (type: `string`):

City to search in, in English or Russian, e.g. "Moscow", "Санкт-Петербург", "Kazan", "Almaty" or "Istanbul". Other cities are looked up on Yandex Maps itself. You can also paste a Yandex region path such as "213/moscow". Ignored when coordinates or a bounding box are given. Leave empty to let Yandex pick the area from the query text (e.g. "кофейня Казань").

## `maxPlacesPerQuery` (type: `integer`):

How many places to save for each search query, in Yandex's order. Yandex returns 25 places per page and widens the area as you page further; a place found by several queries is saved (and charged) only once per run.

## `placeUrls` (type: `array`):

Specific organisations to collect, as Yandex Maps URLs (https://yandex.ru/maps/org/surf_coffee_x_flow/69353267050/, yandex.com, yandex.com.tr, yandex.kz and other domains), share links (https://yandex.ru/maps/-/...) or numeric organisation IDs (69353267050).

## `latitude` (type: `number`):

Search around this point instead of a city, e.g. 55.7558. Use together with longitude.

## `longitude` (type: `number`):

Longitude of the search centre, e.g. 37.6173. Use together with latitude.

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

Map zoom used with latitude/longitude: 12 is a whole city district, 14 a neighbourhood, 16 a few streets. Yandex fills the first pages from this view and widens the area on later pages.

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

Only places inside this rectangle, given as two opposite corners: latitude,longitude,latitude,longitude, e.g. "55.745,37.600,55.765,37.640". Places Yandex returns outside the box are skipped and not charged, so a small box can return fewer places than the maximum. Takes priority over coordinates and city.

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

Reviews to save for each place. 0 = no reviews. Yandex shows at most about 600 reviews per organisation, so 600 is the ceiling. Each review is a separate dataset item and a separate review event. Reviewer names, IDs, avatars and profile links are never collected.

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

Order in which reviews are read. Use "Newest first" with "Only reviews published on or after" to monitor new reviews.

## `minReviewRating` (type: `integer`):

Only save reviews with at least this many stars (1-5). Skipped reviews are not charged.

## `maxReviewRating` (type: `integer`):

Only save reviews with at most this many stars (1-5), e.g. 2 to collect complaints only. Skipped reviews are not charged.

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

Only save reviews published (or last edited) on or after this date (YYYY-MM-DD, UTC). Older reviews are skipped and not charged. With "Newest first" the Actor stops reading a place as soon as it reaches older reviews.

## `includeReviewPhotoUrls` (type: `boolean`):

Add the URLs of photos attached to each review. Off by default; the photo count is always included.

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

Language of categories, addresses, opening hours and feature names. Business names and review texts stay as written. Russian is the most complete for Russia and the CIS.

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

Apify Proxy (datacenter is enough) is on by default. The Actor paces requests (about one every 1-2 seconds with random jitter), moves to a new proxy session every 25 requests and immediately when Yandex shows a block or captcha page, and benches that session. Without a proxy a block pauses the run for 30-90 seconds.

## Actor input object example

```json
{
  "searchQueries": [
    "кофейня"
  ],
  "city": "Moscow",
  "maxPlacesPerQuery": 20,
  "zoom": 14,
  "maxReviewsPerPlace": 5,
  "reviewSort": "relevance",
  "includeReviewPhotoUrls": false,
  "language": "ru",
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `places` (type: `string`):

No description

## `reviews` (type: `string`):

No description

## `allItems` (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 = {
    "searchQueries": [
        "кофейня"
    ],
    "city": "Moscow",
    "maxPlacesPerQuery": 20,
    "maxReviewsPerPlace": 5,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("kyungminlee/yandex-maps-places-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 = {
    "searchQueries": ["кофейня"],
    "city": "Moscow",
    "maxPlacesPerQuery": 20,
    "maxReviewsPerPlace": 5,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("kyungminlee/yandex-maps-places-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 '{
  "searchQueries": [
    "кофейня"
  ],
  "city": "Moscow",
  "maxPlacesPerQuery": 20,
  "maxReviewsPerPlace": 5,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call kyungminlee/yandex-maps-places-reviews-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,kyungminlee/yandex-maps-places-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/GJ7quSfacxiPGGY04/builds/6gA2g4L45da0LwLDN/openapi.json