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

Search Yandex Maps by query and area and export structured public places with contacts, ratings, categories, hours, and coordinates.

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

## Pricing

Pay per event

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/platform/actors/running/actors-in-store#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 Places Scraper

Search **Yandex Maps places** by business query and area, then export structured public listings to JSON, CSV, Excel, or your data pipeline.

The Actor returns stable place IDs, names, addresses, categories, public phone numbers, websites, ratings, review counts, opening information, coordinates, and canonical Yandex Maps URLs when Yandex provides them.

Use it for one-time local-market analysis or schedule it to refresh the same searches repeatedly.

### What does Yandex Maps Places Scraper do?

The Actor turns Yandex Maps search results into a clean Apify dataset.

You provide one or more searches such as:

- coffee shops in Berlin;
- pharmacies in Almaty;
- coworking spaces in Moscow;
- car repair services in Istanbul.

For each search, it:

1. opens a coherent Yandex Maps web session;
2. searches the requested query and area;
3. follows result pages up to your limits;
4. normalizes public business data;
5. deduplicates places by stable Yandex ID;
6. saves only useful place records;
7. charges only for saved records.

It uses Yandex's structured map-search response instead of launching a browser, which keeps runs fast and resource-efficient.

### Who is this Yandex Maps data tool for?

This Actor is useful for:

- lead-generation teams building public business lists;
- local SEO specialists auditing market coverage;
- agencies researching competitors by city or district;
- retail and expansion analysts comparing local categories;
- data teams refreshing business directories;
- developers adding Yandex Maps records to enrichment pipelines;
- researchers tracking listing changes between scheduled runs.

Choose this Actor when the unit you need is a **place or business listing**.

For customer-review text, use [Yandex Maps Reviews Scraper](https://apify.com/automation-lab/yandex-maps-reviews-scraper) instead.

For a lead-focused preset, see [Yandex Maps Lead Finder](https://apify.com/automation-lab/yandex-maps-lead-finder).

### Why use this Actor?

- **Area-aware searches:** combine a business query with a city, district, region, or coordinates.
- **Multiple searches per run:** refresh several category/market combinations together.
- **Stable deduplication:** repeated results are collapsed by Yandex place ID.
- **Typed output:** records work directly in spreadsheets, databases, and APIs.
- **Public contacts:** phone and website fields are included when visible in the source.
- **Predictable limits:** control global and per-query result counts.
- **No API key:** users do not need a Yandex developer credential.
- **Lightweight runtime:** direct structured requests run with 256 MB memory.

The Actor does not scrape unrelated Yandex products such as Yandex Games or Yandex Disk.

### What Yandex Maps place data can I extract?

| Field | Meaning |
| --- | --- |
| `placeId` | Stable Yandex Maps business identifier |
| `name` | Public place or business name |
| `description` | Short locality or source description |
| `address` | Public address |
| `country` | Country returned by Yandex |
| `categories` | Business categories |
| `phone` | Primary public phone number |
| `phones` | All returned public phone numbers |
| `website` | Public website, when present |
| `rating` | Average Yandex Maps rating |
| `reviewCount` | Rating or review count |
| `priceCategory` | Source price label, when present |
| `isOpen` | Current open status, when present |
| `workingHours` | Human-readable hours summary |
| `latitude` | Place latitude |
| `longitude` | Place longitude |
| `yandexUrl` | Canonical Yandex Maps place URL |
| `searchQuery` | Query that found the place |
| `searchLocation` | Area supplied with the query |
| `scrapedAt` | Collection timestamp |

Yandex does not expose every field for every listing. Missing values are returned as `null` or an empty array rather than invented.

### How to scrape Yandex Maps places

1. Open the Actor in Apify Console.
2. Add at least one item to **Search queries and areas**.
3. Enter a category, service, brand, or place type in `query`.
4. Add a city, district, region, or address in `location`.
5. Optionally add map-center coordinates and span for tighter geographic context.
6. Set `maxItems` for the total dataset size.
7. Set `maxItemsPerQuery` to balance several searches.
8. Choose the locale that best matches the target market.
9. Click **Start**.
10. Open the Dataset tab and export JSON, CSV, Excel, XML, or RSS.

A small real input:

```json
{
  "searchQueries": [
    {
      "query": "coffee shops",
      "location": "Berlin",
      "coordinates": "13.405,52.52",
      "span": "0.2,0.2"
    }
  ],
  "maxItems": 20,
  "maxItemsPerQuery": 20,
  "locale": "en_US",
  "regionId": 10174
}
```

### Input parameters

#### `searchQueries`

Required array of search objects.

Each object supports:

- `query` — required business category, brand, service, or place type;
- `location` — optional city, district, region, or address;
- `coordinates` — optional map center as `longitude,latitude`;
- `span` — optional viewport size as `longitudeSpan,latitudeSpan`.

Use both location text and coordinates when a city name is ambiguous.

#### `maxItems`

Maximum unique places saved across all queries.

- default: `100`;
- minimum: `1`;
- maximum: `10000`.

#### `maxItemsPerQuery`

Maximum places accepted from each query.

This is useful when one broad query would otherwise consume the whole global limit.

- default: `20`;
- minimum: `1`;
- maximum: `1000`.

#### `locale`

Controls source language and country formatting.

Supported presets:

- `en_US`;
- `ru_RU`;
- `tr_TR`;
- `kk_KZ`.

#### `regionId`

Numeric Yandex region context.

Most users can rely on location text and coordinates. Set the region ID when you already know the appropriate Yandex region or need repeatable regional context.

### Output example

This shape comes from a current local run against a real Berlin coffee search; identifying details are shortened for documentation:

```json
{
  "placeId": "12313932984",
  "name": "Coffee Bike Berlin Coffee Tom",
  "description": "Berlin, Schönhauser Allee, 58A",
  "address": "Berlin, Schönhauser Allee, 58A",
  "country": "Germany",
  "categories": ["Coffee shop"],
  "phone": "+493080932154",
  "phones": ["+493080932154"],
  "website": null,
  "rating": null,
  "reviewCount": null,
  "priceCategory": null,
  "isOpen": null,
  "workingHours": null,
  "latitude": null,
  "longitude": null,
  "yandexUrl": "https://yandex.com/maps/org/12313932984/",
  "searchQuery": "coffee shops",
  "searchLocation": "Berlin",
  "source": "Yandex Maps",
  "scrapedAt": "2026-08-09T20:09:24.249Z"
}
```

The default dataset is the primary output, so standard Apify integrations work without custom storage names.

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

Pricing uses one `start` event per run plus one `item` event for each unique place saved.

At the FREE tier:

- start: **$0.01 per run**;
- place: **$0.0045172 per saved place**.

Examples at FREE-tier prices:

| Saved places | Estimated Actor charge |
| ---: | ---: |
| 10 | $0.0552 |
| 100 | $0.4617 |
| 1,000 | $4.5272 |

Paid Apify plans receive lower item prices. The BRONZE tier is $0.01 per start and $0.003928 per place.

Failed, duplicate, and rejected place records do not receive an item charge. Apify may separately apply normal platform limits or account policies.

### Recurring local-market refresh workflow

To monitor a market without claiming that the Actor performs change detection itself:

1. save a Task with stable queries and limits;
2. schedule the Task daily, weekly, or monthly;
3. export each run's dataset to your database or cloud storage;
4. join records by `placeId`;
5. compare rating, review count, address, phone, website, and category fields;
6. alert in your own workflow when values change.

This approach separates reliable extraction from business-specific change rules.

### Lead-list and spreadsheet workflow

For a simple prospecting export:

1. search one service category per area;
2. keep `maxItemsPerQuery` equal across cities;
3. run the Actor;
4. export the dataset as CSV or Excel;
5. filter rows with non-null `phone` or `website`;
6. review applicable outreach and privacy rules before contact.

The Actor extracts public listing data; it does not validate phone ownership, email addresses, or consent.

### Tips for better area coverage

- Use the local language for the category when Yandex coverage is stronger in that language.
- Put the city or district in `location`, not only in the query.
- Add `coordinates` and `span` for precise view-based searches.
- Split large countries into several city or district searches.
- Keep recurring Task inputs stable so dataset comparisons remain meaningful.
- Use `maxItemsPerQuery` to prevent broad queries from dominating multi-city runs.
- Expect nearby or category-adjacent businesses when Yandex's ranking considers them relevant.

### Limits and failure behavior

Yandex Maps is an evolving third-party source.

Important limitations:

- search ranking and available fields can change;
- some places have no public phone, website, rating, hours, or coordinates;
- an area query is relevance-ranked, not a guarantee of exhaustive geographic coverage;
- source pagination can stop before a requested maximum;
- temporary rate limits or session challenges can interrupt a run;
- identical businesses may occasionally have separate Yandex place IDs;
- the Actor does not scrape reviews, photos, menus, or historical snapshots;
- it does not perform geofencing after extraction beyond the supplied source search context.

Transient network, HTTP 429, and server errors receive bounded retries. Persistent upstream failures make the run fail instead of returning a misleading empty success.

### Integrations

Connect results through:

- Google Sheets;
- Microsoft Excel exports;
- webhooks;
- Zapier;
- Make;
- Slack notifications;
- cloud storage;
- SQL warehouses;
- Python or JavaScript data pipelines;
- the Apify API;
- Apify MCP tools.

Use `placeId` as the preferred key when merging recurring datasets.

### Use the API with cURL

Replace `APIFY_TOKEN` with your token:

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~yandex-maps-places-scraper/runs?token=APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "searchQueries": [{"query":"pharmacies","location":"Almaty"}],
    "maxItems": 25,
    "locale": "kk_KZ",
    "regionId": 162
  }'
```

Fetch dataset items after the run succeeds:

```bash
curl "https://api.apify.com/v2/datasets/DATASET_ID/items?format=json&clean=true&token=APIFY_TOKEN"
```

### Use the API with JavaScript

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/yandex-maps-places-scraper').call({
  searchQueries: [
    { query: 'coworking spaces', location: 'Moscow' },
    { query: 'coworking spaces', location: 'Almaty' }
  ],
  maxItems: 40,
  maxItemsPerQuery: 20,
  locale: 'en_US'
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### Use the API with Python

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/yandex-maps-places-scraper').call(run_input={
    'searchQueries': [
        {'query': 'car repair', 'location': 'Istanbul'}
    ],
    'maxItems': 50,
    'locale': 'tr_TR'
})

for item in client.dataset(run['defaultDatasetId']).iterate_items():
    print(item)
```

### Use Yandex Maps Places Scraper with MCP

Add the Actor to Claude Code:

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

#### Claude Desktop MCP setup

Add this remote server in Claude Desktop's MCP configuration.

#### Cursor MCP setup

Use the same server object in Cursor's MCP settings.

#### VS Code MCP setup

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

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

Example prompts showing MCP usage:

- “Find 20 coffee shops on Yandex Maps in Berlin and return phone numbers.”
- “Export pharmacies in Almaty to a structured dataset.”
- “Run my three-city coworking search and summarize listings with websites.”

### Responsible and legal use

Yandex Maps contains public business information, but public availability does not remove legal obligations.

You are responsible for:

- following Yandex's applicable terms and policies;
- complying with database, privacy, marketing, and consumer laws;
- collecting only data needed for a legitimate purpose;
- securing exported datasets;
- honoring deletion, correction, and opt-out requirements where applicable;
- avoiding spam, harassment, discrimination, or invasive profiling;
- reviewing outreach rules before using phone numbers for contact.

This Actor does not bypass logins and does not require user credentials.

### Troubleshooting

#### Why did I receive fewer places than `maxItems`?

`maxItems` is a ceiling, not a promise. The source may return fewer relevant results, repeat the same place, or stop pagination for that query.

Try a broader category, a larger span, or several district-level searches.

#### Why are phone, website, rating, or coordinates null?

Yandex did not provide that field in the search result. The Actor preserves missing values instead of guessing.

Try a more specific search or open `yandexUrl` to inspect the public listing.

#### Why did the run fail after retries?

Yandex may be rate-limiting requests or changing its session response.

Inspect the run log. Retry later with a smaller workload rather than launching many simultaneous runs.

#### How do I avoid duplicates across runs?

Store `placeId` in your destination and upsert on that field. Deduplication inside one run is automatic.

### FAQ

#### Does this Actor need a Yandex API key?

No. It reads the same structured public search data used by the Yandex Maps web experience.

#### Does it collect reviews?

No. Use [Yandex Maps Reviews Scraper](https://apify.com/automation-lab/yandex-maps-reviews-scraper) for individual review records.

#### Can I search several cities in one run?

Yes. Add one search object per category and area, then control balance with `maxItemsPerQuery`.

#### Can I schedule recurring scans?

Yes. Save the input as an Apify Task and attach a schedule. Compare datasets downstream by `placeId`.

#### Is every search geographically exhaustive?

No. Yandex ranks results by relevance and viewport context. For better coverage, split a large area into multiple searches.

#### Can I export to CSV or Excel?

Yes. Open the Dataset tab and choose the preferred format, or request it through the dataset API.

### Related Automation Lab Actors

- [Yandex Maps Reviews Scraper](https://apify.com/automation-lab/yandex-maps-reviews-scraper) — extract individual public reviews for known places.
- [Yandex Maps Lead Finder](https://apify.com/automation-lab/yandex-maps-lead-finder) — use a lead-focused Yandex Maps workflow.
- [Google Maps Scraper](https://apify.com/automation-lab/google-maps-scraper) — compare listings on another maps source when your workflow supports cross-source matching.

Each source has different IDs, coverage, ranking, and field availability. Do not assume records from different maps platforms are identical without an explicit matching step.

# Actor input Schema

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

Business searches with a query, location, and optional map coordinates/span.

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

Maximum unique place records saved across all searches.

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

Maximum records accepted from each query, before global deduplication.

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

Language and country code used by Yandex Maps.

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

Optional numeric Yandex region context. The location text and coordinates normally provide the area scope.

## Actor input object example

```json
{
  "searchQueries": [
    {
      "query": "coffee shops",
      "location": "Berlin",
      "coordinates": "13.405,52.52",
      "span": "0.2,0.2"
    }
  ],
  "maxItems": 20,
  "maxItemsPerQuery": 20,
  "locale": "en_US",
  "regionId": 1
}
```

# Actor output Schema

## `dataset` (type: `string`):

Dataset containing all extracted Yandex Maps place records.

# 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": "Berlin",
            "coordinates": "13.405,52.52",
            "span": "0.2,0.2"
        }
    ],
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/yandex-maps-places-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": [{
            "query": "coffee shops",
            "location": "Berlin",
            "coordinates": "13.405,52.52",
            "span": "0.2,0.2",
        }],
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/yandex-maps-places-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": [
    {
      "query": "coffee shops",
      "location": "Berlin",
      "coordinates": "13.405,52.52",
      "span": "0.2,0.2"
    }
  ],
  "maxItems": 20
}' |
apify call automation-lab/yandex-maps-places-scraper --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-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/iYhcev3BO0ydCdYTh/builds/wBJDwAX7yQzoTReOY/openapi.json