# Google Maps Local SEO Leads Scraper (`paduchak/google-maps-local-seo-leads-scraper`) Actor

Track how businesses rank on Google Maps for specific keywords and locations, useful for local SEO audits, competitor tracking, and agency reporting.

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

## Pricing

from $2.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

## Google Maps Local SEO Rank Tracker

Track where target businesses rank in public Google Maps search results for multiple keywords and locations. The Actor combines every keyword with every location, opens Google Maps search results, extracts listing details, and marks rows that match your target business names or website domains.

No Google Maps API key is required.

### What You Can Use It For

- Monitor local SEO visibility across cities, neighborhoods, or service areas
- Track competitor and client positions for important commercial keywords
- Export keyword/location ranking snapshots for reporting
- Audit whether a brand appears in the Google Maps local pack result list

### Input

Configure the Actor with keyword and location lists:

```json
{
  "keywords": ["coffee shop", "cafe"],
  "locations": ["London", "Manchester"],
  "targetBusinessNames": ["Example Coffee"],
  "targetDomains": ["example.com"],
  "maxResults": 20,
  "language": "en",
  "country": "uk",
  "apifyProxy": true,
  "apifyProxyGroups": ["RESIDENTIAL"],
  "proxyCountries": [],
  "proxyUrls": [],
  "proxySessionRetries": 2,
  "adaptiveThrottle": true
}
````

| Field | Type | Default | Description |
|---|---|---|---|
| `keywords` | `string[]` | required | Search terms to track, such as `coffee shop`, `dentist`, or `estate agent`. |
| `locations` | `string[]` | required | Locations to combine with every keyword, such as `London`, `Manchester`, or `Austin TX`. |
| `targetBusinessNames` | `string[]` | `[]` | Business names to match against Google Maps result names. Matching is case-insensitive and tolerant of punctuation. |
| `targetDomains` | `string[]` | `[]` | Website domains to match against listing websites. Values can be plain domains or full URLs. |
| `maxResults` | `number` | `50` | Maximum number of results to collect per keyword/location search. |
| `language` | `string` | `"en"` | Preferred Google Maps interface language. |
| `country` | `string` | - | Optional country hint, such as `uk`, `us`, `de`, or `fr`. |
| `apifyProxy` | `boolean` | `true` | Enable Apify Proxy for more reliable scraping. |
| `apifyProxyGroups` | `string[]` | `["RESIDENTIAL"]` | Proxy pools: `RESIDENTIAL`, `DATACENTER`, `SERP`. |
| `proxyCountries` | `string[]` | `[]` | Route through specific countries using ISO 2-letter country codes. |
| `proxyUrls` | `string[]` | `[]` | Custom proxy URLs. If provided, these override Apify Proxy. |
| `proxySessionRetries` | `number` | `2` | Number of retryable browser sessions per search after blocking, empty results, or navigation failures. |
| `adaptiveThrottle` | `boolean` | `true` | Automatically slows down when Google Maps loads slowly, returns sparse results, or shows blocking signals. |
| `baseThrottleDelayMs` | `number` | `250` | Starting adaptive delay before business-card actions. |
| `maxThrottleDelayMs` | `number` | `10000` | Maximum adaptive delay. |
| `slowLoadThresholdMs` | `number` | `12000` | Load duration that causes the Actor to increase adaptive delay. |

Each source query is built as:

```text
{keyword} in {location}
```

### Output

Each Google Maps result is saved to the default Apify Dataset as one rank row.

```json
{
  "keyword": "coffee shop",
  "location": "London",
  "rankPosition": 3,
  "businessName": "Example Coffee",
  "category": "Coffee shop",
  "address": "10 Example Street, London",
  "website": "https://example.com/",
  "googleMapsUrl": "https://www.google.com/maps/place/Example+Coffee/...",
  "placeId": "0x487...",
  "latitude": 51.5072,
  "longitude": -0.1276,
  "isTargetMatch": true,
  "matchedTarget": "domain:example.com",
  "sourceQuery": "coffee shop in London",
  "scrapedAt": "2026-05-13T12:00:00.000Z"
}
```

The Actor outputs these fields:

`keyword`, `location`, `rankPosition`, `businessName`, `category`, `address`, `website`, `googleMapsUrl`, `placeId`, `latitude`, `longitude`, `isTargetMatch`, `matchedTarget`, `sourceQuery`, and `scrapedAt`.

Some listing fields may be missing when they are not publicly visible on Google Maps.

### How Matching Works

`targetBusinessNames` are matched against the extracted business name using normalized case, whitespace, punctuation, and ampersands. `targetDomains` are normalized to hostnames, so `https://www.example.com/page` and `example.com` match the same target domain.

`matchedTarget` is prefixed with `businessName:` or `domain:` so you can see which target rule matched.

### Reliability Notes

Google Maps can show captcha or automated-traffic blocking, especially on repeated runs, high result counts, or datacenter IPs. The Actor detects common blocking pages and fails clearly instead of silently saving bad data.

For larger production runs:

- Enable `apifyProxy`
- Use residential or geographically relevant proxy settings
- Keep `maxResults` moderate for each keyword/location pair
- Increase `proxySessionRetries` and `maxThrottleDelayMs` for long batches
- Review output quality before scaling to many searches

### Legal Disclaimer

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

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

# Actor input Schema

## `keywords` (type: `array`):

Search terms to track, for example: coffee shop, emergency dentist, estate agent.

## `locations` (type: `array`):

Locations to combine with every keyword, for example: London, Manchester, Austin TX.

## `targetBusinessNames` (type: `array`):

Business names to match against Google Maps result names.

## `targetDomains` (type: `array`):

Website domains to match against listing websites, for example: example.com.

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

Maximum number of Google Maps results to save for each keyword/location search.

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

Google interface language passed as the hl URL parameter.

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

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

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

Enable Apify Proxy for more reliable scraping.

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

Proxy pools: RESIDENTIAL, DATACENTER, SERP.

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

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

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

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

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

How many times to retry each Google Maps search with a fresh proxy session after blocking, empty results, or navigation failures.

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

Automatically increases delays when Google Maps loads slowly, returns sparse results, or shows blocking signals.

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

Starting delay before business-card actions. The adaptive throttle can increase from this value.

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

Upper limit for adaptive delays.

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

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

## Actor input object example

```json
{
  "keywords": [
    "coffee shop"
  ],
  "locations": [
    "London"
  ],
  "targetBusinessNames": [
    "Example Coffee"
  ],
  "targetDomains": [
    "example.com"
  ],
  "maxResults": 20,
  "language": "en",
  "apifyProxy": true,
  "apifyProxyGroups": [
    "RESIDENTIAL"
  ],
  "proxyCountries": [],
  "proxyUrls": [],
  "proxySessionRetries": 2,
  "adaptiveThrottle": true,
  "baseThrottleDelayMs": 250,
  "maxThrottleDelayMs": 10000,
  "slowLoadThresholdMs": 12000
}
```

# Actor output Schema

## `rankResults` (type: `string`):

Keyword/location rank rows scraped from public Google Maps search results.

# 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 = {
    "keywords": [
        "coffee shop"
    ],
    "locations": [
        "London"
    ],
    "targetBusinessNames": [
        "Example Coffee"
    ],
    "targetDomains": [
        "example.com"
    ],
    "apifyProxyGroups": [
        "RESIDENTIAL"
    ],
    "proxyCountries": [],
    "proxyUrls": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("paduchak/google-maps-local-seo-leads-scraper").call(input);

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

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

```

## Python example

```python
from apify_client import ApifyClient

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

# Prepare the Actor input
run_input = {
    "keywords": ["coffee shop"],
    "locations": ["London"],
    "targetBusinessNames": ["Example Coffee"],
    "targetDomains": ["example.com"],
    "apifyProxyGroups": ["RESIDENTIAL"],
    "proxyCountries": [],
    "proxyUrls": [],
}

# Run the Actor and wait for it to finish
run = client.actor("paduchak/google-maps-local-seo-leads-scraper").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "keywords": [
    "coffee shop"
  ],
  "locations": [
    "London"
  ],
  "targetBusinessNames": [
    "Example Coffee"
  ],
  "targetDomains": [
    "example.com"
  ],
  "apifyProxyGroups": [
    "RESIDENTIAL"
  ],
  "proxyCountries": [],
  "proxyUrls": []
}' |
apify call paduchak/google-maps-local-seo-leads-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Google Maps Local SEO Leads Scraper",
        "description": "Track how businesses rank on Google Maps for specific keywords and locations, useful for local SEO audits, competitor tracking, and agency reporting.",
        "version": "0.0",
        "x-build-id": "OftxjA5ejO23wjdfH"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/paduchak~google-maps-local-seo-leads-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-paduchak-google-maps-local-seo-leads-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/paduchak~google-maps-local-seo-leads-scraper/runs": {
            "post": {
                "operationId": "runs-sync-paduchak-google-maps-local-seo-leads-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/paduchak~google-maps-local-seo-leads-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-paduchak-google-maps-local-seo-leads-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "keywords",
                    "locations"
                ],
                "properties": {
                    "keywords": {
                        "title": "Keywords",
                        "type": "array",
                        "description": "Search terms to track, for example: coffee shop, emergency dentist, estate agent.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "locations": {
                        "title": "Locations",
                        "type": "array",
                        "description": "Locations to combine with every keyword, for example: London, Manchester, Austin TX.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "targetBusinessNames": {
                        "title": "Target Business Names",
                        "type": "array",
                        "description": "Business names to match against Google Maps result names.",
                        "items": {
                            "type": "string"
                        },
                        "default": []
                    },
                    "targetDomains": {
                        "title": "Target Domains",
                        "type": "array",
                        "description": "Website domains to match against listing websites, for example: example.com.",
                        "items": {
                            "type": "string"
                        },
                        "default": []
                    },
                    "maxResults": {
                        "title": "Maximum Results Per Search",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum number of Google Maps results to save for each keyword/location search.",
                        "default": 20
                    },
                    "language": {
                        "title": "Language",
                        "type": "string",
                        "description": "Google interface language passed as the hl URL parameter.",
                        "default": "en"
                    },
                    "country": {
                        "title": "Country",
                        "type": "string",
                        "description": "Optional country hint passed as the gl URL parameter, for example uk, us, de, fr."
                    },
                    "apifyProxy": {
                        "title": "Enable Apify Proxy",
                        "type": "boolean",
                        "description": "Enable Apify Proxy for more reliable scraping.",
                        "default": true
                    },
                    "apifyProxyGroups": {
                        "title": "Apify Proxy Groups",
                        "type": "array",
                        "description": "Proxy pools: RESIDENTIAL, DATACENTER, SERP.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "RESIDENTIAL",
                                "DATACENTER",
                                "SERP"
                            ]
                        },
                        "default": [
                            "RESIDENTIAL"
                        ]
                    },
                    "proxyCountries": {
                        "title": "Proxy Countries",
                        "type": "array",
                        "description": "Route through specific countries using ISO 2-letter country codes.",
                        "items": {
                            "type": "string"
                        },
                        "default": []
                    },
                    "proxyUrls": {
                        "title": "Custom Proxy URLs",
                        "type": "array",
                        "description": "Custom proxy URLs. If provided, these override Apify Proxy.",
                        "items": {
                            "type": "string"
                        },
                        "default": []
                    },
                    "proxySessionRetries": {
                        "title": "Proxy Session Retries",
                        "minimum": 0,
                        "maximum": 5,
                        "type": "integer",
                        "description": "How many times to retry each Google Maps search with a fresh proxy session after blocking, empty results, or navigation failures.",
                        "default": 2
                    },
                    "adaptiveThrottle": {
                        "title": "Adaptive Throttle",
                        "type": "boolean",
                        "description": "Automatically increases delays when Google Maps loads slowly, returns sparse results, or shows blocking signals.",
                        "default": true
                    },
                    "baseThrottleDelayMs": {
                        "title": "Base Throttle Delay (ms)",
                        "minimum": 0,
                        "maximum": 60000,
                        "type": "integer",
                        "description": "Starting delay before business-card actions. The adaptive throttle can increase from this value.",
                        "default": 250
                    },
                    "maxThrottleDelayMs": {
                        "title": "Max Throttle Delay (ms)",
                        "minimum": 0,
                        "maximum": 120000,
                        "type": "integer",
                        "description": "Upper limit for adaptive delays.",
                        "default": 10000
                    },
                    "slowLoadThresholdMs": {
                        "title": "Slow Load Threshold (ms)",
                        "minimum": 1000,
                        "maximum": 120000,
                        "type": "integer",
                        "description": "Load duration that causes adaptive throttling to slow down future actions.",
                        "default": 12000
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
