# Google Maps Reviews Leads Scraper (`paduchak/google-maps-reviews-leads-scraper`) Actor

Extract Google Maps reviews from businesses and turn review data into useful lead/reputation insights for agencies, marketers, and researchers.

- **URL**: https://apify.com/paduchak/google-maps-reviews-leads-scraper.md
- **Developed by:** [Dmytro Paduchak](https://apify.com/paduchak) (community)
- **Categories:** SEO tools, Other, Integrations
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.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.

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

## Google Maps Reviews Scraper

Collect public Google Maps reviews from direct place URLs, Google Maps search queries, or dataset items produced by the Google Maps Business Actor.

The Actor reuses the same Google Maps place discovery and place-page navigation approach as the business scraper, then opens each place's reviews panel, scrolls reviews, expands visible review text, and stores one dataset item per review.

No Google Maps API key is required.

### Input

You can start from any mix of:

- `placeUrls` or `placeUrl`: direct Google Maps place URLs
- `searchQueries` or `searchQuery`: Google Maps searches; the Actor discovers places first
- `datasetItems`: pasted items from the Google Maps Business Actor
- `inputDatasetId`: an Apify Dataset ID or name containing Google Maps Business Actor output
- `startUrls`: Apify-style URL objects; `/maps/search/` URLs are treated as search pages, other URLs as places

Example:

```json
{
  "searchQueries": ["coffee shops in London"],
  "placeUrls": [
    "https://www.google.com/maps/place/Hideaway+Coffee+House/..."
  ],
  "maxPlacesPerQuery": 20,
  "maxReviewsPerPlace": 100,
  "reviewsSort": "newest",
  "language": "en",
  "country": "uk",
  "apifyProxy": true,
  "apifyProxyGroups": ["RESIDENTIAL"],
  "proxySessionRetries": 2,
  "adaptiveThrottle": true
}
````

### Output

Each review is saved as one item in the default Apify Dataset. Place fields from the source item are preserved where available, and missing place fields are filled from the live Google Maps place page.

```json
{
  "businessName": "Example Coffee",
  "category": "Coffee shop",
  "rating": 4.6,
  "reviewCount": 321,
  "address": "10 Example Street, London",
  "phone": "+44 1234 567890",
  "website": "https://example.com/",
  "googleMapsUrl": "https://www.google.com/maps/place/Example+Coffee/...",
  "latitude": 51.5072,
  "longitude": -0.1276,
  "placeId": "0x487...",
  "reviewAuthor": "Jane D.",
  "reviewRating": 5,
  "reviewText": "Great coffee and friendly staff.",
  "reviewDate": "2 weeks ago",
  "reviewLanguage": "en",
  "ownerResponse": "Thanks for visiting us!",
  "reviewId": "ChdDSUhNMG...",
  "sourceQuery": "coffee shops in London",
  "scrapedAt": "2026-05-12T12:00:00.000Z"
}
```

If an input dataset item already has `scrapedAt`, the Actor preserves it as `placeScrapedAt` and uses `scrapedAt` for the review scrape timestamp.

### Notes

Google Maps review pages can vary by language, market, place type, and account/browser state. Some reviews may expose only rating, author, and relative date; fields such as `reviewLanguage`, `ownerResponse`, `reviewId`, or `reviewUrl` are saved when Google makes them available in the page.

For larger runs, enable Apify Proxy, prefer residential proxy groups, keep search queries focused, and use moderate `maxPlacesPerQuery` and `maxReviewsPerPlace` values.

### Legal Disclaimer

This Actor is intended for academic, educational, and research purposes only. Users are responsible for ensuring that their use of this tool complies with Google's [Terms of Service](https://policies.google.com/terms), [Google Maps Terms](https://www.google.com/help/terms_maps/), and any applicable local laws regarding data privacy and scraping.

Automated access to Google services may be restricted. We do not encourage or condone use of this tool for activity that violates the rights of others or the service provider.

# Actor input Schema

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

Google Maps search queries. The Actor discovers places from each query and then extracts reviews from those places.

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

Convenience field for one Google Maps search query.

## `placeUrls` (type: `array`):

Direct Google Maps place URLs to scrape reviews from.

## `placeUrl` (type: `string`):

Convenience field for one Google Maps place URL.

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

Apify-style start URLs. Place URLs are scraped directly; /maps/search/ URLs are treated as search pages.

## `datasetItems` (type: `array`):

Paste items produced by the Google Maps Business Actor. Items should include googleMapsUrl.

## `inputDatasetId` (type: `string`):

Optional Apify Dataset ID or name containing items from the Google Maps Business Actor.

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

Maximum total places to open after combining URLs, dataset items, and discovered search results.

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

Maximum places to discover from each Google Maps search query.

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

Maximum reviews to save from each place.

## `reviewsSort` (type: `string`):

Sort order to apply in the Google Maps reviews panel when available.

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

Google interface language passed as the hl URL parameter and browser locale.

## `country` (type: `string`):

Optional country hint passed as the gl URL parameter, for example uk, us, de, fr.

## `apifyProxy` (type: `boolean`):

Enable Apify Proxy for more reliable scraping.

## `apifyProxyGroups` (type: `array`):

Proxy pools: RESIDENTIAL, DATACENTER, SERP.

## `proxyCountries` (type: `array`):

Route through specific countries using ISO 2-letter country codes.

## `proxyUrls` (type: `array`):

Custom proxy URLs. If provided, these override Apify Proxy.

## `proxySessionRetries` (type: `integer`):

How many times to retry the browser scrape with a fresh proxy session after blocking, empty results, or navigation failures.

## `adaptiveThrottle` (type: `boolean`):

Automatically increases delays when Google Maps loads slowly or shows blocking signals.

## `baseThrottleDelayMs` (type: `integer`):

Starting delay before place and review actions. The adaptive throttle can increase from this value.

## `maxThrottleDelayMs` (type: `integer`):

Upper limit for adaptive delays.

## `slowLoadThresholdMs` (type: `integer`):

Load duration that causes adaptive throttling to slow down future actions.

## Actor input object example

```json
{
  "searchQueries": [
    "coffee shops in London"
  ],
  "placeUrls": [],
  "startUrls": [],
  "datasetItems": [],
  "maxPlaces": 100,
  "maxPlacesPerQuery": 20,
  "maxReviewsPerPlace": 100,
  "reviewsSort": "newest",
  "language": "en",
  "apifyProxy": true,
  "apifyProxyGroups": [
    "RESIDENTIAL"
  ],
  "proxyCountries": [],
  "proxyUrls": [],
  "proxySessionRetries": 2,
  "adaptiveThrottle": true,
  "baseThrottleDelayMs": 250,
  "maxThrottleDelayMs": 10000,
  "slowLoadThresholdMs": 12000
}
```

# Actor output Schema

## `reviews` (type: `string`):

Review records scraped from public Google Maps place pages.

# 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 = {
    "searchQueries": [
        "coffee shops in London"
    ],
    "apifyProxyGroups": [
        "RESIDENTIAL"
    ],
    "proxyCountries": [],
    "proxyUrls": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("paduchak/google-maps-reviews-leads-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 = {
    "searchQueries": ["coffee shops in London"],
    "apifyProxyGroups": ["RESIDENTIAL"],
    "proxyCountries": [],
    "proxyUrls": [],
}

# Run the Actor and wait for it to finish
run = client.actor("paduchak/google-maps-reviews-leads-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 '{
  "searchQueries": [
    "coffee shops in London"
  ],
  "apifyProxyGroups": [
    "RESIDENTIAL"
  ],
  "proxyCountries": [],
  "proxyUrls": []
}' |
apify call paduchak/google-maps-reviews-leads-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Google Maps Reviews Leads Scraper",
        "description": "Extract Google Maps reviews from businesses and turn review data into useful lead/reputation insights for agencies, marketers, and researchers.",
        "version": "0.0",
        "x-build-id": "QWxSZCgwuw0g9hHKs"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/paduchak~google-maps-reviews-leads-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-paduchak-google-maps-reviews-leads-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/paduchak~google-maps-reviews-leads-scraper/runs": {
            "post": {
                "operationId": "runs-sync-paduchak-google-maps-reviews-leads-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/paduchak~google-maps-reviews-leads-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-paduchak-google-maps-reviews-leads-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": {
                    "searchQueries": {
                        "title": "Search Queries",
                        "type": "array",
                        "description": "Google Maps search queries. The Actor discovers places from each query and then extracts reviews from those places.",
                        "items": {
                            "type": "string"
                        },
                        "default": []
                    },
                    "searchQuery": {
                        "title": "Single Search Query",
                        "type": "string",
                        "description": "Convenience field for one Google Maps search query."
                    },
                    "placeUrls": {
                        "title": "Google Maps Place URLs",
                        "type": "array",
                        "description": "Direct Google Maps place URLs to scrape reviews from.",
                        "items": {
                            "type": "string"
                        },
                        "default": []
                    },
                    "placeUrl": {
                        "title": "Single Place URL",
                        "type": "string",
                        "description": "Convenience field for one Google Maps place URL."
                    },
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "Apify-style start URLs. Place URLs are scraped directly; /maps/search/ URLs are treated as search pages.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL",
                                    "description": "Google Maps place URL or Google Maps search URL to use as a starting point."
                                }
                            }
                        },
                        "default": []
                    },
                    "datasetItems": {
                        "title": "Business Actor Dataset Items",
                        "type": "array",
                        "description": "Paste items produced by the Google Maps Business Actor. Items should include googleMapsUrl.",
                        "items": {
                            "type": "object"
                        },
                        "default": []
                    },
                    "inputDatasetId": {
                        "title": "Input Dataset ID",
                        "type": "string",
                        "description": "Optional Apify Dataset ID or name containing items from the Google Maps Business Actor."
                    },
                    "maxPlaces": {
                        "title": "Maximum Places",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum total places to open after combining URLs, dataset items, and discovered search results.",
                        "default": 100
                    },
                    "maxPlacesPerQuery": {
                        "title": "Maximum Places per Query",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum places to discover from each Google Maps search query.",
                        "default": 20
                    },
                    "maxReviewsPerPlace": {
                        "title": "Maximum Reviews per Place",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum reviews to save from each place.",
                        "default": 100
                    },
                    "reviewsSort": {
                        "title": "Review Sort",
                        "enum": [
                            "newest",
                            "mostRelevant",
                            "highestRating",
                            "lowestRating"
                        ],
                        "type": "string",
                        "description": "Sort order to apply in the Google Maps reviews panel when available.",
                        "default": "newest"
                    },
                    "language": {
                        "title": "Language",
                        "type": "string",
                        "description": "Google interface language passed as the hl URL parameter and browser locale.",
                        "default": "en"
                    },
                    "country": {
                        "title": "Country",
                        "type": "string",
                        "description": "Optional country hint passed as the gl URL parameter, for example uk, us, de, fr."
                    },
                    "apifyProxy": {
                        "title": "Enable Apify Proxy",
                        "type": "boolean",
                        "description": "Enable Apify Proxy for more reliable scraping.",
                        "default": true
                    },
                    "apifyProxyGroups": {
                        "title": "Apify Proxy Groups",
                        "type": "array",
                        "description": "Proxy pools: RESIDENTIAL, DATACENTER, SERP.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "RESIDENTIAL",
                                "DATACENTER",
                                "SERP"
                            ]
                        },
                        "default": [
                            "RESIDENTIAL"
                        ]
                    },
                    "proxyCountries": {
                        "title": "Proxy Countries",
                        "type": "array",
                        "description": "Route through specific countries using ISO 2-letter country codes.",
                        "items": {
                            "type": "string"
                        },
                        "default": []
                    },
                    "proxyUrls": {
                        "title": "Custom Proxy URLs",
                        "type": "array",
                        "description": "Custom proxy URLs. If provided, these override Apify Proxy.",
                        "items": {
                            "type": "string"
                        },
                        "default": []
                    },
                    "proxySessionRetries": {
                        "title": "Proxy Session Retries",
                        "minimum": 0,
                        "maximum": 5,
                        "type": "integer",
                        "description": "How many times to retry the browser scrape with a fresh proxy session after blocking, empty results, or navigation failures.",
                        "default": 2
                    },
                    "adaptiveThrottle": {
                        "title": "Adaptive Throttle",
                        "type": "boolean",
                        "description": "Automatically increases delays when Google Maps loads slowly or shows blocking signals.",
                        "default": true
                    },
                    "baseThrottleDelayMs": {
                        "title": "Base Throttle Delay (ms)",
                        "minimum": 0,
                        "maximum": 60000,
                        "type": "integer",
                        "description": "Starting delay before place and review actions. The adaptive throttle can increase from this value.",
                        "default": 250
                    },
                    "maxThrottleDelayMs": {
                        "title": "Max Throttle Delay (ms)",
                        "minimum": 0,
                        "maximum": 120000,
                        "type": "integer",
                        "description": "Upper limit for adaptive delays.",
                        "default": 10000
                    },
                    "slowLoadThresholdMs": {
                        "title": "Slow Load Threshold (ms)",
                        "minimum": 1000,
                        "maximum": 120000,
                        "type": "integer",
                        "description": "Load duration that causes adaptive throttling to slow down future actions.",
                        "default": 12000
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
