# Yandex Maps Reviews Scraper (`fetch_cat/yandex-maps-reviews-scraper`) Actor

Extract public Yandex Maps organization reviews, ratings, reviewer names, dates, likes, and owner replies for reputation monitoring.

- **URL**: https://apify.com/fetch\_cat/yandex-maps-reviews-scraper.md
- **Developed by:** [Hanna Nosova](https://apify.com/fetch_cat) (community)
- **Categories:** Lead generation, SEO tools, Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.28 / 1,000 item 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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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 Reviews Scraper

Scrape public Yandex Maps organization reviews, ratings, reviewer names, dates, likes, and owner replies into a clean dataset.

### Ready-to-run examples

- [Yandex Maps Owner Reply Audit](https://apify.com/fetch_cat/yandex-maps-reviews-scraper/examples/yandex-maps-owner-reply-audit)
- [Yandex Maps Restaurant Review Comparison](https://apify.com/fetch_cat/yandex-maps-reviews-scraper/examples/yandex-maps-restaurant-review-comparison)
- [Yandex Maps Known Organization Reviews](https://apify.com/fetch_cat/yandex-maps-reviews-scraper/examples/yandex-maps-known-organization-reviews)
- [Yandex Maps Hotel Reviews Monitoring](https://apify.com/fetch_cat/yandex-maps-reviews-scraper/examples/yandex-maps-hotel-reviews-monitoring)
- [Yandex Maps Moscow Coffee Reviews](https://apify.com/fetch_cat/yandex-maps-reviews-scraper/examples/yandex-maps-moscow-coffee-reviews)

[View all ready-to-run examples](https://apify.com/fetch_cat/yandex-maps-reviews-scraper/examples)

### What does Yandex Maps Reviews Scraper do?

Yandex Maps Reviews Scraper collects public review rows from Yandex Maps organization pages.

It is built for local SEO teams, reputation managers, market researchers, hospitality operators, retail chains, and agencies that need structured review exports.

The actor accepts direct Yandex Maps organization URLs and can also resolve simple Yandex Maps search queries to organization review pages.

### Why scrape Yandex Maps reviews?

Yandex Maps is a major local discovery channel in many markets.

Reviews influence search visibility, conversion, customer trust, and operational decisions.

Manual review monitoring is slow when a team tracks many stores, restaurants, hotels, clinics, or service locations.

This actor turns public reviews into rows that can be exported to JSON, CSV, Excel, Google Sheets, BI tools, or internal dashboards.

### Who is it for?

- 🏪 **Multi-location operators** use it to monitor branch-level review quality, missed owner replies, and recurring service problems across stores, restaurants, clinics, hotels, or service offices.
- 📈 **Local SEO and reputation agencies** use it to create recurring client reports, prove review-response coverage, and spot locations that need urgent attention.
- 🧭 **Market research teams** use it to compare public customer feedback for competing venues in the same city or category.
- 🧑‍💻 **Data and automation teams** use it to feed public review rows into sentiment analysis, alerts, warehouses, CRMs, and BI dashboards.

Use it when you need structured review rows rather than a general place directory export.

### Typical use cases

Monitor recent customer feedback for local branches.

Collect review text for sentiment analysis.

Track owner replies and response coverage.

Compare ratings across competing businesses.

Build lead lists for reputation management services.

Audit hospitality, restaurant, retail, clinic, and service-location performance.

Archive public reviews for reporting and compliance workflows.

### Input options

You can provide direct Yandex Maps organization URLs in `startUrls`.

You can provide optional search terms in `searchQueries`.

You can limit reviews per place with `maxReviewsPerPlace`.

You can limit resolved organizations per query with `maxPlacesPerQuery`.

You can set the language header with `language`.

You can configure Apify Proxy in `proxyConfiguration`.

### Start URLs

Use public Yandex Maps organization URLs.

Both organization overview URLs and review-tab URLs are accepted.

The actor automatically normalizes organization URLs to the Reviews tab.

Example:

```json
{
  "startUrls": [
    { "url": "https://yandex.com/maps/org/surf_coffee/238919133832/reviews/" }
  ],
  "maxReviewsPerPlace": 25
}
````

### Search queries

Search queries are useful when you do not already know the organization URL.

The actor resolves Yandex Maps search results and then scrapes reviews for the matched places.

Keep queries specific for best results.

Examples:

```json
{
  "searchQueries": ["coffee in Moscow"],
  "maxPlacesPerQuery": 1,
  "maxReviewsPerPlace": 25
}
```

### Input settings

| Setting | JSON key | Type / default | Description |
| --- | --- | --- | --- |
| Yandex Maps organization/reviews URLs | `startUrls` | array, default `[{"url":"https://yandex.com/maps/org/surf_coffee/238919133832/reviews/"}]` | Paste one or more public Yandex Maps organization URLs. Regular org URLs are automatically converted to their Reviews tab. |
| Search queries | `searchQueries` | array, default `["coffee in Moscow"]` | Optional Yandex Maps search terms. The actor resolves the first matching places and then scrapes their reviews. |
| Maximum reviews per place | `maxReviewsPerPlace` | integer, default `20` | Maximum number of review rows to save for each organization. |
| Maximum places per search query | `maxPlacesPerQuery` | integer, default `1` | When using search queries, scrape this many places from each query. |
| Review sort order | `sort` | string, default `"relevance"` | Best effort. Yandex may keep its default relevance ranking depending on UI availability. |
| Accept-Language header | `language` | string, default `"en-US,en;q=0.9"` | Browser locale and HTTP language preference used for Yandex Maps pages. |
| Proxy configuration | `proxyConfiguration` | object, default `{"useApifyProxy":true,"apifyProxyGroups":["RESIDENTIAL"]}` | Apify proxy configuration. Residential proxy is recommended for larger runs if Yandex starts challenging requests. |

### Output fields

| JSON key | Label | Type | Description |
| --- | --- | --- | --- |
| `placeId` | PlaceId | string | Output field for placeid. |
| `placeName` | PlaceName | string / null | Output field for placename. |
| `placeUrl` | PlaceUrl | string | Output field for placeurl. |
| `reviewId` | ReviewId | string | Output field for reviewid. |
| `reviewerName` | ReviewerName | string / null | Output field for reviewername. |
| `reviewerProfileUrl` | ReviewerProfileUrl | string / null | Output field for reviewerprofileurl. |
| `rating` | Rating | number / null | Output field for rating. |
| `reviewText` | ReviewText | string / null | Output field for reviewtext. |
| `reviewDate` | ReviewDate | string / null | Output field for reviewdate. |
| `likes` | Likes | integer / null | Output field for likes. |
| `ownerReplyText` | OwnerReplyText | string / null | Output field for ownerreplytext. |
| `ownerReplyDate` | OwnerReplyDate | string / null | Output field for ownerreplydate. |
| `language` | Language | string / null | Output field for language. |
| `scrapedAt` | ScrapedAt | string | Output field for scrapedat. |

### Example input

```json
{
  "startUrls": [
    {
      "url": "https://yandex.com/maps/org/surf_coffee/238919133832/reviews/"
    }
  ],
  "searchQueries": [
    "coffee in Moscow"
  ],
  "maxReviewsPerPlace": 20,
  "maxPlacesPerQuery": 1,
  "sort": "relevance",
  "language": "en-US,en;q=0.9",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

### Example output

```json
{
  "placeId": "238919133832",
  "placeName": "Surf Coffee",
  "placeUrl": "https://yandex.com/maps/org/surf_coffee/238919133832/reviews/",
  "reviewId": "238919133832-user-may-11",
  "reviewerName": "Ксения В.",
  "reviewerProfileUrl": "https://yandex.com/maps/user/example",
  "rating": 5,
  "reviewText": "Great coffee and friendly staff.",
  "reviewDate": "May 11",
  "likes": 3,
  "ownerReplyText": "Thank you for your review!",
  "ownerReplyDate": "May 24",
  "language": "en-US,en;q=0.9",
  "scrapedAt": "2026-07-03T12:00:00.000Z"
}
```

### Review text

The `reviewText` field contains the visible public review text.

The actor removes common UI suffixes such as expanded text controls when possible.

Very long reviews are collected from the rendered review card.

### Ratings

The `rating` field is parsed from the Yandex Maps star rating accessibility label.

It is returned as a number when available.

If a rendered card does not expose a rating, the value is `null`.

### Owner replies

Many Yandex Maps reviews contain an official organization response.

The actor expands visible business response controls before extraction.

When a response is present, `ownerReplyText` and `ownerReplyDate` are saved.

When no response is present, those fields are `null`.

### Likes

The `likes` field captures the visible like count on a review card when available.

If no count is visible, the value is `null`.

### Dates

Yandex Maps may display relative or localized dates depending on the page language and review age.

The actor returns the date text exactly as shown by Yandex Maps.

Use `language` if you need predictable UI language for downstream parsing.

### Limits

`maxReviewsPerPlace` controls how many reviews are saved per organization.

The default is intentionally small enough for quick tests.

Increase it for production monitoring runs.

Large limits may require proxies because Yandex Maps can throttle heavy browser sessions.

### Proxy configuration

The actor supports Apify Proxy.

Residential proxy is recommended for larger production workloads.

Small local tests can often run without a proxy.

If Yandex Maps displays a challenge or empty page, enable proxy and reduce concurrency by keeping inputs small.

### Performance notes

Review pages are rendered dynamically, so the actor uses Playwright.

Search query resolution uses lightweight HTTP parsing where possible.

The actor scrolls review cards until the requested limit is reached or no new reviews load.

### API usage

Run Yandex Maps Reviews Scraper from your own code with the Apify API.

**Node.js**

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const input = {
  "startUrls": [
    {
      "url": "https://yandex.com/maps/org/surf_coffee/238919133832/reviews/"
    }
  ],
  "searchQueries": [
    "coffee in Moscow"
  ],
  "maxReviewsPerPlace": 20,
  "maxPlacesPerQuery": 1,
  "sort": "relevance"
};

const run = await client.actor('fetch_cat/yandex-maps-reviews-scraper').call(input);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

**Python**

```python
from apify_client import ApifyClient
import os

client = ApifyClient(os.environ["APIFY_TOKEN"])
run = client.actor("fetch_cat/yandex-maps-reviews-scraper").call(run_input={
  "startUrls": [
    {
      "url": "https://yandex.com/maps/org/surf_coffee/238919133832/reviews/"
    }
  ],
  "searchQueries": [
    "coffee in Moscow"
  ],
  "maxReviewsPerPlace": 20,
  "maxPlacesPerQuery": 1,
  "sort": "relevance"
})
items = client.dataset(run["defaultDatasetId"]).list_items().items
print(items)
```

**cURL**

```bash
curl -X POST "https://api.apify.com/v2/acts/fetch_cat~yandex-maps-reviews-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"startUrls":[{"url":"https://yandex.com/maps/org/surf_coffee/238919133832/reviews/"}],"searchQueries":["coffee in Moscow"],"maxReviewsPerPlace":20,"maxPlacesPerQuery":1,"sort":"relevance"}'
```

### How to run with search queries

Leave `startUrls` empty.

Add one or more terms to `searchQueries`.

Set `maxPlacesPerQuery` to control how many organizations each query resolves.

Run the actor and inspect the dataset.

### Integrations

- 📊 **Actor → Google Sheets:** schedule the actor daily or weekly, export the dataset to Google Sheets, and give branch managers a simple review-response tracker.
- 📈 **Actor → BI dashboard:** send dataset exports to BigQuery, Snowflake, Looker Studio, Power BI, or another warehouse/dashboard tool to trend ratings, reply coverage, and complaint themes.
- 🧾 **Actor → CRM or helpdesk:** route low-rating reviews or missing owner replies into HubSpot, Salesforce, Zendesk, or an internal queue for follow-up.
- 🤖 **Actor → AI analysis:** pass fresh review rows to an LLM workflow for sentiment summaries, issue clustering, competitor comparison, or monthly reputation reports.

### Use with AI agents via MCP

Yandex Maps Reviews Scraper can be used by AI assistants through the hosted Apify MCP server.

**Claude Code setup**

```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=fetch_cat/yandex-maps-reviews-scraper"
```

**Claude Desktop, Cursor, or VS Code JSON config**

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

**Example prompts**

- "Run Yandex Maps Reviews Scraper with this input JSON and summarize the dataset."
- "Export the latest Yandex Maps Reviews Scraper results to a table I can review."
- "Schedule this Actor for monitoring and tell me what changed between runs."

### Related actors

- [Apple Maps Places Scraper](https://apify.com/fetch_cat/apple-maps-places-scraper)
- [Ashby Jobs Scraper](https://apify.com/fetch_cat/ashby-jobs-scraper)
- [ATS Jobs Scraper for 6 ATS Sources](https://apify.com/fetch_cat/ats-jobs-scraper)
- [Built In Jobs Scraper](https://apify.com/fetch_cat/builtin-jobs-scraper)
- [Craigslist Classifieds Scraper](https://apify.com/fetch_cat/craigslist-classifieds-scraper)

### Best practices

Prefer direct organization URLs for repeatable monitoring.

Use specific search queries when discovering places.

Start with small limits before scaling up.

Use proxies for production-scale runs.

Store historical datasets if you need trend reporting.

### Troubleshooting

If the dataset is empty, verify the Yandex Maps URL opens publicly in a browser.

If a search query returns an unexpected place, make the query more specific.

If Yandex Maps shows a cookie banner, the actor handles the common banner automatically.

If Yandex Maps throttles requests, enable Apify Proxy and lower limits.

### Data quality

The actor extracts public data visible on Yandex Maps pages.

Some fields can be missing when Yandex does not render them for a given review.

The dataset schema keeps optional values as `null` instead of inventing values.

### Pricing

This Actor uses Apify pay-per-event pricing. The prices below come from the current Actor pricing configuration. Apify public plans map to Store discount tiers, so the table shows both the user-facing plan context and the pricing tier name. The final price shown in Apify depends on the user account plan and any custom agreement.

| Event | What is charged | Price |
| --- | --- | ---: |
| `start` | One-time fee charged when a run starts. Covers fixed startup cost (init, proxy warmup, first HTTP setup). | $0.005 |

| Event | What is charged | Free / no discount | Starter / Bronze | Scale / Silver | Business / Gold | Custom / Platinum | Custom / Diamond |
| --- | --- | ---: | ---: | ---: | ---: | ---: | ---: |
| `item` | Charged per item extracted. | $0.54581 / 1,000 | $0.47461 / 1,000 | $0.3702 / 1,000 | $0.28477 / 1,000 | $0.18985 / 1,000 | $0.13289 / 1,000 |

Apify may also charge platform usage for compute, storage, proxies, or data transfer outside this Actor pricing. Check the Actor run and the Apify Pricing tab for the exact cost shown to your account.

### Legality

Only scrape public data that you are allowed to process.

Respect Yandex Maps terms, applicable privacy laws, and your internal compliance requirements.

### Privacy and compliance

Only scrape data you are allowed to process.

Respect Yandex Maps terms and applicable privacy laws.

Do not use the actor to collect private account-only data.

### FAQ

#### Does this require a Yandex account?

No. The first version targets public organization review pages visible without login.

#### Can it scrape every review?

It scrolls the rendered review list up to your configured limit.

Availability depends on what Yandex Maps renders during the session.

#### Can it scrape owner replies?

Yes. Visible official responses are expanded and saved when present.

#### Can I use it for many locations?

Yes. Provide multiple start URLs or search queries, then choose safe limits and proxy settings.

#### Does it scrape photos?

No. This actor focuses on review rows, ratings, likes, and owner replies.

### Support

Report bugs, wrong output, blocked runs, or missing fields from the Actor page. Include the Apify run ID or run URL, your input JSON, what you expected, what the Actor returned, and one reproducible public URL so the issue can be tested quickly.

# Actor input Schema

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

Paste one or more public Yandex Maps organization URLs. Regular org URLs are automatically converted to their Reviews tab.

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

Optional Yandex Maps search terms. The actor resolves the first matching places and then scrapes their reviews.

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

Maximum number of review rows to save for each organization.

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

When using search queries, scrape this many places from each query.

## `sort` (type: `string`):

Best effort. Yandex may keep its default relevance ranking depending on UI availability.

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

Browser locale and HTTP language preference used for Yandex Maps pages.

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

Apify proxy configuration. Residential proxy is recommended for larger runs if Yandex starts challenging requests.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://yandex.com/maps/org/surf_coffee/238919133832/reviews/"
    }
  ],
  "searchQueries": [
    "coffee in Moscow"
  ],
  "maxReviewsPerPlace": 20,
  "maxPlacesPerQuery": 1,
  "sort": "relevance",
  "language": "en-US,en;q=0.9",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `overview` (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 = {
    "startUrls": [
        {
            "url": "https://yandex.com/maps/org/surf_coffee/238919133832/reviews/"
        }
    ],
    "searchQueries": [
        "coffee in Moscow"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("fetch_cat/yandex-maps-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 = {
    "startUrls": [{ "url": "https://yandex.com/maps/org/surf_coffee/238919133832/reviews/" }],
    "searchQueries": ["coffee in Moscow"],
}

# Run the Actor and wait for it to finish
run = client.actor("fetch_cat/yandex-maps-reviews-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "startUrls": [
    {
      "url": "https://yandex.com/maps/org/surf_coffee/238919133832/reviews/"
    }
  ],
  "searchQueries": [
    "coffee in Moscow"
  ]
}' |
apify call fetch_cat/yandex-maps-reviews-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=fetch_cat/yandex-maps-reviews-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Yandex Maps Reviews Scraper",
        "description": "Extract public Yandex Maps organization reviews, ratings, reviewer names, dates, likes, and owner replies for reputation monitoring.",
        "version": "0.1",
        "x-build-id": "AwOGEg9VhWfNt1U0C"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/fetch_cat~yandex-maps-reviews-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-fetch_cat-yandex-maps-reviews-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/fetch_cat~yandex-maps-reviews-scraper/runs": {
            "post": {
                "operationId": "runs-sync-fetch_cat-yandex-maps-reviews-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/fetch_cat~yandex-maps-reviews-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-fetch_cat-yandex-maps-reviews-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "startUrls": {
                        "title": "Yandex Maps organization/reviews URLs",
                        "type": "array",
                        "description": "Paste one or more public Yandex Maps organization URLs. Regular org URLs are automatically converted to their Reviews tab.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "searchQueries": {
                        "title": "Search queries",
                        "type": "array",
                        "description": "Optional Yandex Maps search terms. The actor resolves the first matching places and then scrapes their reviews.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxReviewsPerPlace": {
                        "title": "Maximum reviews per place",
                        "minimum": 1,
                        "maximum": 300,
                        "type": "integer",
                        "description": "Maximum number of review rows to save for each organization.",
                        "default": 20
                    },
                    "maxPlacesPerQuery": {
                        "title": "Maximum places per search query",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "When using search queries, scrape this many places from each query.",
                        "default": 1
                    },
                    "sort": {
                        "title": "Review sort order",
                        "enum": [
                            "relevance",
                            "date"
                        ],
                        "type": "string",
                        "description": "Best effort. Yandex may keep its default relevance ranking depending on UI availability.",
                        "default": "relevance"
                    },
                    "language": {
                        "title": "Accept-Language header",
                        "type": "string",
                        "description": "Browser locale and HTTP language preference used for Yandex Maps pages.",
                        "default": "en-US,en;q=0.9"
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Apify proxy configuration. Residential proxy is recommended for larger runs if Yandex starts challenging requests.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
