# Google Maps Extractor (`khadinakbar/google-maps-extractor`) Actor

Extract Google Maps places by keyword, location, or Maps URL. Returns names, categories, addresses, phones, websites, ratings, reviews, coordinates, and source URLs. MCP optimized for AI agents.

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

## Pricing

from $5.00 / 1,000 place scrapeds

This Actor is paid per event. 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 Extractor

Google Maps Extractor scrapes structured place and business data from Google Maps. Enter a search query plus location, or paste Google Maps search/place URLs, and get one clean dataset row per place with name, category, address, phone, website, rating, review count, coordinates, Maps URL, and source query.

It is built for local SEO agencies, B2B sales teams, market researchers, data enrichment workflows, and AI agents that need a predictable Google Maps data tool. The actor is MCP optimized, perfect for SEO and AI agents, and priced with one clear event: $0.005 per place returned.

### What It Extracts

| Field | Description |
|---|---|
| `business_name` | Place or business name shown on Google Maps |
| `category` | Primary Google Maps category |
| `full_address` | Full street address when available |
| `phone` | Google Maps phone number |
| `website` | Website listed on the place profile |
| `rating` | Google rating from 1.0 to 5.0 |
| `review_count` | Total Google review count |
| `latitude` / `longitude` | Coordinates parsed from the Maps URL |
| `google_maps_url` | Direct URL to the place profile |
| `place_id` | Google Maps place identifier or feature token |
| `website_email` | Optional public email from website scan, when enabled |
| `facebook_url`, `instagram_url`, `linkedin_url`, `x_url` | Optional public social links from website scan, when enabled |
| `is_permanently_closed` | Google Maps permanent closure signal |
| `scraped_at` | ISO timestamp for the scrape |
| `source_query` | Search query, location, or URL that produced the record |

### When To Use It

Use this actor when you need a structured list of businesses or places from Google Maps:

- Build local business datasets for sales research.
- Compare local competitors by rating, category, review count, and website.
- Feed a CRM, spreadsheet, or enrichment pipeline with Maps place data.
- Audit local SEO coverage for a city, niche, or service area.
- Let Claude, ChatGPT, or another AI agent gather place records from a simple query.

Do not use this actor for Google Maps reviews. Use a reviews-specific actor when you need full review text, reviewer names, owner replies, or review pagination. Do not use it as a deep email verifier. The optional website contact scan is lightweight and only returns public links found on listed business websites.

### Input Examples

Search by keyword and location:

```json
{
  "searchQuery": "dentists",
  "location": "Miami, FL",
  "maxResults": 20,
  "minRating": 4,
  "skipClosedPlaces": true
}
````

Use a direct Google Maps URL:

```json
{
  "startUrls": [
    { "url": "https://www.google.com/maps/search/coffee+shops+Austin+TX" }
  ],
  "maxResults": 10
}
```

Optional website contact scan:

```json
{
  "searchQuery": "real estate agents",
  "location": "Austin, TX",
  "maxResults": 25,
  "includeWebsiteContacts": true
}
```

### Output Example

```json
{
  "business_name": "Relax and Smile Dental Care",
  "category": "Dentist",
  "full_address": "123 Ocean Dr, Miami, FL 33139, USA",
  "phone": "+1 305-555-0123",
  "website": "https://relaxandsmiledental.com",
  "rating": 4.7,
  "review_count": 238,
  "latitude": 25.7617,
  "longitude": -80.1918,
  "google_maps_url": "https://www.google.com/maps/place/...",
  "place_id": "0x88d9b6...",
  "website_email": null,
  "facebook_url": null,
  "instagram_url": null,
  "linkedin_url": null,
  "x_url": null,
  "is_permanently_closed": false,
  "scraped_at": "2026-06-12T12:33:20.286Z",
  "source_query": "dentists in Miami, FL"
}
```

### Pricing

This actor uses pay per event pricing.

| Event | Price | When Charged |
|---|---:|---|
| Actor start | $0.00005 | Once per run, scaled by memory |
| Place scraped | $0.005 | Once for each Google Maps place record returned |

Typical cost examples:

- 10 places: about $0.050 plus the tiny start event.
- 100 places: about $0.500 plus the tiny start event.
- 200 places: about $1.000 plus the tiny start event.

The actor logs the max possible event cost at run start. `maxResults` is both the output cap and the event-charge cap.

### Input Fields

| Field | Type | Default | Notes |
|---|---|---|---|
| `searchQuery` | string | `dentists` | Business type, keyword, or place search |
| `location` | string | `Miami, FL` | City, region, state, or country |
| `startUrls` | array | `[]` | Google Maps search/place URLs as an alternative input |
| `maxResults` | integer | `20` | Hard cap from 1 to 2000 |
| `minRating` | number | `0` | Keep only places at or above this rating |
| `skipClosedPlaces` | boolean | `true` | Skip permanently closed businesses |
| `includeWebsiteContacts` | boolean | `false` | Lightweight public website contact/social scan |
| `language` | string | `en` | Google Maps UI language |
| `countryCode` | string | `US` | Apify residential proxy country |

### Reliability Notes

Google Maps is a browser-rendered application and can behave differently by country, proxy, query, and layout version. This actor uses a real Chrome browser, Apify residential proxies, session persistence, consent cookies, retries, and a circuit breaker. It pushes records as soon as they are extracted, so partial output is preserved if Google Maps slows down or blocks a subset of requests.

The default input is intentionally small so Apify health checks and first-time users can get a fast successful run. For bulk coverage, split large jobs by city, postal code, neighborhood, or niche instead of asking one broad query to return everything.

### API Usage

Run with the Apify API:

```bash
curl "https://api.apify.com/v2/acts/khadinakbar~google-maps-extractor/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "searchQuery": "coffee shops",
    "location": "Austin, TX",
    "maxResults": 20
  }'
```

Results are available in the default dataset as JSON, CSV, Excel, XML, RSS, and HTML table exports. The `OUTPUT` key-value store record contains a machine-readable run summary for monitoring and AI agents.

### Related Actors

- `google-maps-leads-scraper` for a lead-scored Google Maps workflow.
- `google-maps-email-extractor` when the primary job is email-first prospecting.
- `google-maps-reviews-scraper` when the primary job is review text and owner replies.
- `bulk-website-contact-extractor` when you already have domains and only need website contacts.

### Legal And Compliance

This actor extracts publicly accessible data visible on Google Maps and optionally public links from listed business websites. You are responsible for using the output lawfully, respecting Google terms, privacy rules, anti-spam laws, and any sector-specific restrictions that apply to your use case. Do not use the output for harassment, spam, surveillance, or unlawful profiling. This actor is not affiliated with Google.

### Support

Open an issue on the Apify actor page with the run ID, input, and expected output. Include a small reproducible query whenever possible.

# Actor input Schema

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

Use this when you want to search Google Maps by business type or keyword. Accepted format is plain text such as 'dentists' or 'coffee shops'. Defaults to 'dentists' when no URLs are provided. This is not a Google Maps URL; paste URLs into Google Maps URLs.

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

Use this when the search query needs a city, region, or country. Accepted format is 'Miami, FL', 'London, UK', or another natural Maps location. Defaults to 'Miami, FL' for health checks. Leave empty only when every Google Maps URL already contains the target area.

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

Use this when you already have Google Maps search or place URLs. Accepted entries are objects with a url field, such as {'url':'https://www.google.com/maps/search/dentists+Miami'}. Defaults to an empty list. This is not for normal website URLs outside Google Maps.

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

Use this to cap how many Google Maps places are returned and charged. Accepted range is 1 to 2000; use 5-10 for testing and 50-200 for campaigns. Defaults to 20. This is not a page-count setting; one result means one place record.

## `minRating` (type: `number`):

Use this to keep only places at or above a Google rating threshold. Accepted values are 0 through 5, for example 4.2. Defaults to 0, which keeps unrated and rated places. This is not a review-count filter.

## `skipClosedPlaces` (type: `boolean`):

Use this to avoid businesses Google marks as permanently closed. Accepted value is true or false. Defaults to true for lead and market research freshness. This does not remove places that are only closed outside business hours.

## `includeWebsiteContacts` (type: `boolean`):

Use this when you want a lightweight scan of each listed website for public email and social profile links. Accepted value is true or false. Defaults to false to keep Google Maps extraction fast and predictable. This is not deep lead enrichment or email verification.

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

Use this to choose the Google Maps interface language for names, categories, and addresses. Accepted examples include 'en', 'es', 'fr', 'de', and 'ja'. Defaults to 'en'. This does not translate data after extraction.

## `countryCode` (type: `string`):

Use this to route the browser through an Apify residential proxy in the target country. Accepted format is a two-letter ISO code such as 'US', 'GB', or 'DE'. Defaults to 'US'. This is not a location filter; use Location for the search area.

## Actor input object example

```json
{
  "searchQuery": "coffee shops",
  "location": "Austin, TX",
  "startUrls": [],
  "maxResults": 20,
  "minRating": 0,
  "skipClosedPlaces": true,
  "includeWebsiteContacts": false,
  "language": "en",
  "countryCode": "US"
}
```

# Actor output Schema

## `results` (type: `string`):

Dataset of places and business contact fields scraped from Google Maps.

## `summary` (type: `string`):

Summary JSON with places scraped, filtered places, runtime, and warnings.

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "searchQuery": "dentists",
    "location": "Miami, FL",
    "startUrls": [],
    "maxResults": 20,
    "language": "en",
    "countryCode": "US"
};

// Run the Actor and wait for it to finish
const run = await client.actor("khadinakbar/google-maps-extractor").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "searchQuery": "dentists",
    "location": "Miami, FL",
    "startUrls": [],
    "maxResults": 20,
    "language": "en",
    "countryCode": "US",
}

# Run the Actor and wait for it to finish
run = client.actor("khadinakbar/google-maps-extractor").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "searchQuery": "dentists",
  "location": "Miami, FL",
  "startUrls": [],
  "maxResults": 20,
  "language": "en",
  "countryCode": "US"
}' |
apify call khadinakbar/google-maps-extractor --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Google Maps Extractor",
        "description": "Extract Google Maps places by keyword, location, or Maps URL. Returns names, categories, addresses, phones, websites, ratings, reviews, coordinates, and source URLs. MCP optimized for AI agents.",
        "version": "1.0",
        "x-build-id": "F2HxzqA2BMqJoI01s"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/khadinakbar~google-maps-extractor/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-khadinakbar-google-maps-extractor",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/khadinakbar~google-maps-extractor/runs": {
            "post": {
                "operationId": "runs-sync-khadinakbar-google-maps-extractor",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/khadinakbar~google-maps-extractor/run-sync": {
            "post": {
                "operationId": "run-sync-khadinakbar-google-maps-extractor",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "searchQuery": {
                        "title": "Search query",
                        "type": "string",
                        "description": "Use this when you want to search Google Maps by business type or keyword. Accepted format is plain text such as 'dentists' or 'coffee shops'. Defaults to 'dentists' when no URLs are provided. This is not a Google Maps URL; paste URLs into Google Maps URLs."
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "Use this when the search query needs a city, region, or country. Accepted format is 'Miami, FL', 'London, UK', or another natural Maps location. Defaults to 'Miami, FL' for health checks. Leave empty only when every Google Maps URL already contains the target area."
                    },
                    "startUrls": {
                        "title": "Google Maps URLs",
                        "type": "array",
                        "description": "Use this when you already have Google Maps search or place URLs. Accepted entries are objects with a url field, such as {'url':'https://www.google.com/maps/search/dentists+Miami'}. Defaults to an empty list. This is not for normal website URLs outside Google Maps.",
                        "default": [],
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxResults": {
                        "title": "Max places",
                        "minimum": 1,
                        "maximum": 2000,
                        "type": "integer",
                        "description": "Use this to cap how many Google Maps places are returned and charged. Accepted range is 1 to 2000; use 5-10 for testing and 50-200 for campaigns. Defaults to 20. This is not a page-count setting; one result means one place record.",
                        "default": 20
                    },
                    "minRating": {
                        "title": "Minimum rating",
                        "minimum": 0,
                        "maximum": 5,
                        "type": "number",
                        "description": "Use this to keep only places at or above a Google rating threshold. Accepted values are 0 through 5, for example 4.2. Defaults to 0, which keeps unrated and rated places. This is not a review-count filter.",
                        "default": 0
                    },
                    "skipClosedPlaces": {
                        "title": "Skip permanently closed places",
                        "type": "boolean",
                        "description": "Use this to avoid businesses Google marks as permanently closed. Accepted value is true or false. Defaults to true for lead and market research freshness. This does not remove places that are only closed outside business hours.",
                        "default": true
                    },
                    "includeWebsiteContacts": {
                        "title": "Scan business websites for contact links",
                        "type": "boolean",
                        "description": "Use this when you want a lightweight scan of each listed website for public email and social profile links. Accepted value is true or false. Defaults to false to keep Google Maps extraction fast and predictable. This is not deep lead enrichment or email verification.",
                        "default": false
                    },
                    "language": {
                        "title": "Language",
                        "enum": [
                            "en",
                            "es",
                            "fr",
                            "de",
                            "it",
                            "pt",
                            "nl",
                            "pl",
                            "ru",
                            "ja",
                            "ko",
                            "zh-CN",
                            "ar",
                            "tr",
                            "hi"
                        ],
                        "type": "string",
                        "description": "Use this to choose the Google Maps interface language for names, categories, and addresses. Accepted examples include 'en', 'es', 'fr', 'de', and 'ja'. Defaults to 'en'. This does not translate data after extraction.",
                        "default": "en"
                    },
                    "countryCode": {
                        "title": "Proxy country",
                        "type": "string",
                        "description": "Use this to route the browser through an Apify residential proxy in the target country. Accepted format is a two-letter ISO code such as 'US', 'GB', or 'DE'. Defaults to 'US'. This is not a location filter; use Location for the search area.",
                        "default": "US"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
