# Yandex Maps Scraper (`crawlerbros/yandex-maps-scraper`) Actor

Scrape business listings, reviews, and place details from Yandex Maps. Extract name, address, phone, website, rating, reviews, working hours, photos and coordinates. Supports 6 regional domains

- **URL**: https://apify.com/crawlerbros/yandex-maps-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Developer tools, Automation, Lead generation
- **Stats:** 38 total users, 12 monthly users, 88.7% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## Yandex Maps Scraper

Extract business listings, reviews, place details, ratings, phone numbers, websites, working hours, and photos from [Yandex Maps](https://yandex.com/maps/) — Russia and CIS's dominant map platform. Supports 6 regional domains and 8 languages.

### What data can you scrape?

- **Business name, address, city, country**
- **Phone numbers and website URLs**
- **Star rating and total review count**
- **Business categories** (e.g. "Restaurant", "Coffee shop")
- **Working hours** (structured by day)
- **Photos** (up to 20 per business)
- **Coordinates** (latitude and longitude)
- **Customer reviews** — author, star rating, text, date, likes

### Use cases

- **Lead generation** — build lists of local businesses in Russia, Turkey, Kazakhstan, and other CIS countries
- **Market research** — find competitors, analyze ratings, and map business density
- **Price monitoring** — track businesses in Yandex Market categories
- **Brand monitoring** — find all your branded locations and monitor customer reviews
- **Real estate & site selection** — discover nearby amenities, transport links, and service density
- **Academic research** — study business ecosystems in Russian-speaking markets

### Modes

#### `searchPlaces` (default)

Search Yandex Maps for businesses matching a keyword and/or location. Returns a list of place records.

**Example queries:**

- `coffee shops Moscow`
- `sushi restaurant Istanbul`
- `hotel near Red Square`
- `pharmacy Almaty`

#### `getDetails`

Fetch complete details for specific Yandex Maps business URLs. Useful when you already know which businesses to target.

#### `getReviews`

Scrape customer reviews from specific business pages, sorted by date, rating, or relevance.

### Input

| Field | Type | Description |
|-------|------|-------------|
| `mode` | select | `searchPlaces`, `getDetails`, or `getReviews` |
| `searchQueries` | string\[] | Search queries (mode=searchPlaces). Combine type + location. |
| `businessUrls` | string\[] | Yandex Maps business URLs (mode=getDetails or getReviews) |
| `yandexDomain` | select | Regional domain: `yandex.com`, `yandex.ru`, `yandex.com.tr`, etc. |
| `language` | select | UI language: `en`, `ru`, `tr`, `de`, `fr`, `uk`, `kk`, `uz` |
| `maxItems` | integer | Max records to return (1–500, default 20) |
| `minRating` | select | Minimum rating filter: `any`, `3`, `3.5`, `4`, `4.5` (searchPlaces only) |
| `reviewsSortOrder` | select | Sort reviews: `by_date_desc`, `by_rating_desc`, `by_relevance` (getReviews only) |
| `proxyConfiguration` | proxy | Residential proxies recommended for best results |

### Output

Each record in the dataset has a `recordType` field:

#### Place record (`recordType: "place"`)

```json
{
  "recordType": "place",
  "placeId": "123456789",
  "name": "Шоколадница",
  "url": "https://yandex.com/maps/org/shokoladnitsa/123456789/",
  "address": "Tverskaya St, 15, Moscow, 125009",
  "city": "Moscow",
  "coordinates": { "lat": 55.7644, "lng": 37.6055 },
  "phone": "+7 495 123-45-67",
  "website": "https://shokoladnitsa.ru/",
  "rating": 4.5,
  "reviewCount": 2341,
  "categories": ["Coffee shop", "Cafe", "Bakery"],
  "workingHours": {
    "Monday": "08:00–22:00",
    "Tuesday": "08:00–22:00",
    "Saturday": "09:00–23:00",
    "Sunday": "09:00–23:00"
  },
  "photos": [
    "https://avatars.mds.yandex.net/get-altay/...",
    "https://avatars.mds.yandex.net/get-altay/..."
  ],
  "scrapedAt": "2026-05-17T10:00:00+00:00"
}
```

#### Review record (`recordType: "review"`)

```json
{
  "recordType": "review",
  "placeId": "123456789",
  "placeName": "Шоколадница",
  "placeUrl": "https://yandex.com/maps/org/shokoladnitsa/123456789/",
  "reviewId": "abc123",
  "author": "Ivan Petrov",
  "authorUrl": "https://yandex.com/profile/ivan",
  "rating": 5,
  "text": "Great coffee and friendly staff. The croissants are fresh every morning.",
  "date": "2024-01-15",
  "likes": 7,
  "scrapedAt": "2026-05-17T10:00:00+00:00"
}
```

### Supported Yandex Domains

| Domain | Region |
|--------|--------|
| `yandex.com` | International |
| `yandex.ru` | Russia |
| `yandex.com.tr` | Turkey |
| `yandex.kz` | Kazakhstan |
| `yandex.uz` | Uzbekistan |
| `yandex.by` | Belarus |

### Tips for best results

- **Use residential proxies** — Yandex may trigger CAPTCHA on datacenter IPs. The default proxy configuration uses Apify residential proxies.
- **Combine type + location** in your search query for precise results (e.g., `Italian restaurant Saint Petersburg` rather than just `restaurant`).
- **Use the matching domain** for your target country — `yandex.ru` for Russian cities, `yandex.com.tr` for Turkish cities.
- **Set language to `ru`** when searching Russian-language businesses for more complete results.
- **Use `getReviews` mode with `by_date_desc`** to get the most recent customer feedback.

### Frequently Asked Questions

**Can I scrape businesses from any city in Russia?**\
Yes. Yandex Maps covers all major Russian cities and thousands of smaller towns. Specify the city name in your search query, e.g., `restaurants Novosibirsk`.

**Does this work for Turkish businesses?**\
Yes. Use `yandex.com.tr` as the domain and `tr` as the language for best results with Turkish locations.

**How many results can I get per search query?**\
Yandex Maps typically returns up to 200–500 results per search. Set `maxItems` accordingly.

**Can I get reviews in Russian?**\
Yes. Reviews are scraped in whatever language they were written. Set `language: ru` to ensure the UI is in Russian.

**Is there a limit on how many reviews I can get per business?**\
You can set `maxItems` up to 500. Most businesses have fewer reviews than that; the scraper stops when there are no more reviews to load.

**Can I filter by minimum star rating?**\
Yes. Use `minRating` to exclude businesses below a threshold (e.g., `4.5` for only top-rated places).

**Why does the scraper use a proxy?**\
Yandex Maps may show a CAPTCHA for automated access from datacenter IP addresses. Residential proxies significantly reduce this. Proxy costs are separate from actor usage.

**How is this different from the Yandex Search Scraper?**\
The Yandex Search Scraper extracts web search results (links, snippets). This actor specializes in Yandex Maps — structured business data including coordinates, phone numbers, hours, photos, and reviews that do not appear in web search results.

**Can I get the coordinates of each business?**\
Yes. Latitude and longitude are included in each place record under the `coordinates` field.

# Actor input Schema

## `mode` (type: `string`):

What to scrape. searchPlaces: search for businesses by keyword. getDetails: fetch full details of specific business URLs. getReviews: scrape reviews from specific business URLs.

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

One or more search queries (mode=searchPlaces). Combine business type and location, e.g. 'coffee shops Moscow', 'sushi restaurant Istanbul'.

## `businessUrls` (type: `array`):

Yandex Maps business page URLs (mode=getDetails or getReviews). Format: https://yandex.com/maps/org/{name}/{id}/

## `yandexDomain` (type: `string`):

Yandex Maps regional domain to use.

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

UI and results language.

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

Maximum number of records to return (places or reviews).

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

Filter out places below this rating. Only applies in searchPlaces mode.

## `reviewsSortOrder` (type: `string`):

How to sort reviews. Only applies in getReviews mode.

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

Recommended. Yandex may trigger captcha on datacenter IPs. Residential proxies give best results.

## Actor input object example

```json
{
  "mode": "searchPlaces",
  "searchQueries": [
    "coffee shops Moscow"
  ],
  "businessUrls": [],
  "yandexDomain": "yandex.ru",
  "language": "en",
  "maxItems": 20,
  "minRating": "any",
  "reviewsSortOrder": "by_date_desc",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

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

Dataset with scraped Yandex Maps places and reviews

# 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 = {
    "mode": "searchPlaces",
    "searchQueries": [
        "coffee shops Moscow"
    ],
    "businessUrls": [],
    "yandexDomain": "yandex.ru",
    "maxItems": 20,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/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 = {
    "mode": "searchPlaces",
    "searchQueries": ["coffee shops Moscow"],
    "businessUrls": [],
    "yandexDomain": "yandex.ru",
    "maxItems": 20,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/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 '{
  "mode": "searchPlaces",
  "searchQueries": [
    "coffee shops Moscow"
  ],
  "businessUrls": [],
  "yandexDomain": "yandex.ru",
  "maxItems": 20,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call crawlerbros/yandex-maps-scraper --silent --output-dataset

```

## MCP server setup

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