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

Scrape Yandex Maps businesses with contacts, ratings, hours and reviews.

- **URL**: https://apify.com/khadinakbar/yandex-maps-scraper.md
- **Developed by:** [Khadin Akbar](https://apify.com/khadinakbar) (community)
- **Categories:** Lead generation, MCP servers, Travel
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 1,000 place scrapeds

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

Scrape **Yandex Maps** businesses at scale — names, phone numbers, websites, addresses, coordinates, categories, opening hours, ratings, review counts, and (optionally) full reviews. Search by keyword, by category + city, or paste Yandex Maps URLs. Built for B2B lead generation and local-market research across **Russia, Turkey, the CIS and Central Asia**, where Yandex Maps has deeper coverage than Google Maps.

MCP-ready: one query in, structured JSON out — a natural tool call for Claude, ChatGPT and other AI agents.

### What you can do

- Find every coffee shop, dentist, gym, hotel or any business type in a city.
- Build B2B lead lists with phone, website and social links.
- Benchmark competitors by rating and review volume.
- Pull customer reviews for sentiment and reputation analysis.

### When to use it

| Use this actor for | Use a different actor for |
|---|---|
| Yandex Maps places, contacts & reviews (RU/TR/CIS) | Google Maps worldwide → google-maps-leads-scraper |
| Local lead generation in Russia, Turkey, Kazakhstan… | LinkedIn company/people data |

### Output (one row per business)

| Field | Description |
|---|---|
| `name` | Business name |
| `category` / `categories` | Primary category + all categories |
| `address` | Full address |
| `coordinates` | `{ lat, lng }` |
| `phone` / `phones` | Primary phone + all phones |
| `website` | Website URL |
| `socialLinks` | Instagram / VK / Telegram / etc. |
| `rating` | Average rating |
| `reviewCount` | Number of reviews |
| `hours` | Opening hours |
| `url` | Canonical Yandex Maps URL |
| `reviews` | Array of `{ author, rating, text, date }` (only when **Include reviews** is on) |
| `yandexId` | Stable Yandex organisation ID |
| `scrapedAt` | ISO-8601 timestamp |

### Pricing (pay per result)

- **$0.005 per place** scraped
- **$0.002 per review** scraped (only when **Include reviews** is enabled)
- $0.00005 actor start

A typical 50-place lead list costs about **$0.25**. Reviews are billed only when you ask for them.

### Input

```json
{
  "searchQuery": "coffee Moscow",
  "maxPlaces": 50,
  "includeReviews": false,
  "maxReviewsPerPlace": 20,
  "language": "ru_RU"
}
````

Three ways to target data:

1. **Search query** — `"searchQuery": "dentist Istanbul"`.
2. **Category + city** — `"category": "restaurant"`, `"city": "Saint Petersburg"`.
3. **Start URLs** — paste a Yandex Maps search URL (`.../maps/?text=...`) or an organisation URL (`.../maps/org/<id>/`).

Set `language` to `ru_RU` (yandex.ru, best Russia/CIS coverage), `en_US` (yandex.com) or `tr_TR` (yandex.com.tr).

### How it works

Yandex Maps is a JavaScript single-page app protected by SmartCaptcha. This actor drives a real browser through **Apify Residential proxies** (default region: Russia) and **passively captures the site's own `/maps/api/search` JSON**, so the data is structured and complete rather than scraped from fragile HTML. It scrolls the results list to paginate past the first page, retires blocked sessions automatically, and degrades gracefully — partial results are always saved with a clear status message.

### Usage examples

#### Apify API (JavaScript)

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

const client = new ApifyClient({ token: 'YOUR_TOKEN' });
const run = await client.actor('khadinakbar/yandex-maps-scraper').call({
  searchQuery: 'coffee Moscow',
  maxPlaces: 100,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### Apify API (Python)

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_TOKEN")
run = client.actor("khadinakbar/yandex-maps-scraper").call(run_input={
    "searchQuery": "dentist Istanbul",
    "language": "tr_TR",
    "maxPlaces": 50,
})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["name"], item["phone"])
```

#### As an MCP tool

Add via `https://mcp.apify.com?tools=khadinakbar/yandex-maps-scraper` and ask your agent: *"Find 20 gyms in Almaty with phone numbers."*

### Tips for best results

- Combine a business type with a place: `"coffee Moscow"` beats `"coffee"`.
- For more than a few hundred results, run several narrower queries (by district or sub-category) — Yandex caps a single listing.
- Match the proxy country to your target market (RU for Russia, TR for Turkey).
- Keep **Include reviews** off for fast, cheap lead lists; turn it on only when you need review text.

### FAQ

**Do I need cookies or a login?** No. Only public Yandex Maps data is scraped.

**Why residential proxies?** Yandex SmartCaptcha blocks datacenter IPs. Residential proxies (default RU) keep the success rate high. They are billed via Apify proxy usage.

**Why did a run return fewer places than `maxPlaces`?** The query genuinely had fewer results, or Yandex capped the listing. Try a broader term or split by district.

**What languages are supported?** Russian, English and Turkish UIs. Review text is returned in its original language.

### Legal & compliance

This actor collects only publicly available information from Yandex Maps. You are responsible for using the data in compliance with Yandex's Terms of Service, applicable data-protection laws (including GDPR and Russian Federal Law No. 152-FZ where relevant), and any local regulations. Do not use scraped personal data for spam or unlawful purposes. This tool is provided for legitimate research, lead generation and analytics.

# Actor input Schema

## `searchQuery` (type: `string`):

Free-text search run on Yandex Maps, exactly as you would type it in the search box (e.g. 'coffee Moscow' or 'дантист Казань'). Combine a business type and a place for best results. Leave empty if you instead use category + city or startUrls. NOT a URL — paste URLs into 'Start URLs' instead.

## `category` (type: `string`):

Business type to search for, used together with 'City' when you do not supply a full search query (e.g. 'restaurant', 'gym', 'автосервис'). Combined internally as '<category> <city>'. Ignored if 'Search query' is set. Optional.

## `city` (type: `string`):

City or area to search within, paired with 'Category' (e.g. 'Saint Petersburg', 'Ankara'). Only used when 'Search query' is empty. Yandex auto-geocodes the place name. Optional.

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

Yandex Maps URLs to scrape directly: a search-results URL (.../maps/?text=...) scrapes its listing, an organisation URL (.../maps/org/<id>/) scrapes that one business. Use this when you already have specific Yandex Maps links. Accepts the standard Apify URL list. Leave empty when using a search query.

## `maxPlaces` (type: `integer`):

Maximum number of unique businesses to return across all queries/URLs. Each place is billed once. Defaults to 50; range 1–1000. Yandex caps a single listing around a few hundred results, so very large targets need multiple narrower queries.

## `includeReviews` (type: `boolean`):

When enabled, each place also gets its visible Yandex reviews scraped (author, rating, text, date) and billed per review. Adds significant runtime, so keep it off for fast lead lists. Defaults to false. Use 'Max reviews per place' to cap volume.

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

Upper limit of reviews fetched per business when 'Include reviews' is on. Defaults to 20; range 0–200. Set to 0 to disable reviews even if the toggle is on. Ignored entirely when 'Include reviews' is off.

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

Yandex locale used for the search and for field text. 'ru\_RU' uses yandex.ru (best coverage for Russia/CIS), 'en\_US' uses yandex.com (English UI), 'tr\_TR' uses yandex.com.tr (Turkey). Defaults to ru\_RU. Does not translate review text — that stays in the original language.

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

Proxy used for requests. Yandex Maps requires residential proxies to avoid SmartCaptcha; the default is Apify Residential in Russia. Change the country to match your target region (e.g. TR for Turkey). Keep 'Use Apify Proxy' enabled.

## Actor input object example

```json
{
  "searchQuery": "dentist Istanbul",
  "category": "restaurant",
  "city": "Saint Petersburg",
  "startUrls": [
    {
      "url": "https://yandex.com/maps/?text=hotels%20Sochi"
    }
  ],
  "maxPlaces": 50,
  "includeReviews": false,
  "maxReviewsPerPlace": 20,
  "language": "ru_RU",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "RU"
  }
}
```

# Actor output Schema

## `places` (type: `string`):

Dataset of scraped Yandex Maps businesses (one row per place).

# 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 = {
    "searchQuery": "coffee Moscow",
    "maxPlaces": 50,
    "includeReviews": false,
    "maxReviewsPerPlace": 20,
    "language": "ru_RU"
};

// Run the Actor and wait for it to finish
const run = await client.actor("khadinakbar/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 = {
    "searchQuery": "coffee Moscow",
    "maxPlaces": 50,
    "includeReviews": False,
    "maxReviewsPerPlace": 20,
    "language": "ru_RU",
}

# Run the Actor and wait for it to finish
run = client.actor("khadinakbar/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 '{
  "searchQuery": "coffee Moscow",
  "maxPlaces": 50,
  "includeReviews": false,
  "maxReviewsPerPlace": 20,
  "language": "ru_RU"
}' |
apify call khadinakbar/yandex-maps-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Yandex Maps Scraper",
        "description": "Scrape Yandex Maps businesses with contacts, ratings, hours and reviews.",
        "version": "0.1",
        "x-build-id": "eD6PZ4QE2NIGNV8R6"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/khadinakbar~yandex-maps-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-khadinakbar-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/khadinakbar~yandex-maps-scraper/runs": {
            "post": {
                "operationId": "runs-sync-khadinakbar-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/khadinakbar~yandex-maps-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-khadinakbar-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",
                "properties": {
                    "searchQuery": {
                        "title": "Search query",
                        "type": "string",
                        "description": "Free-text search run on Yandex Maps, exactly as you would type it in the search box (e.g. 'coffee Moscow' or 'дантист Казань'). Combine a business type and a place for best results. Leave empty if you instead use category + city or startUrls. NOT a URL — paste URLs into 'Start URLs' instead."
                    },
                    "category": {
                        "title": "Category / business type",
                        "type": "string",
                        "description": "Business type to search for, used together with 'City' when you do not supply a full search query (e.g. 'restaurant', 'gym', 'автосервис'). Combined internally as '<category> <city>'. Ignored if 'Search query' is set. Optional."
                    },
                    "city": {
                        "title": "City / location",
                        "type": "string",
                        "description": "City or area to search within, paired with 'Category' (e.g. 'Saint Petersburg', 'Ankara'). Only used when 'Search query' is empty. Yandex auto-geocodes the place name. Optional."
                    },
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "Yandex Maps URLs to scrape directly: a search-results URL (.../maps/?text=...) scrapes its listing, an organisation URL (.../maps/org/<id>/) scrapes that one business. Use this when you already have specific Yandex Maps links. Accepts the standard Apify URL list. Leave empty when using a search query.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxPlaces": {
                        "title": "Max places",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum number of unique businesses to return across all queries/URLs. Each place is billed once. Defaults to 50; range 1–1000. Yandex caps a single listing around a few hundred results, so very large targets need multiple narrower queries.",
                        "default": 50
                    },
                    "includeReviews": {
                        "title": "Include reviews",
                        "type": "boolean",
                        "description": "When enabled, each place also gets its visible Yandex reviews scraped (author, rating, text, date) and billed per review. Adds significant runtime, so keep it off for fast lead lists. Defaults to false. Use 'Max reviews per place' to cap volume.",
                        "default": false
                    },
                    "maxReviewsPerPlace": {
                        "title": "Max reviews per place",
                        "minimum": 0,
                        "maximum": 200,
                        "type": "integer",
                        "description": "Upper limit of reviews fetched per business when 'Include reviews' is on. Defaults to 20; range 0–200. Set to 0 to disable reviews even if the toggle is on. Ignored entirely when 'Include reviews' is off.",
                        "default": 20
                    },
                    "language": {
                        "title": "Language / region",
                        "enum": [
                            "ru_RU",
                            "en_US",
                            "tr_TR"
                        ],
                        "type": "string",
                        "description": "Yandex locale used for the search and for field text. 'ru_RU' uses yandex.ru (best coverage for Russia/CIS), 'en_US' uses yandex.com (English UI), 'tr_TR' uses yandex.com.tr (Turkey). Defaults to ru_RU. Does not translate review text — that stays in the original language.",
                        "default": "ru_RU"
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Proxy used for requests. Yandex Maps requires residential proxies to avoid SmartCaptcha; the default is Apify Residential in Russia. Change the country to match your target region (e.g. TR for Turkey). Keep 'Use Apify Proxy' enabled.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ],
                            "apifyProxyCountry": "RU"
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
