# Yandex Maps Scraper: Leads, Emails & Website Check (`foxlabs/yandex-maps-scraper`) Actor

Yandex Maps businesses in Russia, Türkiye, Kazakhstan and the CIS: phones, website, Telegram/WhatsApp/VK, hours, rating and owner verification. Searches whole cities view by view, not just the first pages. Optional website check: emails with their source and whether the site works.

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

## Pricing

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

## Yandex Maps Scraper: Leads, Emails & Website Check

**Business leads from Yandex Maps for Russia, Türkiye, Kazakhstan and the CIS: phones, website, Telegram/WhatsApp/VK/Instagram, hours, rating and owner verification for any query in any city, plus an optional website check that tells you whether each listed website works and which emails it publishes.**

- 📍 **Whole cities, top places first.** A search starts with the places Yandex ranks highest, then covers the area map view by map view (a full view is split into smaller ones), so a city is not cut off after the first result pages. Only places inside Yandex's outline of the city or district are kept.
- ☎️ **Contacts ready for a CRM.** Phones in E.164 (`+74951399271`), the business website without the usual tracking parameters (utm\_\*, yclid, call-tracking tags…), and every social link Yandex lists (Telegram, WhatsApp, Instagram, VK, Facebook and YouTube in their own columns; all of them, including MAX, Viber, OK and TikTok, in `socialLinks`).
- ✉️ **Emails with their source.** The website check opens the listed website (and its contact page) and returns each email with the page it was found on and its kind: the website's own domain, free mail (gmail, mail.ru, yandex…) or another domain.
- 🩺 **Website health.** Every listed website gets a status: `ok`, `domain-not-found`, `dns-error`, `parked`, `spam`, `hacked`, `empty`, `protected`, `blocked`, `unreachable` or `redirects-to-platform`, with the reason (`no-website` when Yandex lists none).

### Quick start (API)

```bash
curl -X POST "https://api.apify.com/v2/acts/foxlabs~yandex-maps-scraper/run-sync-get-dataset-items?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"queries":["стоматология"],"location":"Москва","maxResults":20}'
```

Twenty dental clinics in Moscow with phones, websites, social links, hours, ratings and (website check on by default) emails and website status.

### What you get

One row per place. Every row has every field (empty when Yandex or the website does not publish it).

| Field | Type | Description |
|---|---|---|
| `type` | text | `place`, or `status` for a row that explains why a search delivered nothing (free) |
| `placeId` | text | Yandex Maps organisation id (stable; use it to join runs) |
| `name`, `category`, `categories` | text | Name and Yandex categories, in the output language |
| `phone`, `phones`, `phonesDetailed` | text | First phone in E.164, and all phones except fax-only ones (E.164; a short service number such as `122` as shown); detailed: shown number, E.164, extension, type (`phone`, `fax` or `phone-fax`) and Yandex's label |
| `email`, `emails`, `emailsDetailed` | text | Website check only. Best email first (the website's own domain, then free mail, then other domains; job, press and marketing addresses last within each kind); detailed: `{ email, type, source }` |
| `website`, `websites`, `websiteDomain` | text | The business's own website (tracking parameters removed, international domains readable); `websites` also lists the social, booking, directory, short-link or marketplace pages Yandex shows (known ones are not checked; a page of an unknown directory can still be taken for the website) |
| `websiteStatus`, `websiteStatusReason`, `websiteFinalUrl`, `contactPageUrl` | text | Website check only: status, why, where the site ended up after redirects, the contact page that was read |
| `telegram`, `whatsapp`, `instagram`, `vk`, `facebook`, `youtube` | link | Yandex's link first; for Telegram, WhatsApp and Instagram the website's link when Yandex has none |
| `socialLinks` | list | Every social link Yandex lists (`{ type, url }`), including MAX, Viber, OK, TikTok |
| `instagramFromWebsite`, `whatsappFromWebsite`, `telegramFromWebsite` | link | What the website itself links to |
| `rating`, `ratingCount`, `reviewCount` | number | Yandex rating (empty when Yandex shows no score), number of ratings and written reviews |
| `workingHoursText`, `workingHours`, `isOpenNow` | text | Yandex's own text, a Monday-first weekly schedule (`09:00–18:00`, `closed`, `24 hours`), open at scrape time |
| `status` | text | `open`, `temporarily-closed` or `permanently-closed` |
| `verifiedOwner` | boolean | The owner confirmed the listing on Yandex (Yandex Business) |
| `chainName`, `chainId` | text | Chain or brand, when Yandex links the branch to one |
| `address`, `street`, `house`, `district`, `city`, `country`, `postalCode`, `latitude`, `longitude` | text / number | Address parts and coordinates |
| `yandexMapsUrl` | link | The place on Yandex Maps |
| `searchQuery`, `searchLocation`, `language`, `scrapedAt`, `error` | text | Which search found the place, when; `error` only on status rows |

#### Sample output

A real row from a test run on the Apify platform on 2026-10-01 (query `стоматология`, location `Москва`; a few fields omitted):

```json
{
  "type": "place",
  "placeId": "1421737716",
  "name": "Artemida Dental Clinic",
  "category": "Стоматологическая клиника",
  "phone": "+79688567171",
  "email": "info@artemidaclinic.ru",
  "emailsDetailed": [{ "email": "info@artemidaclinic.ru", "type": "website-domain", "source": "https://artemidaclinic.ru/" }],
  "website": "http://www.artemidaclinic.ru",
  "websiteStatus": "ok",
  "contactPageUrl": "https://artemidaclinic.ru/contact/",
  "telegram": "https://t.me/ArtemidaClinic",
  "whatsapp": "https://wa.me/79688567171",
  "vk": "https://vk.ru/artemidaclinic",
  "rating": 4.9,
  "ratingCount": 266,
  "reviewCount": 132,
  "workingHoursText": "ежедневно, 10:00–20:00",
  "status": "open",
  "verifiedOwner": true,
  "address": "Москва, район Троицк, 6-я Нововатутинская улица, 3",
  "city": "Москва",
  "postalCode": "108836",
  "latitude": 55.514629,
  "longitude": 37.354547,
  "yandexMapsUrl": "https://yandex.ru/maps/org/artemida_dental_clinic/1421737716/"
}
```

### Input & filters

| Field | What it does | Default |
|---|---|---|
| `queries` | What you would type into Yandex Maps, one per line (`стоматология`, `diş kliniği`, `кафе`). A place found by several queries is delivered once. | — |
| `location` | City, district or region in any language (`Москва`, `Kazan`, `Kadıköy, İstanbul`, `Алматы`). The whole area is searched, and only places inside Yandex's outline of it are kept (the surrounding rectangle when Yandex has no outline). | — |
| `coordinates` + `radiusKm` | Search around a point instead: `"55.7558, 37.6176"` and a radius in km (places within that distance). Overrides `location`. | radius 3 |
| `maxResults` | Places for the whole run, shared by all queries. The places Yandex ranks highest come first (its first four result pages), then the map views of the whole area, starting with those nearest the centre. `0` = the whole area (safety caps: 100,000 places per run, 2,000 Yandex requests per query). | 500 |
| `checkWebsites` | Website check: status, emails, Instagram/WhatsApp/Telegram from the website. | on |
| `leadFilter` | Only places with a phone, a website or an email. Others are skipped and not charged. | all |
| `minRating` | Skip places rated below 3.5 / 4 / 4.5 / 4.8 (and unrated ones). | any |
| `skipClosed` | Skip places Yandex marks as permanently closed. | on |
| `language` | Output language: `ru`, `tr`, `en` or automatic: from the country of `location` (Turkish for Türkiye, Russian for Russia and the CIS, English elsewhere); with `coordinates`, Turkish inside Türkiye's bounding box and Russian elsewhere; for place links, the link's Yandex domain. | automatic |
| `placeUrls` | Yandex Maps place links or ids, to read specific places (filters do not apply to them). | — |
| `proxyConfiguration`, `residentialFallback` | Apify Proxy (datacenter pool by default); switch to residential proxy if Yandex keeps refusing. | on |

Without `location` and `coordinates`, Yandex reads the place from the query text (`кафе Казань`) and only the first eight result pages are read.

### Example inputs (copy & paste)

**Dentists in Moscow that publish an email:**

```json
{ "queries": ["стоматология"], "location": "Москва", "maxResults": 200, "leadFilter": "with-email" }
```

**Dental clinics across the whole of Eskişehir (Türkiye), in Turkish:**

```json
{ "queries": ["diş kliniği"], "location": "Eskişehir", "maxResults": 0 }
```

**Cafés within 2 km of a point in Kadıköy, rated 4.5 or higher:**

```json
{ "queries": ["kafe"], "coordinates": "40.9819, 29.0303", "radiusKm": 2, "minRating": "4.5", "maxResults": 100 }
```

**Specific places by their Yandex Maps links:**

```json
{ "placeUrls": ["https://yandex.ru/maps/org/sozvezdiye/18986838066/", "https://yandex.com.tr/harita/org/serdent/35634361041/"] }
```

### Use cases

- **B2B lead lists** for sales teams and agencies in Russia, Türkiye, Kazakhstan and the CIS: a category in a city, with phones, messengers and emails.
- **Web-design and marketing agencies:** find businesses whose listed website is dead, parked, hacked or missing (`websiteStatus`).
- **Local SEO and reputation tracking:** rating, number of ratings, written reviews and owner verification for the competitors in a district; repeat the run on a schedule and join on `placeId`.
- **Market mapping:** the clinics, cafés or car services Yandex Maps lists across a city, where they are (coordinates) and which chains they belong to.
- **Data hygiene:** refresh the phones, websites and website status of places you already have, by their Yandex Maps links (`placeUrls`).

### How it searches a whole city

A single Yandex Maps query pages poorly: in our tests four pages of 25 gave only 53–86 different places, because later pages repeat earlier ones. A small map view, however, returns the places inside it. The Actor therefore reads an area in two steps:

1. **Yandex's own order first:** the first four result pages for a view around the centre of the area, in the order Yandex's search returns them (at most 100 places; fewer, because later pages repeat earlier ones). A run with a small `maxResults` gets these first.
2. **Then view by view, starting with the views nearest the centre:** a view that comes back full (25 results) is split into four smaller views; the smallest views are paged.

Every place is delivered once per run (by `placeId`) and only if it lies inside Yandex's outline of the location, or within `radiusKm` of the point. Yandex does not return every business of a view for a query, so a whole-area search finds more than the map views alone (153 against 142 dental clinics in Eskişehir) but may still miss some. Rows are written as their website checks finish, so the dataset is not in Yandex's order.

### Performance

Test runs of version 0.1.13 on the Apify platform on 2026-10-01 (512 MB memory, website check on):

| Run | Places | Time | Yandex requests | Places with website checked |
|---|---|---|---|---|
| `стоматология`, Москва, 20 places (the default input) | 20 | 29–30 s | 4–6 | 20 |
| `diş kliniği`, Eskişehir, whole city | 153 | 42–70 s | 34 | 51 |
| Eleven searches in Russia, Türkiye and Kazakhstan, 100 places each | 100 | 35–82 s | 12–32 | 11–96 |
| `стоматология`, Москва, 1,200 places | 1,200 | 493 s | 178 | 1,126 |

- A slow website is given about 30 s, and one that does not answer the platform up to 20 s more through the proxy (the slowest in these runs took 53 s), so one slow website can add up to about 50 s to a short run.
- A city search also reads the places around the city and drops them (not charged): the 1,200-place Moscow run got 1,400 search results outside Moscow's outline (repeats counted), which is why it needed 178 Yandex requests.
- Looking up the area (the city's outline on Yandex) took 2–19 s in these runs. Yandex's answer for a big city is several megabytes and some sessions are slow to deliver it, so a second request on another session starts after 8 s; before that change it took more than 20 s in 15 of 91 runs, up to 102 s.
- In 171 test runs on the platform whose request counts were saved (3,651 Yandex requests, all versions; 64 more short input-check runs all succeeded) Yandex showed no captcha and no rate limit; 21 slow answers were retried through a fresh IP, no search failed and the residential fallback was never needed.
- 512 MB of memory is enough: the 1,200-place run peaked at 296 MB; the highest peak in these runs was 377 MB (200 places with the email filter).

### Integrations

**JavaScript**

```js
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: 'YOUR_APIFY_TOKEN' });
const run = await client.actor('foxlabs/yandex-maps-scraper').call({ queries: ['кафе'], location: 'Казань', maxResults: 100 });
const { items } = await client.dataset(run.defaultDatasetId).listItems();
```

**Python**

```python
from apify_client import ApifyClient
client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("foxlabs/yandex-maps-scraper").call(run_input={"queries": ["avukat"], "location": "Ankara", "maxResults": 100})
items = client.dataset(run["defaultDatasetId"]).list_items().items
```

Make, n8n and Zapier work with Apify Actors through Apify's integrations (Actor `foxlabs/yandex-maps-scraper`); AI agents can call Apify Actors through the Apify MCP server.

### Data quality

Measured in test runs of version 0.1.13 on the Apify platform on 2026-10-01. The share of places with each field depends on the country, the category and how far into a city you go.

**The first 100 places of a search** (Yandex's top-ranked places first, then the map views nearest the centre; 11 searches, 1,100 places):

| Field | Russia (500) | Türkiye (500) | Kazakhstan (100) |
|---|---|---|---|
| Phone | 99.8% | 98% | 100% |
| Own website | 80% | 31% | 64% |
| Email (website check) | 47% | 18% | 31% |
| Any social link | 90% | 64% | 88% |
| Rating | 99% | 86% | 100% |
| Working hours | 99.8% | 89% | 99% |
| Owner verified on Yandex | 70% | 0.4% | 10% |

Russia: dentists in Moscow, cafés in Saint Petersburg, car services in Kazan, lawyers in Yekaterinburg, beauty salons in Novosibirsk. Türkiye: cafés in Kadıköy, car services in İzmir, dental clinics in Eskişehir, hairdressers in Antalya, lawyers in Ankara. Kazakhstan: dentists in Almaty.

**Whole-city searches:**

| Search | Places | Phone | Own website | Email | Rating | Working hours |
|---|---|---|---|---|---|---|
| `стоматология`, Москва (stopped at 1,200 places) | 1,200 | 99.8% | 94% | 65% | 100% | 99.9% |
| `diş kliniği`, Eskişehir (the whole city) | 153 | 96% | 33% | 22% | 60% | 63% |

- The category matters as much as the country: an email was found for 70% of Moscow dentists, 62% of Yekaterinburg lawyers and 37% of Ankara lawyers, but for 29% of Kazan car services, 8% of İzmir car services and 6% of Antalya hairdressers.
- A whole-city search also reaches small practices with fewer details: in Eskişehir the rating was filled for 60% and the hours for 63% of the whole city, against 80% and 64% of the first 100 places.
- Of 619 places with their own website in the eleven 100-place searches (554 different websites), 542 opened normally (`ok`); 35 had almost no text in their HTML (`empty`, possibly a JavaScript-only site), 20 could not be read (`unreachable`: an HTTP error such as 404 or 5xx, a TLS certificate error, a refused connection or no answer), 7 showed a bot check (`protected`), 5 refused our check (`blocked`), 4 carried spam, 3 were parked, 2 had a DNS error and 1 had no domain. An email was found for 353 of the 619.
- Some websites do not answer the Apify platform's own address: in the 1,200-place Moscow run 47 did not, and 42 of them opened through Apify Proxy.
- Yandex hides the score of a few places that have ratings (2 of 1,100): `rating` is empty there, never 0.
- Emails come only from the website Yandex lists for the business (home page and contact page). Regulators' and insurance funds' addresses that Russian clinic sites must show, counter and placeholder addresses, hosting-provider addresses and the pages of booking, directory and link services are left out; a few such addresses may still slip through.
- Each place is delivered once per run: `placeId` was unique in every test run of version 0.1.13 (1,200 of 1,200 in the largest).

Apify run IDs: Moscow 1,200 `hofahl8LjFmCHiOwQ`, Eskişehir `FyPnFRWfpYTjkXdy9`; 100-place runs `fEcpDWv8ZrLyxWgwx`, `x1W8TZVe1nr4vIiP6`, `v5RMM8f9hNCPSUTEq`, `8XZOeQA7877kkUWyB`, `Qwh6XTZ7h3J5yFJBe`, `IVpsyC8ZdEXfmAHos`, `GJEyO27Kz1Nzn0fKJ`, `fGXFmWkQyQQgynY5r`, `Icit7xNNBgAvNBalz`, `1MZ5iwNeipc8e0ZVd`, `I5dTbK3VYU7cSlVZN`.

### Pricing

Pay per event:

- `place`: one per delivered place row;
- `site-checked`: one per delivered place whose website was checked (only when the website check is on and Yandex lists the business's own website, not only a social, booking or directory page).

Status rows, duplicates, places outside the area and places removed by your filters are not charged. A run never delivers more places than your "Maximum cost per run" allows. See the Pricing tab for the current prices.

### FAQ

**Do I need a Yandex account or an API key?** No.

**Which countries work?** Russia, Türkiye and Kazakhstan were measured (see Data quality). Yandex Maps also covers the rest of the CIS and other countries; those were not measured here. Use Russian queries in Russia and the CIS and Turkish queries in Türkiye.

**Why do Turkish places have fewer websites and almost no owner verification?** That is what Yandex Maps holds for Türkiye (see Data quality).

**Where do the emails come from?** From the business's own website only (home page and contact page). Yandex Maps itself shows no emails.

**What does `hacked` mean?** The website looks like the business's own (its name is in the page title or the domain), but the page links to gambling sites.

**Is a place delivered twice when two queries find it?** No. Each place is delivered and charged once per run.

**Can I get reviews?** Not in this version: the Actor delivers the rating and the number of ratings and reviews, not the review texts.

**Can I run it on a schedule?** Yes. `placeId` is stable, so you can compare ratings, hours or website status between runs.

### Troubleshooting

- **No results:** check the spelling of the location; try a Russian query in Russia and the CIS. The free status row and the `SOURCE_REPORT` record in the key-value store say why each search delivered nothing.
- **Fewer places than `maxResults`:** the area has no more places for that query, or filters removed them (the log counts both).
- **A website shows `blocked` or `unreachable`:** `blocked` means the site answered 401, 403, 429 or 451. `unreachable` means another HTTP error (404, 5xx…), a TLS certificate error, a refused connection or no answer; only a site that does not answer is tried again through Apify Proxy. Either may still work from another network.
- **Short share links (`/maps/-/…`)** are not supported; open the link and paste the full place URL.

### Notes, limits & legal

- The Actor reads public Yandex Maps listings and the public websites of the listed businesses. It does not log in.
- Yandex's terms restrict automated and commercial use of its content; you are responsible for how you use the data.
- Phone numbers and emails of sole proprietors, and free-mail addresses, can be personal data under GDPR, KVKK (Türkiye) or 152-FZ (Russia). Check your marketing law before cold outreach (in Türkiye, Law 6563 art. 6).
- Names, addresses and categories come in Yandex's own translation for the chosen language.
- A region's outline on Yandex can include the city it surrounds: a search in `Московская область` also returns places in Moscow (in a test, the first 20 were all in Moscow). Filter on `city` if you need the region without the city.

### Support

Questions or a field you miss: info@foxlabs.com.tr, or open an issue on the Actor's page.

### Changelog

#### 0.1 — 2026-10-01

First version: search by query and area (location or coordinates; Yandex's top-ranked places first, then the whole area map view by map view), places by URL or id, website check with emails and website status, filters (phone, website, email, rating, closed), Russian, Turkish and English output. Batch mode; prepared for a Standby API.

***

*Built by foXLabs.*

# Changelog

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

# Actor input Schema

## `queries` (type: `array`):

One query per line: a business type or a name. Russian queries find the most in Russia and the CIS (стоматология, кафе, автосервис), Turkish ones in Türkiye (diş kliniği, kafe, avukat). A place found by several queries is delivered and charged once.

## `location` (type: `string`):

City, district or region in any language, for example Москва, Kazan, Eskişehir, Kadıköy, İstanbul, Алматы. The whole area is searched, and only places inside Yandex Maps' outline of it are kept. Leave empty to use Coordinates, or to let Yandex read the place from the query text (then only the first result pages are read).

## `coordinates` (type: `string`):

Search around a point instead of a named place: "latitude, longitude" as Yandex and Google Maps show them, for example "55.7558, 37.6176". Used together with Radius. Overrides Location.

## `radiusKm` (type: `integer`):

Only used with Coordinates: places within this many kilometres of the point.

## `maxResults` (type: `integer`):

Maximum number of places for the whole run, shared by all queries (each place is charged once). The places Yandex ranks highest come first. Helps control cost. Set to 0 for no limit: the whole area is searched.

## `checkWebsites` (type: `boolean`):

Open the website each place lists on Yandex Maps: say whether it works (ok, domain not found, parked or for sale, spam, empty, unreachable, blocks us) and collect the emails it publishes (with the page they were found on and their kind: the website's own domain, free mail or another domain) plus Instagram, WhatsApp and Telegram links. Charged per place whose website was checked.

## `leadFilter` (type: `string`):

Deliver only places that have this contact. Places without it are skipped and not charged. "Email" needs the website check and switches it on.

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

Skip places rated below this on Yandex Maps (places without a rating are skipped too when a minimum is set). Skipped places are not charged.

## `skipClosed` (type: `boolean`):

Yandex marks some listings as permanently closed. On by default: they are skipped and not charged. Temporarily closed places are always delivered.

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

Language of names, addresses and categories. Automatic uses Turkish for places in Türkiye, Russian for Russia and the CIS, English elsewhere.

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

Yandex Maps place links such as https://yandex.com/maps/org/name/1018907821/ (any Yandex domain), or the number alone. Filters do not apply to places you list. Short share links (/maps/-/…) are not supported.

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

Apify Proxy without a group (the datacenter pool) works for Yandex Maps and is the default. The Actor switches to residential proxy on its own if Yandex keeps refusing (see the next setting).

## `residentialFallback` (type: `boolean`):

If Yandex answers several requests in a row with a captcha or a rate limit, continue through Apify residential proxy. The price per place stays the same.

## Actor input object example

```json
{
  "queries": [
    "стоматология"
  ],
  "location": "Москва",
  "radiusKm": 3,
  "maxResults": 20,
  "checkWebsites": true,
  "leadFilter": "all",
  "minRating": "any",
  "skipClosed": true,
  "language": "auto",
  "proxyConfiguration": {
    "useApifyProxy": true
  },
  "residentialFallback": true
}
```

# Actor output Schema

## `dataset` (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 = {
    "queries": [
        "стоматология"
    ],
    "location": "Москва",
    "maxResults": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("foxlabs/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 = {
    "queries": ["стоматология"],
    "location": "Москва",
    "maxResults": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("foxlabs/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 '{
  "queries": [
    "стоматология"
  ],
  "location": "Москва",
  "maxResults": 20
}' |
apify call foxlabs/yandex-maps-scraper --silent --output-dataset

```

## MCP server setup

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