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

Scrape public Yandex Maps reviews with ratings, reviewer profiles, reactions, photos, owner replies, and place context from URLs, IDs, or searches.

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

## Pricing

Pay per event

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are 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

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

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

### What does Yandex Maps Reviews Scraper do?

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

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

Each dataset item is one review enriched with place context.

### Who is it for?

#### Reputation agencies

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

#### Local SEO teams

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

#### Brand monitoring teams

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

#### Data analysts

Build repeatable review datasets for sentiment analysis and BI pipelines.

#### Sales and market researchers

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

### Why use this actor?

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

### What data can you extract?

| Field | Description |
| --- | --- |
| `placeId` | Yandex Maps business ID |
| `placeName` | Place name when discovered from search |
| `placeUrl` | Yandex Maps organization URL |
| `address` | Public address when available |
| `categories` | Place categories |
| `overallRating` | Overall place rating when available |
| `totalReviewCount` | Public count from place metadata when available |
| `reviewId` | Review identifier |
| `reviewerName` | Public reviewer display name |
| `reviewerProfileUrl` | Public Yandex Maps profile URL when available |
| `reviewerAvatarUrl` | Public avatar URL/template |
| `reviewerLevel` | Yandex reviewer level text |
| `rating` | Numeric review rating |
| `reviewText` | Review text |
| `reviewLanguage` | Language marker from Yandex |
| `reviewDate` | Review update/create timestamp |
| `likes` | Public like count |
| `dislikes` | Public dislike count |
| `photos` | Public review photo URLs |
| `ownerReplyText` | Business owner reply text when present |
| `ownerReplyDate` | Owner reply timestamp when present |
| `scrapedAt` | Timestamp of extraction |

### How much does it cost to scrape Yandex Maps reviews?

This actor uses pay-per-event pricing.

You pay a small start fee for each run and a per-review fee for every saved review record.

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

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

### How to scrape Yandex Maps reviews

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

### Input options

#### `startUrls`

Paste Yandex Maps business URLs such as:

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

#### `businessIds`

Use raw IDs when you already have them:

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

#### `searchQueries`

Discover places before collecting reviews:

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

#### `maxItems`

Total review limit across all places.

#### `maxReviewsPerPlace`

Maximum review records for each organization.

#### `maxPlacesPerQuery`

Maximum places to process for each search query.

#### `sort`

Choose newest reviews first or most relevant reviews first.

#### `locale`

`ru_RU` is the default because Yandex often exposes richer review data in that locale.

#### `regionId`

Yandex region context for search queries.

### Output example

```json
{
  "placeId": "1018907821",
  "placeName": null,
  "placeUrl": "https://yandex.com/maps/org/1018907821/",
  "address": null,
  "categories": [],
  "overallRating": null,
  "totalReviewCount": null,
  "reviewId": "example-review-id",
  "reviewerName": "Public reviewer",
  "reviewerProfileUrl": "https://yandex.com/maps/user/example/",
  "reviewerAvatarUrl": "https://avatars.mds.yandex.net/...",
  "reviewerLevel": "City expert",
  "rating": 5,
  "reviewText": "Great place and friendly service.",
  "reviewLanguage": "unknown",
  "reviewDate": "2026-05-28T20:52:45.512Z",
  "likes": 0,
  "dislikes": 0,
  "photos": [],
  "ownerReplyText": null,
  "ownerReplyDate": null,
  "source": "Yandex Maps",
  "scrapedAt": "2026-05-29T00:00:00.000Z"
}
```

### Tips for best results

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

### Integrations

#### Google Sheets

Send the dataset to Google Sheets for review tracking.

#### Slack

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

#### Airtable

Store review records for client-facing reputation workflows.

#### BI tools

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

#### Sentiment analysis

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

### API usage

#### Node.js

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

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

#### Python

```python
from apify_client import ApifyClient

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

#### cURL

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

### MCP usage

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

MCP server URL:

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

Claude Code setup:

```bash
claude mcp add apify-yandex-reviews https://mcp.apify.com/?tools=automation-lab/yandex-maps-reviews-scraper
```

Claude Desktop JSON config:

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

Example prompt:

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

Another prompt:

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

### Scheduling

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

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

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

### Common workflows

#### Competitor review monitoring

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

#### Branch QA

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

#### Agency reporting

Export review records into a monthly reputation report.

#### Owner reply audit

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

### Limitations

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

Some places have few or no public reviews.

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

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

### Troubleshooting

#### Why did I get zero reviews?

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

#### Why is place name missing?

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

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

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

### Data quality notes

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

Timestamps are ISO strings when provided by the source.

Photo arrays are empty when reviews have no public images.

### Legality

This actor extracts publicly available information from Yandex Maps.

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

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

### Related scrapers

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

### FAQ

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

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

#### Can I get only new reviews?

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

#### Does the actor require login?

No. It collects public review data only.

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

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

#### Can I export to CSV?

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

#### Does it scrape private user data?

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

### Changelog

#### 0.1

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

### Support

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

### Version

Actor version: 0.1

### End

Ready for structured Yandex Maps review extraction.

# Actor input Schema

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

Paste Yandex Maps organization/place URLs. The scraper extracts the business ID and downloads public reviews.

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

Optional raw Yandex organization IDs, for example 1018907821.

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

Optional Yandex Maps searches. Use this when you do not have exact place URLs yet.

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

Stop after this many review records across all places.

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

Limit reviews downloaded for each organization.

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

For search queries, scrape reviews from up to this many matching Yandex Maps places.

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

Sort order requested from Yandex Maps.

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

Yandex Maps locale. ru\_RU usually exposes the richest public review data; en\_US works for international output labels.

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

Region context for search queries. 213 is Moscow; 11508 is Istanbul.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://yandex.com/maps/org/1018907821/"
    }
  ],
  "businessIds": [
    "1018907821"
  ],
  "searchQueries": [
    {
      "query": "cafe pushkin",
      "location": "moscow",
      "coordinates": "37.6173,55.7558",
      "span": "0.5,0.5"
    }
  ],
  "maxItems": 20,
  "maxReviewsPerPlace": 20,
  "maxPlacesPerQuery": 3,
  "sort": "by_time",
  "locale": "ru_RU",
  "regionId": 213
}
```

# 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/1018907821/"
        }
    ],
    "businessIds": [
        "1018907821"
    ],
    "searchQueries": [
        {
            "query": "cafe pushkin",
            "location": "moscow",
            "coordinates": "37.6173,55.7558",
            "span": "0.5,0.5"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/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/1018907821/" }],
    "businessIds": ["1018907821"],
    "searchQueries": [{
            "query": "cafe pushkin",
            "location": "moscow",
            "coordinates": "37.6173,55.7558",
            "span": "0.5,0.5",
        }],
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/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/1018907821/"
    }
  ],
  "businessIds": [
    "1018907821"
  ],
  "searchQueries": [
    {
      "query": "cafe pushkin",
      "location": "moscow",
      "coordinates": "37.6173,55.7558",
      "span": "0.5,0.5"
    }
  ]
}' |
apify call automation-lab/yandex-maps-reviews-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Yandex Maps Reviews Scraper",
        "description": "Scrape public Yandex Maps reviews with ratings, reviewer profiles, reactions, photos, owner replies, and place context from URLs, IDs, or searches.",
        "version": "0.1",
        "x-build-id": "oad70zS9Q4XmBD8nA"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~yandex-maps-reviews-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-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/automation-lab~yandex-maps-reviews-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-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/automation-lab~yandex-maps-reviews-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-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 place URLs",
                        "type": "array",
                        "description": "Paste Yandex Maps organization/place URLs. The scraper extracts the business ID and downloads public reviews.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "businessIds": {
                        "title": "Business IDs",
                        "type": "array",
                        "description": "Optional raw Yandex organization IDs, for example 1018907821.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "searchQueries": {
                        "title": "Search queries",
                        "type": "array",
                        "description": "Optional Yandex Maps searches. Use this when you do not have exact place URLs yet."
                    },
                    "maxItems": {
                        "title": "Maximum reviews total",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Stop after this many review records across all places.",
                        "default": 20
                    },
                    "maxReviewsPerPlace": {
                        "title": "Maximum reviews per place",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Limit reviews downloaded for each organization.",
                        "default": 20
                    },
                    "maxPlacesPerQuery": {
                        "title": "Maximum places per search query",
                        "minimum": 1,
                        "maximum": 50,
                        "type": "integer",
                        "description": "For search queries, scrape reviews from up to this many matching Yandex Maps places.",
                        "default": 3
                    },
                    "sort": {
                        "title": "Review sorting",
                        "enum": [
                            "by_time",
                            "by_relevance"
                        ],
                        "type": "string",
                        "description": "Sort order requested from Yandex Maps.",
                        "default": "by_time"
                    },
                    "locale": {
                        "title": "Locale",
                        "type": "string",
                        "description": "Yandex Maps locale. ru_RU usually exposes the richest public review data; en_US works for international output labels.",
                        "default": "ru_RU"
                    },
                    "regionId": {
                        "title": "Yandex region ID",
                        "type": "integer",
                        "description": "Region context for search queries. 213 is Moscow; 11508 is Istanbul.",
                        "default": 213
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```