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

Scrape Yandex Maps places with ratings, contacts, websites, addresses, coordinates, opening hours, and categories for local lead generation.

- **URL**: https://apify.com/fetch\_cat/yandex-maps-scraper.md
- **Developed by:** [Hanna Nosova](https://apify.com/fetch_cat) (community)
- **Categories:** Lead generation, SEO tools, Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.02 / 1,000 place extracteds

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

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

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

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

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## Yandex Maps Scraper

Scrape public Yandex Maps places with ratings, contacts, addresses, websites, coordinates, categories, and opening-hours data.

Use this actor to build local lead lists, local SEO datasets, market maps, and business directories from public Yandex Maps search results. Results can be downloaded as CSV, JSON, Excel, XML, RSS, or used through the Apify Dataset API.

### At a glance

- **Local business discovery**: Search by category or keyword, such as `coffee`, `plumber`, `hotel`, `dentist`, or `restaurant`.
- **Place details**: Export names, categories, ratings, review counts, addresses, phones, websites, coordinates, hours, images, and Yandex Maps URLs.
- **City targeting**: Use a public Yandex Maps city URL or a text location fallback.
- **Lead and SEO workflows**: Build local prospect lists, competitor maps, local directory datasets, and branch-location research.
- **API-ready output**: Send flat place records to CRMs, spreadsheets, BI tools, maps, agents, or enrichment pipelines.

### Ready-to-run examples

Use these saved Store examples as starting points. Open any example to prefill the Actor input, then adjust URLs, keywords, limits, or filters for your own run.

- **[Research Saint Petersburg Electronics Stores](https://apify.com/fetch_cat/yandex-maps-scraper/examples/saint-petersburg-electronics-stores)**
- **[Map Saint Petersburg Bookstores](https://apify.com/fetch_cat/yandex-maps-scraper/examples/saint-petersburg-bookstores)**
- **[Export Saint Petersburg Pet Stores](https://apify.com/fetch_cat/yandex-maps-scraper/examples/saint-petersburg-pet-stores)**
- **[Find Saint Petersburg Flower Shops](https://apify.com/fetch_cat/yandex-maps-scraper/examples/saint-petersburg-flower-shops)**
- **[Export Saint Petersburg Bakeries](https://apify.com/fetch_cat/yandex-maps-scraper/examples/saint-petersburg-bakeries)**
- **[Map Saint Petersburg Bars](https://apify.com/fetch_cat/yandex-maps-scraper/examples/saint-petersburg-bars-nightlife)**
- **[View all ready-to-run examples](https://apify.com/fetch_cat/yandex-maps-scraper/examples)** (50 examples)

### What can it do?

Yandex Maps Scraper saves one dataset row per public place found in Yandex Maps search results.

- **Search places**: Add one or more `queries` for business categories, service keywords, or place types.
- **Target a city**: Paste a public `cityUrl` such as `https://yandex.com/maps/213/moscow`.
- **Use location fallback**: Provide `location` when no city URL is available.
- **Extract embedded details**: Keep `includeDetails` enabled for phones, websites, hours, features, images, and coordinates when available.
- **Control output size**: Set `maxItems` to cap saved place records and spend.

### Common workflows

- **Lead generation**: Export local businesses with phone numbers, websites, ratings, and addresses.
- **Local SEO research**: Compare competitors by category, rating, review count, website presence, and location.
- **Market mapping**: Build datasets by city, category, or neighborhood for expansion planning.
- **Directory enrichment**: Use Yandex Maps URLs, place IDs, phones, and websites as enrichment anchors.
- **Scheduled monitoring**: Run the same query periodically to watch category visibility or rating changes.

### Pricing

This actor uses pay-per-event pricing. You pay a small run-start fee plus a per-place charge for saved dataset rows.

| Event name | Price from `actor.json` | Charged when |
| --- | --- | --- |
| `start` | `$0.005` per run | Once when the actor starts. |
| `item` | FREE `$0.000045939`; BRONZE `$0.000039947`; SILVER `$0.000031159`; GOLD `$0.000023968`; PLATINUM `$0.000015979`; DIAMOND `$0.000011185` | Each Yandex Maps place extracted and saved to the dataset. |

On BRONZE, `item` pricing is about `$0.039947` per 1,000 saved places. Start with `maxItems: 25` to validate a city and query before scaling up.

### Input configuration

| Setting | JSON key | Use it for |
| --- | --- | --- |
| Search queries | `queries` | Keywords or business categories to search on Yandex Maps, such as coffee, plumber, hotel, dentist, or restaurant. |
| Yandex Maps city URL | `cityUrl` | Public Yandex Maps city URL used as the search area. Example: `https://yandex.com/maps/213/moscow`. |
| Location fallback | `location` | Optional text location used only when no city URL is provided. |
| Maximum places | `maxItems` | Maximum number of places to save across all queries. |
| Language header | `language` | `Accept-Language` header sent to Yandex Maps. Use `en-US,en;q=0.9` for English output where available. |
| Include embedded details | `includeDetails` | Extract public detail fields already embedded in Yandex Maps search results, such as phones, websites, hours, features, images, and coordinates. |
| Include reviews (reserved) | `includeReviews` | Reserved for a later version. The current build returns place records and rating/review counts, not individual review rows. |

### Example input

```json
{
  "queries": ["coffee", "plumber"],
  "cityUrl": "https://yandex.com/maps/213/moscow",
  "maxItems": 25,
  "language": "en-US,en;q=0.9",
  "includeDetails": true,
  "includeReviews": false
}
````

### Example output

```json
{
  "query": "coffee",
  "rank": 1,
  "name": "Surf Coffee",
  "url": "https://yandex.com/maps/org/surf_coffee/238919133832/",
  "placeId": "238919133832",
  "category": "Coffee shop",
  "rating": 4.8,
  "reviewCount": 517,
  "address": "Okhotny Ryad Street, 2",
  "phone": "+7 (985) 111-91-64",
  "website": "https://surfcoffee.ru/",
  "coordinates": {
    "longitude": 37.61823,
    "latitude": 55.757274
  },
  "scrapedAt": "2026-06-28T00:00:00.000Z"
}
```

### Output fields

| Field | Description |
| --- | --- |
| `query` | Search query that produced the place. |
| `rank` | Position of the place in the scraped search results. |
| `name` | Place or business name. |
| `category` | Primary category shown by Yandex Maps. |
| `categories` | Additional category values when available. |
| `rating` | Public rating value when available. |
| `ratingCount` | Count behind the rating when available. |
| `reviewCount` | Public review-count value when available. |
| `address` | Short address text. |
| `fullAddress` | Longer address text when available. |
| `phone` | Primary phone number when available. |
| `phones` | Additional phone values when available. |
| `website` | Public business website when available. |
| `url` | Public Yandex Maps place URL. |
| `placeId` | Yandex Maps place identifier when available. |
| `coordinates` | Latitude and longitude values when available. |
| `hours` | Structured opening-hours data when available. |
| `workingTimeText` | Human-readable opening-hours text when available. |
| `status` | Current open/closed or place status text when available. |
| `features` | Public feature tags when available. |
| `socialLinks` | Public social links when available. |
| `imageUrl` | Public image URL when available. |
| `snippet` | Search-result snippet text when available. |
| `scrapedAt` | Timestamp when the row was saved. |

### Tips for best results

- **Use category terms**: Queries such as `dentist`, `hotel`, or `coffee` usually work better than vague phrases.
- **Run cities separately**: Separate tasks make outputs easier to compare and retry.
- **Start with a cap**: Use `maxItems: 25` for the first run, then increase it after checking quality.
- **Keep details enabled**: `includeDetails` improves contact and location fields when Yandex Maps exposes them.
- **Do not expect review text**: The current version returns rating and review counts, not individual reviews.

### API and integrations

- Run the actor from the Apify Console, API, SDKs, webhooks, schedules, or MCP-compatible agents.
- Export datasets as CSV, JSON, Excel, XML, RSS, or stream rows through the Dataset API.
- Send place records to CRMs, lead-scoring systems, mapping tools, or local SEO dashboards.
- Combine with contact, review, or search actors for broader local intelligence workflows.

### MCP and AI agents

Use the official Apify MCP server when you want an AI tool to run this actor directly.

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

Example prompts:

- "Find coffee shops in this Yandex Maps city URL and return places with websites."
- "Build a dentist lead list with phone numbers and ratings from Yandex Maps."
- "Run this Yandex Maps query weekly and summarize new high-rated businesses."

### Limits and responsible use

- The actor extracts public Yandex Maps search-result data. It does not log into Yandex or access private records.
- Phone, website, hour, image, and coordinate fields depend on what Yandex Maps exposes for each place.
- `includeReviews` is reserved; this actor does not currently save individual review rows.
- Review your use of exported data against Yandex terms, Apify terms, and applicable privacy rules.

### Related actors

- [Google Ads Transparency Center Scraper](https://apify.com/fetch_cat/google-ads-transparency-scraper) for advertiser and competitor research workflows.
- [Bing Search Results Scraper](https://apify.com/fetch_cat/bing-search-results-scraper) for search-result monitoring workflows.
- [Website Contact Finder](https://apify.com/fetch_cat/website-contact-finder) for public contact enrichment from business websites.
- [Google News Scraper](https://apify.com/fetch_cat/google-news-scraper) for local business or competitor news monitoring.

### FAQ

**Does it scrape individual Yandex reviews?** No. The current version returns place records plus rating and review counts, not individual review text.

**Can I scrape phones and websites?** Yes, when those public fields are available in Yandex Maps results and `includeDetails` is enabled.

**Can I schedule it?** Yes. Save the input as an Apify task and schedule repeat runs for the same query and city.

**Can I export to Excel?** Yes. Apify datasets support Excel, CSV, JSON, XML, RSS, and API access.

### Changelog

- `0.1`: Initial public version for Yandex Maps place search, contact fields, ratings, coordinates, dataset export, and pay-per-place pricing.

### Support

If a run fails, returns no data, or a field looks wrong, open an issue from the Actor page.

Please include the Apify run ID or run URL, input JSON, one example public URL, query, or input item, what you expected, and what the dataset returned. Small reproducible inputs make parsing or site-layout issues much faster to fix.

# Actor input Schema

## `queries` (type: `array`):

Keywords or business categories to search on Yandex Maps, such as coffee, plumber, hotel, dentist, or restaurant.

## `cityUrl` (type: `string`):

Public Yandex Maps city URL used as the search area. Example: https://yandex.com/maps/213/moscow

## `location` (type: `string`):

Optional text location used only when no city URL is provided.

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

Maximum number of places to save across all queries.

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

Accept-Language header sent to Yandex Maps. Use en-US,en;q=0.9 for English output where available.

## `includeDetails` (type: `boolean`):

Keep enabled to extract public detail fields already embedded in Yandex Maps search results, such as phones, websites, hours, features, images, and coordinates.

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

Reserved for a later version. The current build returns place records and rating/review counts, not individual review rows.

## Actor input object example

```json
{
  "queries": [
    "coffee",
    "plumber"
  ],
  "cityUrl": "https://yandex.com/maps/213/moscow",
  "location": "Moscow",
  "maxItems": 20,
  "language": "en-US,en;q=0.9",
  "includeDetails": true,
  "includeReviews": false
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "queries": [
        "coffee",
        "plumber"
    ],
    "cityUrl": "https://yandex.com/maps/213/moscow",
    "location": "Moscow"
};

// Run the Actor and wait for it to finish
const run = await client.actor("fetch_cat/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 = {
    "queries": [
        "coffee",
        "plumber",
    ],
    "cityUrl": "https://yandex.com/maps/213/moscow",
    "location": "Moscow",
}

# Run the Actor and wait for it to finish
run = client.actor("fetch_cat/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 '{
  "queries": [
    "coffee",
    "plumber"
  ],
  "cityUrl": "https://yandex.com/maps/213/moscow",
  "location": "Moscow"
}' |
apify call fetch_cat/yandex-maps-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=fetch_cat/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 places with ratings, contacts, websites, addresses, coordinates, opening hours, and categories for local lead generation.",
        "version": "0.1",
        "x-build-id": "YlkXdnA4VaYu9C1lL"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/fetch_cat~yandex-maps-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-fetch_cat-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/fetch_cat~yandex-maps-scraper/runs": {
            "post": {
                "operationId": "runs-sync-fetch_cat-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/fetch_cat~yandex-maps-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-fetch_cat-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": [
                    "queries"
                ],
                "properties": {
                    "queries": {
                        "title": "Search queries",
                        "type": "array",
                        "description": "Keywords or business categories to search on Yandex Maps, such as coffee, plumber, hotel, dentist, or restaurant.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "cityUrl": {
                        "title": "Yandex Maps city URL",
                        "type": "string",
                        "description": "Public Yandex Maps city URL used as the search area. Example: https://yandex.com/maps/213/moscow"
                    },
                    "location": {
                        "title": "Location fallback",
                        "type": "string",
                        "description": "Optional text location used only when no city URL is provided."
                    },
                    "maxItems": {
                        "title": "Maximum places",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum number of places to save across all queries.",
                        "default": 20
                    },
                    "language": {
                        "title": "Language header",
                        "type": "string",
                        "description": "Accept-Language header sent to Yandex Maps. Use en-US,en;q=0.9 for English output where available.",
                        "default": "en-US,en;q=0.9"
                    },
                    "includeDetails": {
                        "title": "Include embedded details",
                        "type": "boolean",
                        "description": "Keep enabled to extract public detail fields already embedded in Yandex Maps search results, such as phones, websites, hours, features, images, and coordinates.",
                        "default": true
                    },
                    "includeReviews": {
                        "title": "Include reviews (reserved)",
                        "type": "boolean",
                        "description": "Reserved for a later version. The current build returns place records and rating/review counts, not individual review rows.",
                        "default": false
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
