# 2GIS Reviews Scraper (`scrapesmith/2gis-reviews-scraper`) Actor

Scrape reviews from any 2GIS business. Get review text, ratings, author profiles, photos, official replies, dates, and 49 structured fields per review. Covers 200+ cities across Russia, Kazakhstan, and UAE. No proxy needed. JSON/CSV/Excel. API, MCP, webhook, AI-agent ready.

- **URL**: https://apify.com/scrapesmith/2gis-reviews-scraper.md
- **Developed by:** [Scrape Smith](https://apify.com/scrapesmith) (community)
- **Categories:** Developer tools, Social media, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.30 / 1,000 results

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

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

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

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

## 🗺️ 2GIS Reviews Scraper

Scrape customer reviews from any business on 2GIS — Russia's largest maps and business directory. Get review text, star ratings, author profiles, photos, official business replies, and 49 structured fields per review across 200+ cities.

No login required. No proxy needed. No API keys from your side. Just paste a 2GIS business URL and run.

### 🔍 What does 2GIS Reviews Scraper do?

2GIS is the go-to maps and business directory platform across Russia, Kazakhstan, UAE, and Central Asia — think Google Maps but for Russian-speaking markets. Every restaurant, shop, clinic, hotel, and service provider listed on 2GIS has customer reviews.

This scraper collects all those reviews for any business you specify and returns clean, structured data ready for spreadsheets, databases, or analytics pipelines.

**Use it to:**

- 📢 **Monitor your brand reputation** — track what customers say about your business across every 2GIS location, get alerts on new negative reviews
- 🔎 **Benchmark against competitors** — compare review scores, response rates, and common complaints side by side
- 📊 **Analyze customer sentiment** — feed review text into NLP pipelines for topic extraction, sentiment scoring, and trend detection
- 🏪 **Research local markets** — understand customer expectations in specific Russian cities before opening new locations
- 💬 **Audit response quality** — measure how fast and how well businesses respond to customer feedback
- 🏢 **Multi-location monitoring** — scrape reviews for all your franchise, chain, or branch locations in a single run
- 🧠 **Train AI models** — use structured review data for fine-tuning language models, building recommendation systems, or creating review classifiers
- 📈 **Track trends over time** — schedule daily or weekly runs to monitor how review volume and sentiment change

### ⚡ Why use this scraper?

- 💰 **80x cheaper than the cheapest competitor** — under $0.01 per 1,000 reviews vs $0.50/1k for the market leader
- 📋 **49 fields per review** — matches every competitor field: ratings, text, author, photos, official replies, moderation status, trust signals
- 🚀 **3,000+ reviews per minute** — all businesses scraped in parallel, not one at a time
- 🌍 **All 2GIS sources** — captures native 2GIS reviews, Flamp cross-posts, and Booking.com cross-posts automatically
- 🔌 **Zero proxy cost** — direct API access, no residential or datacenter proxy needed
- ✅ **Zero setup** — no cookies, no API keys, no credentials
- 🔁 **Per-place limits** — cap reviews per business so you get balanced coverage across locations

### 💰 How much does it cost?

Pay-per-result pricing. You only pay for the reviews you receive — empty runs cost nothing.

| Volume | Approximate cost |
|--------|-----------------|
| 25 reviews | 🆓 **Free** (every run) |
| 1,000 reviews | ~$0.006 |
| 10,000 reviews | ~$0.06 |
| 100,000 reviews | ~$0.60 |

No proxy fees. No hidden charges. The scraper uses direct API access — cost is pure platform compute.

**Competitor pricing for comparison:**
| Competitor | Price per 1,000 |
|-----------|----------------|
| zen-studio | $0.50 – $1.00 |
| getascraper | $0.66 |
| piotrv1001 | $1.80 |
| m_mamaev | $2.00 |
| **This scraper** | **$0.006** |

### 📥 Input

The scraper accepts 2GIS business URLs or numeric branch IDs in any format — mix both freely:

- Full URL: `https://2gis.ru/moscow/firm/70000001088748920/tab/reviews`
- Short URL: `https://2gis.ru/moscow/firm/70000001088748920`
- Bare ID: `70000001088748920`

#### Input parameters

| Parameter | Type | Required | Description |
|-----------|------|----------|-------------|
| **urls** | Array of strings | Yes | 2GIS business URLs or numeric branch IDs |
| resultsPerPlace | Integer | No | Maximum reviews per individual business. Leave empty for all. |
| maxItems | Integer | No | Maximum total reviews across all places. Leave empty for no limit. |

#### Example input — multiple locations

```json
{
    "urls": [
        "https://2gis.ru/moscow/firm/70000001088748920",
        "4504127908652933",
        "4504127908349335"
    ],
    "resultsPerPlace": 100
}
````

#### Example input — single location, all reviews

```json
{
    "urls": ["70000001088748920"]
}
```

#### Example input — balanced multi-location monitoring

```json
{
    "urls": [
        "70000001088748920",
        "4504127908652933",
        "4504127908349335",
        "4504127908658015"
    ],
    "resultsPerPlace": 50,
    "maxItems": 500
}
```

### 📤 Output

Each review is a flat JSON object with 49 fields — no nested blobs to parse. Ready for spreadsheets, databases, and downstream pipelines.

<details>
<summary><strong>Click to see all 49 output fields</strong></summary>

| Field | Type | Description |
|-------|------|-------------|
| reviewId | String | Unique review ID |
| text | String | Full review text |
| rating | Integer | Star rating (1-5) |
| dateCreated | String | Review creation date (ISO 8601) |
| dateEdited | String | Last edit date |
| provider | String | Source (2gis, flamp, booking) |
| source | String | Source metadata |
| providerData | String | Provider-specific data |
| externalId | String | External review ID |
| isRated | Boolean | Has star rating |
| isHidden | Boolean | Hidden by moderation |
| isUnratedPermanently | Boolean | Permanently unrated |
| hidingReason | String | Hiding reason |
| hidingType | String | Hiding type |
| likesCount | Integer | Likes |
| commentsCount | Integer | Replies/comments |
| authorUserId | String | Author's user ID |
| authorPublicId | String | Author's public UUID |
| authorName | String | Display name |
| authorFirstName | String | First name |
| authorLastName | String | Last name |
| authorProvider | String | Identity provider |
| authorReviewsCount | Integer | Total reviews by author |
| authorUrl | String | Profile URL |
| authorPhotoUrl | String | Avatar (original) |
| authorPhotoUrls | Object | Avatar in 5 sizes |
| photos | Array | Review photo URLs |
| photoCount | Integer | Photo count |
| hasOfficialAnswer | Boolean | Business replied |
| officialAnswerText | String | Reply text |
| officialAnswerDate | String | Reply date |
| reactions | String | Emoji reactions |
| reviewTopics | Array | Auto-detected topics |
| trustFactors | String | Trust signals |
| filteredFacts | String | Moderation facts |
| statusHistory | Array | Status changes |
| branchId | String | Business branch ID |
| objectType | String | Object type |
| regionId | Integer | Region ID |
| pinStatus | String | Pin status |
| hasUnresolvedComplaints | Boolean | Unresolved complaints |
| reviewUrl | String | Direct review URL |
| placeName | String | Business name |
| placeAddress | String | Street address |
| placeCity | String | City |
| placeRating | Float | Average rating |
| placeReviewCount | Integer | Total review count |
| placeCategories | Array | Category tags |
| scrapedAt | String | Scrape timestamp |

</details>

#### Example output

```json
{
    "reviewId": "255246182",
    "text": "Отличное место! Кофе вкусный, обслуживание быстрое.",
    "rating": 5,
    "dateCreated": "2026-07-03T18:57:38.000Z",
    "provider": "2gis",
    "likesCount": 3,
    "commentsCount": 1,
    "authorName": "Иван Петров",
    "authorReviewsCount": 62,
    "authorPhotoUrl": "https://i1.photo.2gis.com/images/profile/...",
    "hasOfficialAnswer": true,
    "officialAnswerText": "Спасибо за отзыв! Рады, что вам понравилось.",
    "branchId": "70000001088748920",
    "placeName": "Stars Coffee",
    "placeCity": "Москва",
    "placeRating": 4.5,
    "scrapedAt": "2026-07-23T12:00:00.000Z"
}
```

### 🏎️ Performance

| Metric | Value |
|--------|-------|
| Speed | 3,000+ reviews/minute |
| Concurrent places | Up to 10 simultaneously |
| Memory | 50–80 MB |
| Cost per 1,000 | ~$0.006 |
| Proxy needed | No |
| Output formats | JSON, CSV, Excel, XML, RSS |

### 🌍 Supported regions

Works across the entire 2GIS network:

- **Russia** — Moscow, St. Petersburg, Novosibirsk, Yekaterinburg, Kazan, and 200+ cities
- **Kazakhstan** — Almaty, Astana, Karaganda, Shymkent
- **UAE** — Dubai, Abu Dhabi, Sharjah
- **Uzbekistan** — Tashkent, Samarkand
- **Kyrgyzstan, Belarus, and more** — all 2GIS-covered territories

Reviews from all sources are captured: native 2GIS reviews, Flamp cross-posts, and Booking.com cross-posts. Each review includes a `provider` field so you can filter by source.

### 💡 Tips and advanced usage

#### Monitor reviews on a schedule

Set up daily or weekly runs with the [Apify scheduling feature](https://docs.apify.com/platform/schedules). Track new reviews, catch negative feedback early, and measure how review volume changes over time.

#### Get balanced coverage across locations

Use `resultsPerPlace` to cap reviews per business. This ensures you get recent reviews from ALL locations, not 5,000 from one popular spot and none from the rest:

```json
{
    "urls": ["branch1", "branch2", "branch3", "branch4"],
    "resultsPerPlace": 50
}
```

#### Find a business's branch ID

The branch ID is the long numeric identifier in any 2GIS URL:

- `https://2gis.ru/moscow/firm/70000001088748920` → `70000001088748920`

You can also search for a business on 2gis.ru, open its page, and copy the URL — the scraper extracts the ID automatically.

#### Export to Google Sheets automatically

Connect to Google Sheets via the [Apify integration](https://docs.apify.com/platform/integrations/google-sheets). New reviews are appended to your spreadsheet after every run — perfect for dashboards and reporting.

#### Use with Make, Zapier, or n8n

Trigger downstream workflows whenever new reviews appear. Set up a webhook to alert your team on negative reviews, update a CRM, or feed a sentiment analysis pipeline. Connect via [webhooks](https://docs.apify.com/platform/integrations/webhooks) or the [Apify integrations page](https://docs.apify.com/platform/integrations).

#### Call from your code

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_API_TOKEN")
run = client.actor("scrapesmith/2gis-reviews-scraper").call(
    run_input={
        "urls": ["70000001088748920", "4504127908652933"],
        "resultsPerPlace": 100
    }
)
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(f"{item['authorName']} ({'⭐' * item['rating']}): {item['text'][:60]}")
```

#### Connect to AI agents via MCP

Available as an MCP tool for Claude, ChatGPT, and other AI agents. Feed real-time 2GIS review data into your AI workflows for sentiment analysis, market research, competitive intelligence, or automated reputation monitoring.

### ❓ Frequently asked questions

#### Does it work for all 2GIS cities?

Yes. Every city covered by 2GIS is supported — Russia (200+ cities), Kazakhstan, UAE, Uzbekistan, Kyrgyzstan, Belarus, and all other territories in the 2GIS network.

#### What review sources are included?

2GIS aggregates reviews from three sources: native 2GIS reviews, Flamp cross-posts, and Booking.com cross-posts. This scraper captures all of them. Each review has a `provider` field so you can filter by source.

#### Can I get the business's overall rating?

Yes. Each review includes `placeRating` (the business's average score) and `placeReviewCount` (total review count for that location).

#### Is there a limit on how many reviews I can scrape?

No artificial limit on paid plans. The scraper paginates through all available reviews. Popular restaurants may have thousands of reviews — use `resultsPerPlace` to cap output per location if needed.

#### How fresh is the data?

Every run fetches live data directly from 2GIS. No caching — you always get the current state of reviews at the time of the run.

#### Do I need a 2GIS account or API key?

No. The scraper handles all access internally. You never need to provide credentials, cookies, or API keys.

#### Can I filter reviews by rating or date?

The scraper returns all reviews sorted by newest first. You can filter the output by rating, date range, or any other field using Apify's dataset filtering or in your own code after export.

#### What's the difference between this and the 2GIS Places Scraper?

This scraper focuses on **reviews** — the full text, ratings, author details, and business replies for specific locations. The Places Scraper extracts **business listings** — names, addresses, phone numbers, and categories from search results. Use this scraper when you need the actual customer feedback.

#### Can I monitor multiple locations at once?

Yes. Pass multiple URLs or branch IDs and they all scrape in parallel. Use `resultsPerPlace` for balanced coverage across locations. Schedule the scraper to run daily for continuous monitoring.

### 🔗 Related scrapers

Looking for other review and business data scrapers? Check out our collection:

- [Google Maps Reviews Scraper](https://apify.com/scrapesmith/Google-Maps-Reviews-Scraper) — Scrape reviews from Google Maps businesses
- [TripAdvisor Reviews Scraper](https://apify.com/scrapesmith/tripadvisor-reviews-scraper) — Extract hotel and restaurant reviews from TripAdvisor
- [Booking Reviews Scraper](https://apify.com/scrapesmith/booking-com-hotel-reviews-scraper) — Scrape Booking.com hotel reviews
- [Google Play Reviews](https://apify.com/scrapesmith/google-play-store-reviews-scraper) — Extract app reviews from Google Play Store
- [Apple App Store Reviews](https://apify.com/scrapesmith/apple-app-store-reviews-scraper) — Scrape iOS app reviews

#### Other Russian market scrapers

- [Avito Scraper](https://apify.com/scrapesmith/avito-scraper) — Extract classified listings from Avito.ru
- [Yandex Maps Reviews Scraper](https://apify.com/scrapesmith/yandex-maps-reviews-scraper) — Scrape reviews from Yandex Maps

# Actor input Schema

## `urls` (type: `array`):

2GIS place page URLs or numeric branch IDs. Example: https://2gis.ru/moscow/firm/70000001088748920 or just 70000001088748920

## `resultsPerPlace` (type: `integer`):

Maximum reviews per individual business. Leave empty to scrape all available reviews for each place.

## Actor input object example

```json
{
  "urls": [
    "https://2gis.ru/moscow/firm/70000001088748920"
  ]
}
```

# 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 = {
    "urls": [
        "https://2gis.ru/moscow/firm/70000001088748920"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapesmith/2gis-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 = { "urls": ["https://2gis.ru/moscow/firm/70000001088748920"] }

# Run the Actor and wait for it to finish
run = client.actor("scrapesmith/2gis-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 '{
  "urls": [
    "https://2gis.ru/moscow/firm/70000001088748920"
  ]
}' |
apify call scrapesmith/2gis-reviews-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "2GIS Reviews Scraper",
        "description": "Scrape reviews from any 2GIS business. Get review text, ratings, author profiles, photos, official replies, dates, and 49 structured fields per review. Covers 200+ cities across Russia, Kazakhstan, and UAE. No proxy needed. JSON/CSV/Excel. API, MCP, webhook, AI-agent ready.",
        "version": "0.0",
        "x-build-id": "rxhRzBM0iaAcqrdex"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapesmith~2gis-reviews-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapesmith-2gis-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/scrapesmith~2gis-reviews-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapesmith-2gis-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/scrapesmith~2gis-reviews-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapesmith-2gis-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",
                "required": [
                    "urls"
                ],
                "properties": {
                    "urls": {
                        "title": "2GIS Place URLs or Branch IDs",
                        "type": "array",
                        "description": "2GIS place page URLs or numeric branch IDs. Example: https://2gis.ru/moscow/firm/70000001088748920 or just 70000001088748920",
                        "items": {
                            "type": "string"
                        }
                    },
                    "resultsPerPlace": {
                        "title": "Reviews Per Place",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum reviews per individual business. Leave empty to scrape all available reviews for each place."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```