# Yandex Maps Review Monitor: Парсер отзывов Яндекс Карт (`getascraper/yandex-maps-review-monitor`) Actor

Track new reviews and rating changes on any Yandex Maps business listing. Schedule runs to get only what changed since last time, not a full re-scrape. Reviews, ratings, owner replies as JSON.

- **URL**: https://apify.com/getascraper/yandex-maps-review-monitor.md
- **Developed by:** [GetAScraper](https://apify.com/getascraper) (community)
- **Categories:** Travel, SEO tools, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.97 / 1,000 reviews

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 Review Monitor: Парсер отзывов Яндекс Карт

<table width="100%">
<tr>
<td style="padding:24px 28px;background:#FDECEA;border:1px solid #F6C7C0;border-top:4px solid #E8341A;border-radius:12px">
<span style="font-size:23px;font-weight:800;color:#1C1917;line-height:1.3">Know the moment a new review lands on Yandex Maps, not weeks later.</span><br>
<span style="font-size:15px;color:#57534E;line-height:1.6">This Actor watches a Yandex Maps (Яндекс Карты) business listing and hands back only what's new since your last check: fresh reviews, star ratings, and owner replies. No re-scraping the same reviews twice.</span>
</td>
</tr>
</table>

<table width="100%">
<tr>
<td style="padding:14px 12px;width:25%;background:#FFFFFF;border:1px solid #F6C7C0;border-radius:10px 0 0 10px;vertical-align:top">
<span style="font-size:15px;font-weight:800;color:#B32A15">🆕 New reviews only</span><br>
<span style="font-size:12px;color:#57534E">Skips anything already delivered in a prior run</span>
</td>
<td style="padding:14px 12px;width:25%;background:#FFFFFF;border:1px solid #F6C7C0;border-left:none;vertical-align:top">
<span style="font-size:15px;font-weight:800;color:#B32A15">⭐ Star rating filter</span><br>
<span style="font-size:12px;color:#57534E">Watch just the 1 to 2 star reviews if that's all you need</span>
</td>
<td style="padding:14px 12px;width:25%;background:#FFFFFF;border:1px solid #F6C7C0;border-left:none;vertical-align:top">
<span style="font-size:15px;font-weight:800;color:#B32A15">🏢 Business details</span><br>
<span style="font-size:12px;color:#57534E">Name, address, and total rating count with every row</span>
</td>
<td style="padding:14px 12px;width:25%;background:#FFFFFF;border:1px solid #F6C7C0;border-left:none;border-radius:0 10px 10px 0;vertical-align:top">
<span style="font-size:15px;font-weight:800;color:#B32A15">🇷🇺 RU + EN ready</span><br>
<span style="font-size:12px;color:#57534E">Review text stays original, business details in your language</span>
</td>
</tr>
</table>

Checking Yandex Maps by hand means opening the same listings over and over, hoping you catch a new review before a customer walks away unanswered. This Actor does the checking for you. Point it at any business ID or URL, schedule it daily or weekly, and receive fresh reviews, ratings, and owner replies as clean rows ready for a dashboard, spreadsheet, or alert.

### 🔍 What does Yandex Maps Review Monitor do?

Most Yandex Maps scrapers pull the entire review list every time you run them, so you pay again and again for reviews you already have. This Actor remembers what it already saw for each business and returns only what changed: brand-new reviews and any rating shifts since the previous run.

Give it a business ID or a Yandex Maps URL. It opens the reviews page, scrolls to load as many reviews as you ask for, and extracts the reviewer, star rating, date, review text, and business reply. On the next scheduled run, it compares against its own memory of that business and skips anything already delivered.

<table width="100%"><tr>
<td style="padding:12px 18px;background:#F5F3FF;border-left:4px solid #7B1FA2">
<span style="font-size:15px;color:#1C1917">&#9889; <b>Built for ongoing monitoring, not one-off pulls.</b> Set a daily or weekly schedule and let it run unattended. You only see what's actually new.</span>
</td>
</tr></table>

### 💡 Why use Yandex Maps Review Monitor?

"I run a reputation-management agency covering Russian and CIS clients. I check ten business listings every morning for new reviews so I can respond fast. This Actor replaced that manual routine with a scheduled run and an alert."

"I manage a chain of coffee shops across Moscow. I want to know the moment a customer leaves a bad review, not find out three weeks later when I happen to check. This Actor tells me what's new since yesterday."

"I do competitive intelligence for a hospitality brand. I track review velocity and sentiment for five competitor locations without re-downloading their entire review history every week."

"I built an automation that runs this Actor daily and posts new reviews straight to a Slack channel. My team responds to reviews the same day they're posted."

### 🚀 How to use Yandex Maps Review Monitor

<table width="100%">
<tr>
<td style="padding:16px 14px;width:33%;background:#FDECEA;border:1px solid #F6C7C0;border-radius:10px 0 0 10px;vertical-align:top">
<span style="font-size:12px;font-weight:800;color:#E8341A;letter-spacing:1px">STEP 1</span><br>
<span style="font-size:14px;font-weight:700;color:#1C1917">Add a business ID or URL</span><br>
<span style="font-size:12px;color:#57534E">One or more listings, and leave "only new reviews" on.</span>
</td>
<td style="padding:16px 14px;width:33%;background:#FDECEA;border:1px solid #F6C7C0;border-left:none;vertical-align:top">
<span style="font-size:12px;font-weight:800;color:#E8341A;letter-spacing:1px">STEP 2</span><br>
<span style="font-size:14px;font-weight:700;color:#1C1917">Schedule it</span><br>
<span style="font-size:12px;color:#57534E">Daily or weekly, in the Apify Console Schedules tab.</span>
</td>
<td style="padding:16px 14px;width:33%;background:#FDECEA;border:1px solid #F6C7C0;border-left:none;border-radius:0 10px 10px 0;vertical-align:top">
<span style="font-size:12px;font-weight:800;color:#E8341A;letter-spacing:1px">STEP 3</span><br>
<span style="font-size:14px;font-weight:700;color:#1C1917">Get only what's new</span><br>
<span style="font-size:12px;color:#57534E">To Slack, Google Sheets, a webhook, CSV, or JSON.</span>
</td>
</tr>
</table>

### ⚙️ Input

At least one business ID or URL is required.

| Field | Type | Required | Description |
|---|---|---|---|
| `businessIds` | array of strings | No | Yandex Maps business IDs to monitor. Find the number in the URL: `/maps/org/<slug>/<id>/`. |
| `startUrls` | array of URLs | No | Yandex Maps business page URLs. The business ID is extracted automatically. |
| `onlyNewReviews` | boolean | No | When on (default), only reviews not seen in a prior run are returned. |
| `minRating` | integer | No | Only include reviews at or above this star rating. 0 means no filter. |
| `maxRating` | integer | No | Only include reviews at or below this star rating. 0 means no filter. |
| `reviewSort` | enum | No | Review order requested from Yandex Maps: relevance, newest, highest, or lowest. |
| `maxReviewsPerPlace` | integer | No | Maximum reviews scanned per business per run. 0 means unlimited. |
| `includeReviewerData` | boolean | No | When off, reviewer name, profile link, and avatar are left out for privacy-conscious use cases. |
| `language` | enum | No | Language for business details (default: Russian). Review text stays in its original language. |
| `proxyConfiguration` | object | No | Proxy settings. Russian residential is the default and recommended setting. |

### 📦 Output

Each row is one review, tied to its business. Download as JSON, CSV, Excel, or HTML.

```json
[
  {
    "businessId": "122754033471",
    "businessTitle": "Sip Coffee",
    "businessUrl": "https://yandex.com/maps/org/122754033471/reviews/",
    "businessAddress": "Moscow, Gazetny Lane, 3",
    "businessRatingsCount": 448,
    "totalReviewCount": 448,
    "reviewId": "d72eea53bfe94815bdb0e445",
    "rating": 5,
    "text": "Nice atmosphere, no waiting time, nice interior.",
    "date": "2024-07-12T14:19:07.003Z",
    "reviewerName": "abdulla al naqbi",
    "reviewerProfileUrl": "https://yandex.com/maps/user/84hna92ancv4k950227g7fqavg",
    "reviewerAvatarUrl": "https://avatars.mds.yandex.net/get-yapic/59871/0f-4/islands-68",
    "reviewerLevel": "Level 3 Local Expert",
    "isNewSinceLastRun": true,
    "scrapedAt": "2026-07-06T00:38:44.251Z"
  }
]
````

### 📊 Data table

| Field | Type | Description |
|---|---|---|
| `businessId` | string | Yandex Maps business ID. |
| `businessTitle` | string | Business name. |
| `businessUrl` | string | Link to the business's reviews page. |
| `businessAddress` | string | Business address as shown on Yandex Maps. |
| `businessRatingsCount` | number | Total ratings count for the business. |
| `totalReviewCount` | number | Total review count for the business. |
| `reviewId` | string | Stable identifier for the review, generated by the Actor since Yandex Maps does not expose one directly. |
| `rating` | number | Star rating for the review, 1 to 5. |
| `text` | string | Review text. |
| `date` | string | ISO timestamp of when the review was posted. |
| `reviewerName` | string | Reviewer's display name. Left out when `includeReviewerData` is off. |
| `reviewerProfileUrl` | string | Link to the reviewer's Yandex Maps profile. |
| `reviewerAvatarUrl` | string | Reviewer's avatar image URL. |
| `reviewerLevel` | string | Reviewer's Yandex Maps level, such as "Level 3 Local Expert." |
| `ownerReplyText` | string | The business owner's reply to the review, when present. |
| `isNewSinceLastRun` | boolean | True when `onlyNewReviews` is on and this review was not seen in a prior run. |
| `scrapedAt` | string | ISO timestamp of when the Actor collected this row. |

### 💰 Pricing

Pricing is pay per result. You only pay for the reviews the Actor actually returns, so an empty run costs nothing. There are no monthly subscriptions and no minimum spend. Because the Actor only delivers what changed since your last run, a daily monitoring schedule stays cheap once the initial history has been collected.

### ⭐ Enjoying Yandex Maps Review Monitor?

<table width="100%">
<tr>
<td style="padding:20px 24px 14px;background:#FDECEA;border:1px solid #F6C7C0;border-left:5px solid #E8341A;border-radius:10px 10px 0 0">
<span style="font-size:20px;letter-spacing:4px">⭐ ⭐ ⭐ ⭐ ⭐</span><br>
<span style="font-size:17px;font-weight:800;color:#1C1917">If this Actor caught a review you'd have missed, leave a quick rating.</span><br>
<span style="font-size:14px;color:#57534E">A 5-star rating takes 10 seconds and helps other reputation managers, multi-location owners, and competitive intel teams find it. Your feedback also tells us what to build next.</span>
</td>
</tr>
<tr>
<td style="padding:0;background:#E8341A;border:1px solid #F6C7C0;border-top:none;border-radius:0 0 10px 10px;text-align:center">
<a href="https://apify.com/getascraper/yandex-maps-review-monitor/reviews" style="display:block;padding:13px 16px;color:#FFFFFF;text-decoration:none;font-weight:800;font-size:15px;letter-spacing:0.3px">★&nbsp;&nbsp;Rate this Actor on Apify</a>
</td>
</tr>
</table>

### ✨ Tips

- Turn `onlyNewReviews` off for the very first run on a new business if you want its full review history, then leave it on for every scheduled run after that.
- Use `minRating` and `maxRating` together to watch only for reviews in a specific range, such as 1 to 2 stars for urgent response alerts.
- Turn off `includeReviewerData` if you only need the review content and don't want to store reviewer identity information.
- Combine a daily Apify Schedule with the Slack or Google Sheets integration to get new reviews delivered automatically without writing any code.

### ❓ FAQ

##### Как отслеживать новые отзывы на Яндекс Картах?

Add your business ID or Yandex Maps URL to the input, leave "Only new reviews" turned on, and set a daily or weekly schedule in Apify Console. Each run returns only the reviews posted since the last one.

##### Does it get blocked?

The Actor uses Russian residential proxy routing by default, which matches how a real visitor from Russia would browse Yandex Maps. This keeps runs reliable at normal monitoring volumes.

##### How fresh is the data?

Reviews are read directly from the live business page at the moment the Actor runs, so results reflect exactly what's published on Yandex Maps right now.

##### Do I need a Yandex account or login?

No. The Actor reads only public business and review data. No login or cookies are required.

##### What happens on the very first run for a new business?

Since there's no prior history yet, the first run with `onlyNewReviews` on returns every review currently visible, up to `maxReviewsPerPlace`. Every run after that returns only new ones.

##### Found a problem or need another field?

Open a ticket on the Issues tab of this Actor. Custom solutions and additional fields are available on request.

# Actor input Schema

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

Yandex Maps organization IDs to monitor. Find the number in the org page URL: /maps/org/<slug>/<id>/.

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

Yandex Maps business page URLs. The organization ID is extracted automatically.

## `onlyNewReviews` (type: `boolean`):

When on, only reviews not seen in a prior run are returned. Turn off to pull the full review list every run.

## `minRating` (type: `integer`):

Only include reviews with this star rating or higher. 0 = no filter.

## `maxRating` (type: `integer`):

Only include reviews with this star rating or lower. 0 = no filter.

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

Sort order requested from Yandex Maps for the review list.

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

Maximum reviews to scan per business per run. 0 = unlimited (scans until no more load).

## `includeReviewerData` (type: `boolean`):

When off, reviewer name, profile URL, and avatar are omitted from the output for privacy-conscious use cases.

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

Language for business details. Review text is always in its original language.

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

Datacenter proxy (the default) works reliably and is far cheaper. Switch to Residential only if a very large run starts hitting rate limits.

## Actor input object example

```json
{
  "onlyNewReviews": true,
  "minRating": 0,
  "maxRating": 0,
  "reviewSort": "newest",
  "maxReviewsPerPlace": 0,
  "includeReviewerData": true,
  "language": "ru",
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

No description

## `keyValueStore` (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 = {
    "onlyNewReviews": true,
    "minRating": 0,
    "maxRating": 0,
    "reviewSort": "newest",
    "maxReviewsPerPlace": 0,
    "includeReviewerData": true,
    "language": "ru",
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("getascraper/yandex-maps-review-monitor").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 = {
    "onlyNewReviews": True,
    "minRating": 0,
    "maxRating": 0,
    "reviewSort": "newest",
    "maxReviewsPerPlace": 0,
    "includeReviewerData": True,
    "language": "ru",
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("getascraper/yandex-maps-review-monitor").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 '{
  "onlyNewReviews": true,
  "minRating": 0,
  "maxRating": 0,
  "reviewSort": "newest",
  "maxReviewsPerPlace": 0,
  "includeReviewerData": true,
  "language": "ru",
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call getascraper/yandex-maps-review-monitor --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Yandex Maps Review Monitor: Парсер отзывов Яндекс Карт",
        "description": "Track new reviews and rating changes on any Yandex Maps business listing. Schedule runs to get only what changed since last time, not a full re-scrape. Reviews, ratings, owner replies as JSON.",
        "version": "0.1",
        "x-build-id": "EngHM15kiod6D4zFj"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/getascraper~yandex-maps-review-monitor/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-getascraper-yandex-maps-review-monitor",
                "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/getascraper~yandex-maps-review-monitor/runs": {
            "post": {
                "operationId": "runs-sync-getascraper-yandex-maps-review-monitor",
                "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/getascraper~yandex-maps-review-monitor/run-sync": {
            "post": {
                "operationId": "run-sync-getascraper-yandex-maps-review-monitor",
                "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": {
                    "businessIds": {
                        "title": "Business IDs",
                        "type": "array",
                        "description": "Yandex Maps organization IDs to monitor. Find the number in the org page URL: /maps/org/<slug>/<id>/.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "Yandex Maps business page URLs. The organization ID is extracted automatically.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "onlyNewReviews": {
                        "title": "Only new reviews",
                        "type": "boolean",
                        "description": "When on, only reviews not seen in a prior run are returned. Turn off to pull the full review list every run.",
                        "default": true
                    },
                    "minRating": {
                        "title": "Minimum rating",
                        "minimum": 0,
                        "maximum": 5,
                        "type": "integer",
                        "description": "Only include reviews with this star rating or higher. 0 = no filter.",
                        "default": 0
                    },
                    "maxRating": {
                        "title": "Maximum rating",
                        "minimum": 0,
                        "maximum": 5,
                        "type": "integer",
                        "description": "Only include reviews with this star rating or lower. 0 = no filter.",
                        "default": 0
                    },
                    "reviewSort": {
                        "title": "Review sort order",
                        "enum": [
                            "relevance",
                            "newest",
                            "highest",
                            "lowest"
                        ],
                        "type": "string",
                        "description": "Sort order requested from Yandex Maps for the review list.",
                        "default": "newest"
                    },
                    "maxReviewsPerPlace": {
                        "title": "Max reviews per business",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum reviews to scan per business per run. 0 = unlimited (scans until no more load).",
                        "default": 0
                    },
                    "includeReviewerData": {
                        "title": "Include reviewer profile data",
                        "type": "boolean",
                        "description": "When off, reviewer name, profile URL, and avatar are omitted from the output for privacy-conscious use cases.",
                        "default": true
                    },
                    "language": {
                        "title": "Language",
                        "enum": [
                            "ru",
                            "en",
                            "tr",
                            "uk",
                            "kk"
                        ],
                        "type": "string",
                        "description": "Language for business details. Review text is always in its original language.",
                        "default": "ru"
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Datacenter proxy (the default) works reliably and is far cheaper. Switch to Residential only if a very large run starts hitting rate limits.",
                        "default": {
                            "useApifyProxy": true
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
