# Google Maps Reviews Scraper — Ratings, Text & Replies (No Key) (`nexgendata/google-maps-reviews`) Actor

- **URL**: https://apify.com/nexgendata/google-maps-reviews.md
- **Developed by:** [NexGenData](https://apify.com/nexgendata) (community)
- **Categories:** Business, Marketing
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 1,000 review extracteds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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 — Ratings, Review Text & Owner Replies (No API Key)

> ✅ **No Google API key required.** Extract every Google Maps review for any place — reviewer name, star rating, review text, date, owner replies, and likes. Just paste a place URL, a business name, or a search query and run.

Pull individual customer reviews straight from Google Maps for any business, landmark, hotel, restaurant, or service — at scale, with no Places API billing, no quotas, and no SDK fees. A drop-in **alternative to** Google Places API reviews, Outscraper Reviews, SerpApi Google Maps Reviews, and Bright Data — built for reputation monitoring, review analytics, and local-SEO research.

### Why This Beats the Places API & Paid Review APIs

| Feature | NexGenData Google Maps Reviews | Google Places API | Outscraper Reviews | SerpApi Maps Reviews | Bright Data |
|---|---|---|---|---|---|
| Reviews per place | **Up to thousands** (scrolled) | Only 5 most-relevant | Yes (plan-gated) | Yes (plan-gated) | Yes (enterprise) |
| Owner replies | **Yes** (text + date) | No | Partial | Partial | Partial |
| Review text + author | Yes | Yes | Yes | Yes | Yes |
| Star rating per review | Yes | Yes | Yes | Yes | Yes |
| Review date | Relative + absolute | Limited | Yes | Yes | Yes |
| Cost | Pay-per-event, no plan | $17–$32 / 1,000 calls | Per-result, plan-gated | $75–$2,500 / mo | Enterprise contract |
| Auth | Apify token | Google Cloud key + billing | API key + plan | API key + plan | Enterprise SSO |
| Time-to-first-row | < 90 seconds | Billing + project setup | Signup + plan | Signup + plan | Sales cycle |

The Places API caps you at **5 reviews per place** and never returns owner replies. This actor scrolls the full review feed and pulls **every review** plus the business owner's responses — ideal for sentiment analysis, competitor monitoring, and reputation management.

### What You Get

One record **per review**, with:

- **place_name**, **place_id**, **place_address** — which place the review belongs to
- **reviewer_name** — the review author
- **reviewer_review_count** — how many reviews the author has written (credibility signal)
- **rating** — 1–5 stars for this review
- **review_text** — the full review (auto-expanded past "More")
- **review_date** — relative date as shown ("2 weeks ago"), plus absolute where available
- **owner_response** + **owner_response_date** — the business's public reply, if any
- **likes_count** — helpful votes on the review
- **review_url** — link back to the place
- **data_source**, **as_of_timestamp** — provenance for every row

Output streams to a clean Apify dataset — export to CSV, JSON, Excel, or hit the API directly.

### Use Cases

- **Reputation monitoring** — track new reviews and owner replies for your locations over time.
- **Competitor analysis** — pull a rival's full review history and mine it for complaints and praise.
- **Sentiment & NLP** — feed thousands of real review texts into your sentiment or topic models.
- **Local SEO audits** — measure review velocity, rating distribution, and response rate.
- **Customer research** — surface recurring themes in what real customers say.

### How To Use

Provide **any one** of:

1. **Google Maps place URLs** — `placeUrls: ["https://www.google.com/maps/place/Franklin+Barbecue/..."]`
2. **Place names** — `searchQueries: ["Franklin Barbecue Austin TX"]` (opens the top match)
3. **A search query** — same field; the top matching place is scraped.

Set `maxReviews` (default 100) to control depth. The scraper sorts reviews **newest-first** and scrolls the feed to lazy-load up to that many.

#### 3 Sample Inputs

**A — By place name (recommended for a quick start):**
```json
{ "searchQueries": ["Franklin Barbecue Austin TX"], "maxReviews": 30 }
````

**B — By direct place URL:**

```json
{ "placeUrls": ["https://www.google.com/maps/place/Franklin+Barbecue"], "maxReviews": 200 }
```

**C — Multiple places at once:**

```json
{ "searchQueries": ["Blue Bottle Coffee SF", "Philz Coffee SF"], "maxReviews": 100 }
```

### 📊 Sample Output

```json
{
  "place_name": "Franklin Barbecue",
  "place_id": "0x8644b59e1c1d0a8f:0x...",
  "place_address": "900 E 11th St, Austin, TX 78702",
  "reviewer_name": "Jordan M.",
  "reviewer_review_count": 87,
  "rating": 5,
  "review_text": "Worth every minute of the line. The brisket melts in your mouth...",
  "review_date": "2 weeks ago",
  "owner_response": "Thanks so much for the kind words — see you next time!",
  "owner_response_date": "a week ago",
  "likes_count": 12,
  "review_url": "https://www.google.com/maps/place/Franklin+Barbecue/...",
  "data_source": "google_maps_scrape",
  "as_of_timestamp": "2026-06-13T00:00:00Z"
}
```

### How It Works

The actor launches a headless Chromium browser (Playwright) through Apify's **RESIDENTIAL** proxy network, handles Google's consent interstitial, opens the place's **Reviews** panel, sorts by **Newest**, and scrolls the review feed to lazy-load reviews up to your `maxReviews`. Each review card is parsed for the author, rating, text, date, owner reply, and likes. **No Google API key is ever required.**

### 🔗 Related Actors

- **[Google Maps Extractor — Business Leads & Emails](https://apify.com/nexgendata/google-maps-extractor?fpr=2ayu9b)** — names, phones, websites, emails, ratings, hours for whole local markets.
- **[Yelp Business Scraper](https://apify.com/nexgendata/yelp-business-scraper?fpr=2ayu9b)** — business listings + reviews from Yelp.
- **[Google Maps Scraper](https://apify.com/nexgendata/google-maps-scraper?fpr=2ayu9b)** — the original key-free Maps business scraper.

### 🏢 About NexGenData

NexGenData builds reliable, no-API-key public-data scrapers for lead generation, market research, and competitive intelligence. Every actor returns clean, structured data you can drop straight into your CRM, warehouse, or model. Explore the full fleet: [apify.com/nexgendata](https://apify.com/nexgendata?fpr=2ayu9b).

### ⚖️ Legal & Compliance

This actor collects **publicly available** review data displayed on Google Maps. Use it in accordance with applicable laws and Google's Terms of Service. Do not use scraped personal data in ways that violate privacy regulations (GDPR/CCPA). You are responsible for your use of the output.

### ❓ FAQ

**Do I need a Google API key?** No. The scraper reads Google Maps directly.

**How many reviews can I get?** Up to thousands per place — set `maxReviews`. Google lazy-loads reviews as you scroll; the actor scrolls until it reaches your limit or runs out.

**Does it get owner replies?** Yes — `owner_response` and `owner_response_date` when the business has replied.

**Can I pass a business name instead of a URL?** Yes — use `searchQueries`. The top matching place is scraped.

**What sort order?** Newest first, so you always capture the latest reviews.

**Which proxy should I use?** Apify RESIDENTIAL (default). Google Maps is anti-bot defended; residential IPs are strongly recommended.

**What does it cost?** Pay-per-event — you're charged per review extracted. No subscription.

### 🛠️ Troubleshooting

- **No reviews returned** — the place may genuinely have none, or Google served an anti-bot page. Re-run (each retry uses a fresh residential IP).
- **Fewer reviews than expected** — raise `maxReviews`; some places simply have fewer reviews than your limit.
- **Place not found by name** — pass a more specific query (add the city/state) or use the direct place URL.
- **Slow runs** — residential proxy + a real browser is slower than an API; this is the trade-off for needing no API key.
- **Run memory** — keep memory at 2048 MB or higher (Playwright needs it).

# Actor input Schema

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

Google Maps place URLs (https://www.google.com/maps/place/...). One record is returned per review for each place. You can also paste a Maps search URL. NO Google API key required. Leave blank and use Search Queries instead if you only have a business name.

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

Business names or search queries — e.g. 'Franklin Barbecue Austin TX', 'Eiffel Tower Paris'. The scraper opens the top matching place and extracts its reviews. Use this when you don't have a direct place URL.

## `maxReviews` (type: `integer`):

Maximum number of reviews to extract per place. Reviews are sorted by newest first and the feed is scrolled to lazy-load up to this many. 30 for a quick scan, up to a few thousand for full coverage.

## `max_reviews` (type: `integer`):

Alias of maxReviews.

## `placeNames` (type: `array`):

Alias of Search Queries. List of business/place names to look up and scrape reviews for.

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

Alias of Search Queries for users coming from other Apify scrapers.

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

Alias of Place URLs. Accepts Google Maps place URLs.

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

Alias of Place URLs. Accepts plain strings or {url: ...} dict items.

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

Proxy used to scrape Google Maps. Apify RESIDENTIAL proxy is strongly recommended (and used by default) — Google Maps is anti-bot defended.

## Actor input object example

```json
{
  "placeUrls": [],
  "searchQueries": [
    "Franklin Barbecue Austin TX"
  ],
  "maxReviews": 100,
  "max_reviews": 100,
  "placeNames": [],
  "queries": [],
  "urls": [],
  "startUrls": [],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

# 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 = {
    "placeUrls": [],
    "searchQueries": [
        "Franklin Barbecue Austin TX"
    ],
    "maxReviews": 100,
    "max_reviews": 100,
    "placeNames": [],
    "queries": [],
    "urls": [],
    "startUrls": [],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("nexgendata/google-maps-reviews").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 = {
    "placeUrls": [],
    "searchQueries": ["Franklin Barbecue Austin TX"],
    "maxReviews": 100,
    "max_reviews": 100,
    "placeNames": [],
    "queries": [],
    "urls": [],
    "startUrls": [],
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("nexgendata/google-maps-reviews").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 '{
  "placeUrls": [],
  "searchQueries": [
    "Franklin Barbecue Austin TX"
  ],
  "maxReviews": 100,
  "max_reviews": 100,
  "placeNames": [],
  "queries": [],
  "urls": [],
  "startUrls": [],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call nexgendata/google-maps-reviews --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Google Maps Reviews Scraper — Ratings, Text & Replies (No Key)",
        "version": "0.0",
        "x-build-id": "NtNdHKIketoJFkQzd"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/nexgendata~google-maps-reviews/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-nexgendata-google-maps-reviews",
                "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/nexgendata~google-maps-reviews/runs": {
            "post": {
                "operationId": "runs-sync-nexgendata-google-maps-reviews",
                "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/nexgendata~google-maps-reviews/run-sync": {
            "post": {
                "operationId": "run-sync-nexgendata-google-maps-reviews",
                "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": {
                    "placeUrls": {
                        "title": "Google Maps Place URLs",
                        "type": "array",
                        "description": "Google Maps place URLs (https://www.google.com/maps/place/...). One record is returned per review for each place. You can also paste a Maps search URL. NO Google API key required. Leave blank and use Search Queries instead if you only have a business name.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "searchQueries": {
                        "title": "Search Queries / Place Names",
                        "type": "array",
                        "description": "Business names or search queries — e.g. 'Franklin Barbecue Austin TX', 'Eiffel Tower Paris'. The scraper opens the top matching place and extracts its reviews. Use this when you don't have a direct place URL.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxReviews": {
                        "title": "Maximum Reviews Per Place",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum number of reviews to extract per place. Reviews are sorted by newest first and the feed is scrolled to lazy-load up to this many. 30 for a quick scan, up to a few thousand for full coverage.",
                        "default": 100
                    },
                    "max_reviews": {
                        "title": "Maximum Reviews (alias)",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Alias of maxReviews."
                    },
                    "placeNames": {
                        "title": "Place Names (alias)",
                        "type": "array",
                        "description": "Alias of Search Queries. List of business/place names to look up and scrape reviews for.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "queries": {
                        "title": "Queries (alias)",
                        "type": "array",
                        "description": "Alias of Search Queries for users coming from other Apify scrapers.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "urls": {
                        "title": "URLs (alias)",
                        "type": "array",
                        "description": "Alias of Place URLs. Accepts Google Maps place URLs.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "startUrls": {
                        "title": "Start URLs (alias)",
                        "type": "array",
                        "description": "Alias of Place URLs. Accepts plain strings or {url: ...} dict items."
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Proxy used to scrape Google Maps. Apify RESIDENTIAL proxy is strongly recommended (and used by default) — Google Maps is anti-bot defended.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
