# Yandex Maps Scraper (`crawlerbros/yandex-maps-scraper`) Actor

Scrape business listings, reviews, and place details from Yandex Maps. Extract name, address, phone, website, rating, reviews, working hours, photos and coordinates. Supports 6 regional domains

- **URL**: https://apify.com/crawlerbros/yandex-maps-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Developer tools, Automation, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 7 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $3.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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 Scraper

Extract business listings, reviews, place details, ratings, phone numbers, websites, working hours, and photos from [Yandex Maps](https://yandex.com/maps/) — Russia and CIS's dominant map platform. Supports 6 regional domains and 8 languages.

### What data can you scrape?

- **Business name, address, city, country**
- **Phone numbers and website URLs**
- **Star rating and total review count**
- **Business categories** (e.g. "Restaurant", "Coffee shop")
- **Working hours** (structured by day)
- **Photos** (up to 20 per business)
- **Coordinates** (latitude and longitude)
- **Customer reviews** — author, star rating, text, date, likes

### Use cases

- **Lead generation** — build lists of local businesses in Russia, Turkey, Kazakhstan, and other CIS countries
- **Market research** — find competitors, analyze ratings, and map business density
- **Price monitoring** — track businesses in Yandex Market categories
- **Brand monitoring** — find all your branded locations and monitor customer reviews
- **Real estate & site selection** — discover nearby amenities, transport links, and service density
- **Academic research** — study business ecosystems in Russian-speaking markets

### Modes

#### `searchPlaces` (default)
Search Yandex Maps for businesses matching a keyword and/or location. Returns a list of place records.

**Example queries:**
- `coffee shops Moscow`
- `sushi restaurant Istanbul`
- `hotel near Red Square`
- `pharmacy Almaty`

#### `getDetails`
Fetch complete details for specific Yandex Maps business URLs. Useful when you already know which businesses to target.

#### `getReviews`
Scrape customer reviews from specific business pages, sorted by date, rating, or relevance.

### Input

| Field | Type | Description |
|-------|------|-------------|
| `mode` | select | `searchPlaces`, `getDetails`, or `getReviews` |
| `searchQueries` | string[] | Search queries (mode=searchPlaces). Combine type + location. |
| `businessUrls` | string[] | Yandex Maps business URLs (mode=getDetails or getReviews) |
| `yandexDomain` | select | Regional domain: `yandex.com`, `yandex.ru`, `yandex.com.tr`, etc. |
| `language` | select | UI language: `en`, `ru`, `tr`, `de`, `fr`, `uk`, `kk`, `uz` |
| `maxItems` | integer | Max records to return (1–500, default 20) |
| `minRating` | select | Minimum rating filter: `any`, `3`, `3.5`, `4`, `4.5` (searchPlaces only) |
| `reviewsSortOrder` | select | Sort reviews: `by_date_desc`, `by_rating_desc`, `by_relevance` (getReviews only) |
| `proxyConfiguration` | proxy | Residential proxies recommended for best results |

### Output

Each record in the dataset has a `recordType` field:

#### Place record (`recordType: "place"`)

```json
{
  "recordType": "place",
  "placeId": "123456789",
  "name": "Шоколадница",
  "url": "https://yandex.com/maps/org/shokoladnitsa/123456789/",
  "address": "Tverskaya St, 15, Moscow, 125009",
  "city": "Moscow",
  "coordinates": { "lat": 55.7644, "lng": 37.6055 },
  "phone": "+7 495 123-45-67",
  "website": "https://shokoladnitsa.ru",
  "rating": 4.5,
  "reviewCount": 2341,
  "categories": ["Coffee shop", "Cafe", "Bakery"],
  "workingHours": {
    "Monday": "08:00–22:00",
    "Tuesday": "08:00–22:00",
    "Saturday": "09:00–23:00",
    "Sunday": "09:00–23:00"
  },
  "photos": [
    "https://avatars.mds.yandex.net/get-altay/...",
    "https://avatars.mds.yandex.net/get-altay/..."
  ],
  "scrapedAt": "2026-05-17T10:00:00+00:00"
}
````

#### Review record (`recordType: "review"`)

```json
{
  "recordType": "review",
  "placeId": "123456789",
  "placeName": "Шоколадница",
  "placeUrl": "https://yandex.com/maps/org/shokoladnitsa/123456789/",
  "reviewId": "abc123",
  "author": "Ivan Petrov",
  "authorUrl": "https://yandex.com/profile/ivan",
  "rating": 5,
  "text": "Great coffee and friendly staff. The croissants are fresh every morning.",
  "date": "2024-01-15",
  "likes": 7,
  "scrapedAt": "2026-05-17T10:00:00+00:00"
}
```

### Supported Yandex Domains

| Domain | Region |
|--------|--------|
| `yandex.com` | International |
| `yandex.ru` | Russia |
| `yandex.com.tr` | Turkey |
| `yandex.kz` | Kazakhstan |
| `yandex.uz` | Uzbekistan |
| `yandex.by` | Belarus |

### Tips for best results

- **Use residential proxies** — Yandex may trigger CAPTCHA on datacenter IPs. The default proxy configuration uses Apify residential proxies.
- **Combine type + location** in your search query for precise results (e.g., `Italian restaurant Saint Petersburg` rather than just `restaurant`).
- **Use the matching domain** for your target country — `yandex.ru` for Russian cities, `yandex.com.tr` for Turkish cities.
- **Set language to `ru`** when searching Russian-language businesses for more complete results.
- **Use `getReviews` mode with `by_date_desc`** to get the most recent customer feedback.

### Frequently Asked Questions

**Can I scrape businesses from any city in Russia?**\
Yes. Yandex Maps covers all major Russian cities and thousands of smaller towns. Specify the city name in your search query, e.g., `restaurants Novosibirsk`.

**Does this work for Turkish businesses?**\
Yes. Use `yandex.com.tr` as the domain and `tr` as the language for best results with Turkish locations.

**How many results can I get per search query?**\
Yandex Maps typically returns up to 200–500 results per search. Set `maxItems` accordingly.

**Can I get reviews in Russian?**\
Yes. Reviews are scraped in whatever language they were written. Set `language: ru` to ensure the UI is in Russian.

**Is there a limit on how many reviews I can get per business?**\
You can set `maxItems` up to 500. Most businesses have fewer reviews than that; the scraper stops when there are no more reviews to load.

**Can I filter by minimum star rating?**\
Yes. Use `minRating` to exclude businesses below a threshold (e.g., `4.5` for only top-rated places).

**Why does the scraper use a proxy?**\
Yandex Maps may show a CAPTCHA for automated access from datacenter IP addresses. Residential proxies significantly reduce this. Proxy costs are separate from actor usage.

**How is this different from the Yandex Search Scraper?**\
The Yandex Search Scraper extracts web search results (links, snippets). This actor specializes in Yandex Maps — structured business data including coordinates, phone numbers, hours, photos, and reviews that do not appear in web search results.

**Can I get the coordinates of each business?**\
Yes. Latitude and longitude are included in each place record under the `coordinates` field.

# Actor input Schema

## `mode` (type: `string`):

What to scrape. searchPlaces: search for businesses by keyword. getDetails: fetch full details of specific business URLs. getReviews: scrape reviews from specific business URLs.

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

One or more search queries (mode=searchPlaces). Combine business type and location, e.g. 'coffee shops Moscow', 'sushi restaurant Istanbul'.

## `businessUrls` (type: `array`):

Yandex Maps business page URLs (mode=getDetails or getReviews). Format: https://yandex.com/maps/org/{name}/{id}/

## `yandexDomain` (type: `string`):

Yandex Maps regional domain to use.

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

UI and results language.

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

Maximum number of records to return (places or reviews).

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

Filter out places below this rating. Only applies in searchPlaces mode.

## `reviewsSortOrder` (type: `string`):

How to sort reviews. Only applies in getReviews mode.

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

Recommended. Yandex may trigger captcha on datacenter IPs. Residential proxies give best results.

## Actor input object example

```json
{
  "mode": "searchPlaces",
  "searchQueries": [
    "coffee shops Moscow"
  ],
  "businessUrls": [],
  "yandexDomain": "yandex.ru",
  "language": "en",
  "maxItems": 20,
  "minRating": "any",
  "reviewsSortOrder": "by_date_desc",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `results` (type: `string`):

Dataset with scraped Yandex Maps places and reviews

# 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 = {
    "mode": "searchPlaces",
    "searchQueries": [
        "coffee shops Moscow"
    ],
    "businessUrls": [],
    "yandexDomain": "yandex.ru",
    "maxItems": 20,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/yandex-maps-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "mode": "searchPlaces",
    "searchQueries": ["coffee shops Moscow"],
    "businessUrls": [],
    "yandexDomain": "yandex.ru",
    "maxItems": 20,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/yandex-maps-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 '{
  "mode": "searchPlaces",
  "searchQueries": [
    "coffee shops Moscow"
  ],
  "businessUrls": [],
  "yandexDomain": "yandex.ru",
  "maxItems": 20,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call crawlerbros/yandex-maps-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Yandex Maps Scraper",
        "description": "Scrape business listings, reviews, and place details from Yandex Maps. Extract name, address, phone, website, rating, reviews, working hours, photos and coordinates. Supports 6 regional domains",
        "version": "1.0",
        "x-build-id": "fiQi344EChdj4wifT"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~yandex-maps-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-yandex-maps-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/crawlerbros~yandex-maps-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-yandex-maps-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/crawlerbros~yandex-maps-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-yandex-maps-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": [
                    "mode"
                ],
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "searchPlaces",
                            "getDetails",
                            "getReviews"
                        ],
                        "type": "string",
                        "description": "What to scrape. searchPlaces: search for businesses by keyword. getDetails: fetch full details of specific business URLs. getReviews: scrape reviews from specific business URLs.",
                        "default": "searchPlaces"
                    },
                    "searchQueries": {
                        "title": "Search Queries",
                        "type": "array",
                        "description": "One or more search queries (mode=searchPlaces). Combine business type and location, e.g. 'coffee shops Moscow', 'sushi restaurant Istanbul'.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "businessUrls": {
                        "title": "Business URLs",
                        "type": "array",
                        "description": "Yandex Maps business page URLs (mode=getDetails or getReviews). Format: https://yandex.com/maps/org/{name}/{id}/",
                        "items": {
                            "type": "string"
                        }
                    },
                    "yandexDomain": {
                        "title": "Yandex Domain",
                        "enum": [
                            "yandex.com",
                            "yandex.ru",
                            "yandex.com.tr",
                            "yandex.kz",
                            "yandex.uz",
                            "yandex.by"
                        ],
                        "type": "string",
                        "description": "Yandex Maps regional domain to use.",
                        "default": "yandex.ru"
                    },
                    "language": {
                        "title": "Language",
                        "enum": [
                            "en",
                            "ru",
                            "tr",
                            "de",
                            "fr",
                            "uk",
                            "kk",
                            "uz"
                        ],
                        "type": "string",
                        "description": "UI and results language.",
                        "default": "en"
                    },
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum number of records to return (places or reviews).",
                        "default": 20
                    },
                    "minRating": {
                        "title": "Minimum Rating (searchPlaces only)",
                        "enum": [
                            "any",
                            "3",
                            "3.5",
                            "4",
                            "4.5"
                        ],
                        "type": "string",
                        "description": "Filter out places below this rating. Only applies in searchPlaces mode.",
                        "default": "any"
                    },
                    "reviewsSortOrder": {
                        "title": "Reviews Sort Order (getReviews only)",
                        "enum": [
                            "by_date_desc",
                            "by_rating_desc",
                            "by_relevance"
                        ],
                        "type": "string",
                        "description": "How to sort reviews. Only applies in getReviews mode.",
                        "default": "by_date_desc"
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Recommended. Yandex may trigger captcha on datacenter IPs. Residential proxies give best results."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
