# Yandex Maps Places & Reviews Scraper (`automation-lab/yandex-maps-places-reviews`) Actor

Search Yandex Maps by query or place ID and export public business contacts, coordinates, ratings, and individual review records.

- **URL**: https://apify.com/automation-lab/yandex-maps-places-reviews.md
- **Developed by:** [Automation Lab](https://apify.com/automation-lab) (community)
- **Categories:** Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.78 / 1,000 record extracteds

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 Places & Reviews Scraper

Extract public Yandex Maps reviews from organization URLs, raw business IDs, or search queries.

The actor is built for reputation monitoring, local SEO research, competitor intelligence, and review analytics workflows that need structured Yandex Maps review data without manual copying.

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

Yandex Maps Places & Reviews Scraper collects public review records from Yandex Maps business pages.

It can start from exact place URLs, raw Yandex business IDs, or search queries that discover matching places first.

The dataset contains `place` records with contacts and coordinates plus `review` records enriched with the same place context.

### Who is it for?

#### Reputation agencies

Monitor customer feedback for client branches and export reviews into dashboards.

#### Local SEO teams

Analyze ratings, reviewer language, review recency, and owner replies across local competitors.

#### Brand monitoring teams

Track fresh public reviews for high-priority branches on Yandex Maps.

#### Data analysts

Build repeatable review datasets for sentiment analysis and BI pipelines.

#### Sales and market researchers

Compare public customer feedback for businesses in the same category and region.

### Why use this actor?

- ✅ Structured review data instead of manual copy-paste
- ✅ Supports exact Yandex Maps URLs and raw organization IDs
- ✅ Optional search-query discovery for places
- ✅ Includes reviewer metadata, ratings, text, reactions, and owner replies when public
- ✅ Runs as an Apify actor with datasets, API access, schedules, and integrations

### What Yandex Maps place and review data can you extract?

Place rows include names, addresses, categories, phones, websites, coordinates, overall ratings, review counts, and canonical URLs. Review rows add public reviewer, rating, text, date, reactions, photos, and owner reply fields.

| Field | Description |
| --- | --- |
| `recordType` | `place` or `review` |
| `placeId` | Yandex Maps business ID |
| `name` | Place name when discovered from search |
| `yandexUrl` | Canonical Yandex Maps organization URL |
| `address` | Public address when available |
| `categories` | Place categories |
| `phones` | Public phone numbers |
| `website` | Public business website when available |
| `overallRating` | Overall place rating when available |
| `totalReviewCount` | Public count from place metadata when available |
| `longitude`, `latitude` | Place coordinates when exposed |
| `searchQuery`, `searchLocation` | Discovery context for search-derived places |
| `reviewId` | Review identifier; `null` on place rows |
| `reviewerName` | Public reviewer display name |
| `reviewerProfileUrl` | Public Yandex Maps profile URL when available |
| `rating` | Numeric review rating |
| `reviewText` | Review text |
| `reviewLanguage` | Language marker from Yandex |
| `reviewDate` | Review update/create timestamp |
| `likes`, `dislikes` | Public reaction counts |
| `photos` | Public review photo URLs |
| `ownerReplyText` | Business owner reply text when present |
| `ownerReplyDate` | Owner reply timestamp when present |
| `source` | `Yandex Maps` |
| `scrapedAt` | Timestamp of extraction |

### How much does it cost to extract Yandex Maps places and reviews?

This actor uses pay-per-event pricing.

You pay $0.005 per run start and, on the FREE tier, $0.003404 for each saved place or review record. Paid tiers receive lower item prices.

Small tests are inexpensive because the default input saves only a limited number of reviews.

For large monitoring jobs, increase `maxItems` and `maxReviewsPerPlace` based on your budget.

### How to scrape Yandex Maps reviews

1. Open the actor on Apify.
2. Paste one or more Yandex Maps organization URLs.
3. Optionally add raw business IDs or search queries.
4. Set `maxItems` to the total number of reviews you want.
5. Run the actor.
6. Export the dataset as JSON, CSV, Excel, XML, RSS, or HTML.

### Input options

#### `startUrls`

Paste Yandex Maps business URLs such as:

```json
[{ "url": "https://yandex.com/maps/org/1018907821/" }]
```

#### `businessIds`

Use raw IDs when you already have them:

```json
["1018907821"]
```

#### `searchQueries`

Discover places before collecting reviews:

```json
[
  {
    "query": "cafe pushkin",
    "location": "moscow",
    "coordinates": "37.6173,55.7558",
    "span": "0.5,0.5"
  }
]
```

#### `maxItems`

Maximum combined place and review records across all places.

#### `maxReviewsPerPlace`

Maximum review records for each organization.

#### `maxPlacesPerQuery`

Maximum places to process for each search query.

#### `reviewSort`

Choose newest reviews first or most relevant reviews first.

#### `locale`

`en_US` is the default. Set another supported Yandex locale such as `ru_RU` when it better matches the market you are researching.

#### `regionId`

Yandex region context for search queries.

### Output example

```json
{
  "recordType": "review",
  "placeId": "89095193045",
  "name": "Skuratov Coffee",
  "yandexUrl": "https://yandex.com/maps/org/89095193045/",
  "address": "Moscow, Kalashny Lane, 5",
  "categories": ["Coffee shop"],
  "phones": ["+74951234567"],
  "website": "https://skuratovcoffee.ru/",
  "overallRating": 4.8,
  "totalReviewCount": 956,
  "longitude": 37.604156,
  "latitude": 55.755321,
  "searchQuery": "coffee shops",
  "searchLocation": "Moscow",
  "reviewId": "public-review-id",
  "reviewerName": "Public reviewer",
  "reviewerProfileUrl": "https://yandex.com/maps/user/public-id/",
  "rating": 5,
  "reviewText": "Great coffee and friendly service.",
  "reviewLanguage": "en",
  "reviewDate": "2026-08-28T20:52:45.512Z",
  "likes": 0,
  "dislikes": 0,
  "photos": [],
  "ownerReplyText": null,
  "ownerReplyDate": null,
  "source": "Yandex Maps",
  "scrapedAt": "2026-09-19T00:00:00.000Z"
}
```

### Tips for best results

- Use exact organization URLs when possible.
- Use raw business IDs for repeat monitoring.
- Keep first test runs small.
- Use `reviewSort: "by_time"` to monitor the newest feedback.
- Add coordinates and span for search queries in large cities.
- Use `ru_RU` if review counts look unexpectedly low.

### Integrations

#### Google Sheets

Send the dataset to Google Sheets for review tracking.

#### Slack

Schedule the actor and notify a Slack channel when new reviews appear.

#### Airtable

Store review records for client-facing reputation workflows.

#### BI tools

Export JSON or CSV into Power BI, Looker Studio, or Tableau.

#### Sentiment analysis

Pipe `reviewText` into an NLP classifier or LLM workflow.

### API usage

#### Node.js

```js
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/yandex-maps-places-reviews').call({
  businessIds: ['1018907821'],
  maxItems: 20
});
console.log(run.defaultDatasetId);
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient('MY-APIFY-TOKEN')
run = client.actor('automation-lab/yandex-maps-places-reviews').call(run_input={
    'businessIds': ['1018907821'],
    'maxItems': 20,
})
print(run['defaultDatasetId'])
```

#### cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/automation-lab~yandex-maps-places-reviews/runs?token=MY-APIFY-TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"businessIds":["1018907821"],"maxItems":20}'
```

### MCP usage

Use this actor from Claude Desktop or Claude Code through Apify MCP.

MCP server URL:

```text
https://mcp.apify.com/?tools=automation-lab/yandex-maps-places-reviews
```

Claude Code setup:

```bash
claude mcp add --transport http apify \
  "https://mcp.apify.com?tools=automation-lab/yandex-maps-places-reviews"
```

#### Claude Desktop setup

Use this JSON configuration:

```json
{
  "mcpServers": {
    "apify-yandex-reviews": {
      "url": "https://mcp.apify.com/?tools=automation-lab/yandex-maps-places-reviews"
    }
  }
}
```

#### Cursor setup

Add the same remote server URL in Cursor MCP settings.

#### VS Code setup

Add the same remote server URL in your VS Code MCP extension or workspace configuration.

Example prompt:

```text
Scrape the newest 20 Yandex Maps reviews for business ID 1018907821 and summarize the main complaints.
```

Another prompt:

```text
Find Yandex Maps reviews for cafe pushkin in Moscow and return reviewer names, ratings, dates, and review text.
```

### Scheduling

Run the actor daily or weekly to monitor public review changes.

Use a fixed set of business IDs for stable recurring jobs.

Export the dataset after each run or connect it to a webhook.

### Common workflows

#### Competitor review monitoring

Search for category leaders, collect recent reviews, and compare ratings and complaints.

#### Branch QA

Run one business ID per branch and track low-rated reviews.

#### Agency reporting

Export review records into a monthly reputation report.

#### Owner reply audit

Use `ownerReplyText` to check whether businesses respond to public feedback.

### Limitations

Yandex Maps may expose different metadata by region, locale, and organization.

Some places have few or no public reviews.

Reviewer profile URLs and owner replies are included only when Yandex returns them publicly.

Search-query discovery depends on Yandex Maps search context, so exact URLs or IDs are more deterministic.

### Troubleshooting

#### Why did I get zero reviews?

Check that the place has public Yandex Maps reviews and try `locale: "ru_RU"`.

#### Why is place name missing?

Place names are available when the actor discovers places from search. Raw business IDs and some URLs may only provide review data.

#### Why does search find a different place?

Add `coordinates`, `span`, and the correct `regionId` to narrow the Yandex Maps search area.

### Data quality notes

The actor stores the raw public review identifiers returned by Yandex Maps.

Timestamps are ISO strings when provided by the source.

Photo arrays are empty when reviews have no public images.

### Legality

This actor extracts publicly available information from Yandex Maps.

Use the data responsibly and comply with applicable laws, platform terms, privacy obligations, and your own legal requirements.

Do not use scraped personal data for spam, harassment, or unlawful profiling.

### Related scrapers

- https://apify.com/automation-lab/google-maps-lead-finder
- https://apify.com/automation-lab/google-maps-reviews-scraper
- https://apify.com/automation-lab/yandex-maps-lead-finder
- https://apify.com/automation-lab/trustpilot-scraper

### FAQ

#### Can I scrape multiple places in one run?

Yes. Add multiple URLs, business IDs, or search queries.

#### Can I get only new reviews?

Use `sort: "by_time"` and keep your own previous `reviewId` list for deduplication.

#### Does the actor require login?

No. It collects public review data only.

#### Can I scrape by category and city?

Yes. Use a search query such as `restaurants` with `location`, `coordinates`, and `span`.

#### Can I export to CSV?

Yes. Apify datasets support CSV, JSON, Excel, XML, RSS, and HTML exports.

#### Does it scrape private user data?

No. It only returns data exposed publicly by Yandex Maps.

### Changelog

#### 0.1

Initial release with URL, business ID, and search-query input modes.

### Support

If a run fails, share the run URL and input with support so we can reproduce the issue.

### Version

Actor version: 0.1

### End

Ready for structured Yandex Maps review extraction.

# Changelog

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

# Actor input Schema

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

Business keywords with optional location or map coordinates.

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

Direct Yandex Maps organization URLs.

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

Numeric Yandex Maps organization IDs.

## `includeReviews` (type: `boolean`):

Also export individual public review records for every discovered place.

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

Maximum combined place and review records.

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

Maximum businesses discovered for each query.

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

Maximum reviews exported for each business.

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

Sort reviews by newest or relevance.

## `locale` (type: `string`):

Yandex locale such as en\_US or ru\_RU.

## `regionId` (type: `integer`):

Numeric region context used by Yandex search.

## Actor input object example

```json
{
  "searchQueries": [
    {
      "query": "coffee shops",
      "location": "Moscow"
    }
  ],
  "includeReviews": true,
  "maxItems": 20,
  "maxPlacesPerQuery": 10,
  "maxReviewsPerPlace": 20,
  "reviewSort": "by_time",
  "locale": "en_US",
  "regionId": 1
}
```

# Actor output Schema

## `overview` (type: `string`):

Yandex Maps place profiles and individual public 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 = {
    "searchQueries": [
        {
            "query": "coffee shops",
            "location": "Moscow"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/yandex-maps-places-reviews").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": [{
            "query": "coffee shops",
            "location": "Moscow",
        }] }

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/yandex-maps-places-reviews").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": [
    {
      "query": "coffee shops",
      "location": "Moscow"
    }
  ]
}' |
apify call automation-lab/yandex-maps-places-reviews --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,automation-lab/yandex-maps-places-reviews"
        }
    }
}
```

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/3fs85SZXXbNqhXgMb/builds/zpvEoF4YXXbp8OXya/openapi.json