# Google Maps Scraper (`surigami/google-maps-scraper`) Actor

📍 Google Maps Scraper
Google Maps Scraper lets you extract business data from Google Maps.

- **URL**: https://apify.com/surigami/google-maps-scraper.md
- **Developed by:** [surigami](https://apify.com/surigami) (community)
- **Categories:** E-commerce, SEO tools, Travel
- **Stats:** 4 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $100.01 / 1,000 results

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 Scraper

Extract business data from Google Maps to generate leads, analyze competitors, and perform market analysis.

### 📍 What is Google Maps Scraper?

Google Maps Scraper lets you extract business data from Google Maps, helping you generate leads, analyze competitors, and fuel growth with just a few clicks.

#### Key Features

- **Generate qualified leads**: Extract business names, websites, emails, and phone numbers to build prospect lists
- **Track competitors**: Monitor where competitors operate, ratings, and review counts
- **Market analysis**: Analyze market saturation, identify service gaps, benchmark local businesses
- **Support partnerships**: Discover top-rated or high-volume locations for outreach
- **Automate workflows**: Replace manual search tasks with repeatable, automated workflows

The scraper expands Google Maps data extraction beyond the limitations of the official Google Places API and bypasses the limitation of Google Maps displaying no more than 120 places per area.

### 📊 What Data Does It Extract?

- 🔗 **Title/place name** - Business name
- 📝 **Subtitle, category, place ID, and URL**
- 📍 **Address** - Location, plus code and exact coordinates
- ☎️ **Phone number**
- 🌐 **Website** (if available)
- 📝 **Company contact details** from website (email, phone, social media) - *Paid add-on*
- 🎯 **Business leads enrichment** (full name, work email, phone, job title, LinkedIn) - *Paid add-on*
- 📱 **Social media profile enrichment** (Facebook, Instagram, YouTube, TikTok, Twitter) - *Paid add-on*
- ➕ **List of detailed characteristics** (additionalInfo)
- 📊 **Review count and review distribution**
- ⭐️ **Average rating** (totalScore)
- 📸 **List of images**
- 🏨 **Hotel booking URL and price** + nearby hotels
- 🔒 **Temporarily or permanently closed status**
- 🙋 **Updates from customers & Questions and answers**
- 🔍 **People also search**
- 🏷 **Menu**
- 💲 **Price bracket**
- 🧑‍🍳 **Opening hours**
- ⌚️ **Popular times** - histogram & live occupancy
- 🪑 **Table reservation provider**
- 🛍 **Multiple businesses** located within indoor venues (malls, shopping centers)

### ⬇️ Input

The input for Google Maps Scraper should be either:

1. **Google Maps URL** - Direct search URL
2. **Location + Search Terms** - Location with search query
3. **Place IDs or URLs** - Direct place IDs/URLs (paid add-on)

#### Input Parameters

- **searchTerms** (array): List of search terms (e.g., `['restaurant', 'bar', 'cafe']`)
- **location** (string): Location to search in (e.g., `'New York, NY'` or coordinates)
- **startUrl** (string): Direct Google Maps search URL
- **placeIds** (array): Direct Google Maps Place IDs or URLs
- **categories** (array): Filter results by specific categories
- **maxResults** (number): Maximum number of places to scrape (0 = unlimited)
- **includeImages** (boolean): Extract images
- **includeReviews** (boolean): Extract reviews
- **includeAmenities** (boolean): Extract detailed characteristics
- **includePopularTimes** (boolean): Extract popular times data
- **includeMenu** (boolean): Extract menu information
- **includeQuestionsAnswers** (boolean): Extract Q&A
- **enrichWithContactDetails** (boolean): Extract contact details from website - *Paid add-on*
- **enrichWithLeads** (boolean): Enrich with business leads - *Paid add-on*
- **enrichWithSocialMedia** (boolean): Extract social media profiles - *Paid add-on*

#### Search Terms Best Practices

**Good example:**
````

\['restaurant', 'bar', 'pub', 'cafe', 'buffet', 'ice cream', 'tea house']

```

**Bad example:**
```

\['restaurant', 'restaurants', 'chinese restaurant', 'cafe', 'coffee', 'coffee shop']

````

Use distinct search terms that don't overlap significantly.

#### Categories Warning

⚠️ **Using categories can be dangerous!**

- Categories can introduce **false positives** (irrelevant places)
- Categories can cause **false negatives** (excluding relevant places)
- Google has thousands of categories, many are synonymous
- You must list ALL categories you want, including synonyms
- Example: `Divorce lawyer`, `Divorce service`, and `Divorce attorney` are three distinct categories

**Recommendation:** Use fewer search terms and many categories, or skip categories entirely.

### ⬆️ Output

Results are stored in a dataset accessible from the **Output** or **Storage** tab. You can:

- View results as a **table**, **JSON**, or **map**
- Download in various formats: **JSON**, **CSV**, **Excel**, **XML**, **HTML**
- Pick or omit specific output fields before exporting
- Download whole views with thematically connected data

**Reviews** and **Leads enrichment** views spread each review or lead to a separate row for easier processing.

### 🚀 Getting Started

#### Prerequisites

- Node.js 18+ (for local development)
- Apify account ([sign up here](https://console.apify.com/))

#### Local Development

1. **Install dependencies:**
   ```bash
   npm install
````

2. **Run locally:**
   ```bash
   npm start
   ```

#### Deploy to Apify

1. **Install Apify CLI:**
   ```bash
   npm install -g apify-cli
   ```

2. **Login to Apify:**
   ```bash
   apify login
   ```

3. **Push to Apify:**
   ```bash
   apify push
   ```

4. **Run on Apify:**
   ```bash
   apify run
   ```

Or run it from the [Apify Console](https://console.apify.com/).

### 📝 Example Usage

#### Example 1: Search by Location and Terms

```json
{
  "searchTerms": ["restaurant", "cafe"],
  "location": "New York, NY",
  "maxResults": 50,
  "includeReviews": true,
  "includeImages": true
}
```

#### Example 2: Direct URL

```json
{
  "startUrl": "https://www.google.com/maps/search/restaurants/@40.7128,-74.0060,12z/",
  "includePopularTimes": true,
  "includeMenu": true
}
```

#### Example 3: Direct Place IDs

```json
{
  "placeIds": [
    "ChIJN1t_tDeuEmsRUsoyG83frY4",
    "https://www.google.com/maps/place/Some+Place/@40.7128,-74.0060"
  ],
  "includeReviews": true,
  "includeAmenities": true
}
```

### 🔧 Configuration

#### Proxy Configuration

To avoid blocking, configure proxies in the input:

```json
{
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

### 📚 Resources

- [Apify Documentation](https://docs.apify.com/)
- [Apify SDK for JavaScript](https://docs.apify.com/sdk/js/)
- [Crawlee Documentation](https://crawlee.dev/)
- [Playwright Documentation](https://playwright.dev/)

### 📄 License

ISC

# Actor input Schema

## `searchTerms` (type: `array`):

List of search terms to find places on Google Maps (e.g., \['restaurant', 'bar', 'cafe']). Using multiple distinct search terms can increase results.

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

Location to search in (e.g., 'New York, NY', 'Berlin, Germany', or coordinates like '52.5200,13.4050')

## `customSearchArea` (type: `object`):

Custom search area using GeoJSON format. Supports Polygon, MultiPolygon, and Point (circle) types. Note: coordinates use \[longitude, latitude] order. For Point type, include 'radiusKm' property (default: 5km). Example: {"type":"Polygon","coordinates":\[\[\[-0.322813,51.597165],\[-0.31499,51.388023],\[0.060493,51.389199],\[0.051936,51.60036],\[-0.322813,51.597165]]]}

## `startUrl` (type: `string`):

Direct Google Maps search URL (e.g., 'https://www.google.com/maps/search/restaurants/@52.5190603,13.388574,13z/')

## `placeIds` (type: `array`):

Direct Google Maps Place IDs or URLs to scrape (paid add-on feature)

## `categories` (type: `array`):

Filter results by specific categories. Use with caution - must include all synonyms to avoid false negatives.

## `maxResults` (type: `integer`):

Maximum number of places to scrape (default: unlimited, but Google Maps limits to ~120 per area without location input)

## `includeImages` (type: `boolean`):

Extract list of images for each place

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

Extract reviews for each place

## `includeAmenities` (type: `boolean`):

Extract detailed characteristics and amenities

## `includePopularTimes` (type: `boolean`):

Extract popular times histogram and live occupancy data

## `includeMenu` (type: `boolean`):

Extract menu information if available

## `includeQuestionsAnswers` (type: `boolean`):

Extract customer questions and answers

## `enrichWithContactDetails` (type: `boolean`):

Extract company email, phone, and social media from website (paid add-on)

## `enrichWithLeads` (type: `boolean`):

Enrich with full name, work email, phone, job title, LinkedIn (paid add-on)

## `enrichWithSocialMedia` (type: `boolean`):

Extract detailed profile data for Facebook, Instagram, YouTube, TikTok, Twitter (paid add-on)

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

Proxy configuration to avoid blocking

## Actor input object example

```json
{
  "searchTerms": [],
  "placeIds": [],
  "categories": [],
  "maxResults": 0,
  "includeImages": false,
  "includeReviews": false,
  "includeAmenities": false,
  "includePopularTimes": false,
  "includeMenu": false,
  "includeQuestionsAnswers": false,
  "enrichWithContactDetails": false,
  "enrichWithLeads": false,
  "enrichWithSocialMedia": false
}
```

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("surigami/google-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 = {}

# Run the Actor and wait for it to finish
run = client.actor("surigami/google-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 '{}' |
apify call surigami/google-maps-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Google Maps Scraper",
        "description": "📍 Google Maps Scraper\nGoogle Maps Scraper lets you extract business data from Google Maps.",
        "version": "0.0",
        "x-build-id": "2txIgKE2FLciFxkdU"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/surigami~google-maps-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-surigami-google-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/surigami~google-maps-scraper/runs": {
            "post": {
                "operationId": "runs-sync-surigami-google-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/surigami~google-maps-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-surigami-google-maps-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "searchTerms": {
                        "title": "Search Terms",
                        "type": "array",
                        "description": "List of search terms to find places on Google Maps (e.g., ['restaurant', 'bar', 'cafe']). Using multiple distinct search terms can increase results.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "Location to search in (e.g., 'New York, NY', 'Berlin, Germany', or coordinates like '52.5200,13.4050')"
                    },
                    "customSearchArea": {
                        "title": "Custom Search Area (GeoJSON)",
                        "type": "object",
                        "description": "Custom search area using GeoJSON format. Supports Polygon, MultiPolygon, and Point (circle) types. Note: coordinates use [longitude, latitude] order. For Point type, include 'radiusKm' property (default: 5km). Example: {\"type\":\"Polygon\",\"coordinates\":[[[-0.322813,51.597165],[-0.31499,51.388023],[0.060493,51.389199],[0.051936,51.60036],[-0.322813,51.597165]]]}"
                    },
                    "startUrl": {
                        "title": "Google Maps URL",
                        "type": "string",
                        "description": "Direct Google Maps search URL (e.g., 'https://www.google.com/maps/search/restaurants/@52.5190603,13.388574,13z/')"
                    },
                    "placeIds": {
                        "title": "Place IDs or URLs",
                        "type": "array",
                        "description": "Direct Google Maps Place IDs or URLs to scrape (paid add-on feature)",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "categories": {
                        "title": "Categories",
                        "type": "array",
                        "description": "Filter results by specific categories. Use with caution - must include all synonyms to avoid false negatives.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of places to scrape (default: unlimited, but Google Maps limits to ~120 per area without location input)",
                        "default": 0
                    },
                    "includeImages": {
                        "title": "Include Images",
                        "type": "boolean",
                        "description": "Extract list of images for each place",
                        "default": false
                    },
                    "includeReviews": {
                        "title": "Include Reviews",
                        "type": "boolean",
                        "description": "Extract reviews for each place",
                        "default": false
                    },
                    "includeAmenities": {
                        "title": "Include Amenities",
                        "type": "boolean",
                        "description": "Extract detailed characteristics and amenities",
                        "default": false
                    },
                    "includePopularTimes": {
                        "title": "Include Popular Times",
                        "type": "boolean",
                        "description": "Extract popular times histogram and live occupancy data",
                        "default": false
                    },
                    "includeMenu": {
                        "title": "Include Menu",
                        "type": "boolean",
                        "description": "Extract menu information if available",
                        "default": false
                    },
                    "includeQuestionsAnswers": {
                        "title": "Include Q&A",
                        "type": "boolean",
                        "description": "Extract customer questions and answers",
                        "default": false
                    },
                    "enrichWithContactDetails": {
                        "title": "Enrich with Contact Details",
                        "type": "boolean",
                        "description": "Extract company email, phone, and social media from website (paid add-on)",
                        "default": false
                    },
                    "enrichWithLeads": {
                        "title": "Enrich with Business Leads",
                        "type": "boolean",
                        "description": "Enrich with full name, work email, phone, job title, LinkedIn (paid add-on)",
                        "default": false
                    },
                    "enrichWithSocialMedia": {
                        "title": "Enrich with Social Media",
                        "type": "boolean",
                        "description": "Extract detailed profile data for Facebook, Instagram, YouTube, TikTok, Twitter (paid add-on)",
                        "default": false
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Proxy configuration to avoid blocking"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```