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

📍 Google Maps Extractor (google-maps-extractor) scrapes business data from Google Maps — names, addresses, phones, websites, ratings, reviews & hours. 🔎 Export to CSV/Excel or API. ⚡ Ideal for lead gen, local SEO, market research & competitor analysis. 🚀 Fast, accurate, easy to use.

- **URL**: https://apify.com/scraperforge/google-maps-extractor.md
- **Developed by:** [ScraperForge](https://apify.com/scraperforge) (community)
- **Categories:** Automation, AI, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$19.99/month + usage

To use this Actor, you pay a monthly rental fee to the developer. The rent is subtracted from your prepaid usage every month after the free trial period.You also pay for the Apify platform usage, which gets cheaper the higher Apify subscription plan you have.

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

## 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 is a production-ready Google Maps scraper that automates bulk business discovery from Google Maps for lead generation, local SEO, and market research. It combines grid-based coverage with an automatic proxy ladder to overcome blocks and returns clean, deduplicated records. Built for marketers, developers, data analysts, and researchers, this Google Maps data extractor scales workflows from quick lookups to repeatable pipelines that export Google Maps data to CSV or JSON at speed. 🚀

### What data / output can you get?

Below are the real output fields this Google Maps business listing scraper produces in the Apify Dataset and the final JSON file. Each row is a structured place record, ideal for enrichment and analysis.

| Data type        | Description                                                      | Example value |
| ---              | ---                                                              | --- |
| name             | Business name                                                    | “Sample Coffee” |
| website          | Cleaned website URL (Google redirect removed)                    | “https://samplecoffee.com” |
| avg_rating       | Average rating                                                   | 4.6 |
| total_reviews    | Total review count                                               | 128 |
| street_address   | Street line                                                      | “123 Main St” |
| city             | City                                                             | “New York” |
| state            | State/region                                                     | “NY” |
| zip              | Postal/ZIP code                                                  | “10001” |
| country_code     | ISO-like country code                                            | “US” |
| full_address     | Concatenated full address                                        | “123 Main St New York NY 10001 US” |
| tags             | Categories/tags                                                  | [“Coffee shop”] |
| notes            | Additional notes parsed from Maps (if present)                   | null |
| place_id         | Unique Google place identifier                                   | “abcd1234” |
| phone            | Phone number                                                     | “+1 212-555-0100” |
| lat              | Latitude                                                         | 40.7500 |
| long             | Longitude                                                        | -73.9900 |
| hours            | Opening hours array (best-effort; day/range/24h hints)           | [{“day”: “Monday”, “hours”: “8 AM–6 PM”, …}] |
| success          | Extraction status flag                                           | true |

Notes:
- Exports are available from the Apify Dataset in JSON or CSV, and a final merged list is saved as maps.json in the Key-Value Store for easy retrieval.
- When review fetching is enabled, the actor can also push review records for each place (see Output Format below for details).

### Key features

- ⚡️ Fast, reliable harvesting
  Automatic retries with a proxy escalation ladder (direct → datacenter → residential) to keep your Google Maps scraping tool running when rate-limited or blocked.

- 🧭 Grid-based coverage
  Viewport grids ensure your Google Places scraper doesn’t miss pockets of businesses across a city or region.

- 🧹 Clean, deduplicated output
  Results are deduplicated by place_id for high-quality datasets ready for CRM or analytics pipelines.

- 📦 Structured exports
  Write to the Apify Dataset (JSON/CSV) and a final merged maps.json file — perfect for “Export Google Maps data to CSV” or opening in Excel.

- 🔌 Developer-friendly
  Runs as an Apify actor with clear logs and consistent output fields — easy to integrate with your data stack or API workflows.

- 🛡️ Production-grade resilience
  Built for reliability with informative logs: grid progress, proxy switches, and optional review progress.

### How to use Google Maps Extractor – step by step

1. Sign in to Apify
   Create or log in to your Apify account.

2. Open the actor
   Find “Google Maps Extractor” in the Apify Store or open it from your console.

3. Add your inputs
   Provide a mix of:
   - locations: e.g., “New York”, “Florida”
   - keywords: e.g., “coffee shops”, “plumbers”
   - urls: paste direct Google Maps search URLs (optional; supports bulk)

4. Set a results cap
   Use maxResults to control how many businesses you want across the whole run.

5. Configure proxy (optional)
   Leave Proxy Configuration blank to start direct; the actor auto‑falls back to datacenter and then residential when blocked.

6. Run the actor
   Click Start and monitor logs for viewport coverage, grid progress, and any proxy escalation.

7. Download results
   - Dataset: export as JSON or CSV
   - Key-Value Store: download maps.json, the final merged list

Pro tip: Schedule runs and pull results via the Apify API to build a repeatable Google Maps leads generator or enrichment pipeline.

### Use cases

| Use case name | Description |
| --- | --- |
| Sales lead generation (local) | Build targeted B2C/B2B lead lists by city and category with a Google Maps lead extractor and export to CSV for outreach. |
| Local SEO audits | Collect ratings, review counts, and NAP data to benchmark visibility for Google Business Profile optimization. |
| Competitive scans | Map competitor density and quality signals across regions with a Google Maps scraper for strategic planning. |
| Franchise territory planning | Assess market gaps by extracting business counts and categories across multiple viewports. |
| Data enrichment (API pipeline) | Append phone numbers, addresses, and coordinates to existing records in your data warehouse. |
| Academic & market research | Analyze local market structure using a reliable Google Maps data extraction tool. |
| Operations & site selection | Shortlist locations with proximity and density signals using structured business listing data. |

### Why choose Google Maps Extractor?

This Google Maps business listing scraper focuses on precision and reliability for at-scale extraction.

- 🎯 Accurate, structured fields: Clean website URLs, deduped by place_id, and consistent address/geo fields.
- 🌍 Broad coverage: Grid-based approach reduces blind spots for city-wide or multi-region scans.
- 📈 Scales to bulk: Mix locations, keywords, and URLs in one run to cover large areas quickly.
- 👨‍💻 Developer-friendly: Runs on Apify with consistent output fields suited for pipelines and APIs.
- 🛡️ Robust against blocks: Automatic proxy escalation and retries keep results flowing.
- 💸 Cost-effective alternative: More stable than browser extensions and other unstable tools.
- 🔗 Easy exports: Pull datasets as JSON/CSV and consume the final maps.json for downstream apps.

In short, a reliable Google Maps scraper vs. extensions: production-grade stability, cleaner outputs, and automation-readiness.

### Is it legal / ethical to use Google Maps Extractor?

Yes — when used responsibly. This Google Maps data extractor retrieves publicly available information from Google Maps pages and does not access private or authenticated data.

Guidelines for compliant use:
- Only use data from public pages and respect platform terms.
- Comply with applicable regulations (e.g., GDPR, CCPA).
- Avoid misuse (e.g., spam). You are responsible for how the data is used.
- Consult your legal team for edge cases or jurisdiction-specific considerations.

### Input parameters & output format

Example JSON input
```json
{
  "locations": ["New York"],
  "keywords": ["coffee shops"],
  "urls": [],
  "maxResults": 20,
  "proxyConfiguration": { "useApifyProxy": false }
}
````

Input fields (from schema)

- locations (array)
  - Description: List of location names (e.g., New York, Florida).
  - Default: none
  - Required: No
- keywords (array)
  - Description: Search keywords or user-specified terms (supports bulk).
  - Default: none
  - Required: Yes
- urls (array)
  - Description: Direct Google Maps search URLs (optional, supports bulk).
  - Default: \[]
  - Required: No
- maxResults (integer)
  - Description: Maximum number of places to return (cap across all searches).
  - Default: 20 (min 1, max 10000)
  - Required: No
- proxyConfiguration (object)
  - Description: Default is direct (no proxy). Actor auto‑falls back to datacenter → residential if blocked.
  - Default: { "useApifyProxy": false }
  - Required: No

Example dataset item (place record)

```json
{
  "name": "Sample Coffee",
  "website": "https://samplecoffee.com",
  "avg_rating": 4.6,
  "total_reviews": 128,
  "street_address": "123 Main St",
  "city": "New York",
  "state": "NY",
  "zip": "10001",
  "country_code": "US",
  "full_address": "123 Main St New York NY 10001 US",
  "tags": ["Coffee shop"],
  "notes": null,
  "place_id": "abcd1234",
  "phone": "+1 212-555-0100",
  "lat": 40.75,
  "long": -73.99,
  "hours": [],
  "success": true
}
```

Additional dataset entries (reviews, when enabled)

```json
{
  "place_id": "abcd1234",
  "reviews": [
    {
      "author_name": "Jane Doe",
      "author_url": "https://maps.google.com/user/123",
      "rating": 5,
      "text": "Great espresso and friendly staff!",
      "time": 1704067200,
      "relative_time": "2 months ago",
      "author_reviews_count": 14,
      "author_photo": "https://example.com/photo.jpg",
      "likes": 3
    }
  ],
  "review_count": 1
}
```

Also saved:

- Key-Value Store: maps.json (final merged list of place records)

### FAQ

#### Does the Google Maps Extractor need login or cookies?

No. It works on publicly available Google Maps data without requiring login or cookies.

#### Can I mix locations, keywords, and direct URLs in one run?

Yes. You can provide any combination of locations, keywords, and Google Maps URLs to drive coverage in a single run.

#### How many results can I fetch?

You control the cap with maxResults. The actor stops early when it reaches the configured limit across all searches.

#### What if Google rate-limits or blocks my requests?

The actor automatically escalates from a direct connection to datacenter and then residential proxies with retries, logging each change so you can track progress.

#### What output formats are supported?

You can export results from the Apify Dataset as JSON or CSV. A final merged JSON file (maps.json) is also written to the Key-Value Store.

#### Does it extract phone numbers and emails?

It extracts phone numbers when available. Email addresses are not part of the output fields; this is not a Google Maps email extractor.

#### Will it capture business hours and reviews?

Hours are captured on a best‑effort basis. Review records can be appended and pushed to the dataset when review fetching is enabled.

#### Is this suitable for lead generation and local SEO?

Yes. It functions as a Google Business Profile extractor and Google Maps leads generator, returning key contact and quality signals for prospecting and SEO audits.

### Closing thoughts

Google Maps Extractor is built to turn Google Maps into structured, analysis-ready business data. With grid-based coverage, automatic proxy fallback, and clean exports, it’s a dependable Google Maps scraping tool for sales, marketing, research, and operations teams. Developers can automate end‑to‑end via the Apify platform and API, pulling JSON/CSV or the final maps.json into their data stacks. Start extracting smarter, scalable insights from Google Maps today.

# Actor input Schema

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

🏙️ Examples: *New York*, *Texas*, *Downtown Chicago* — mix and match for bulk coverage.

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

☕ Describe the businesses or places you care about — *coffee shops*, *dentists*, *coworking*, *hotels near airport*, and so on. 📝 Add many keywords to multiply your searches!

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

🌐 Bulk-friendly list of map links. ✨ Great when you’ve bookmarked exact searches.

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

🔢 Total unique places across **all** locations, keywords, and URLs (duplicates are merged automatically). ✨ Default is friendly for quick tests; raise it for big lists.

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

🎛️ Optional Apify Proxy — leave off for simple runs; turn on for heavier jobs or picky networks.

## Actor input object example

```json
{
  "locations": [
    "New York"
  ],
  "keywords": [
    "coffee shops"
  ],
  "urls": [],
  "maxResults": 20,
  "proxyConfiguration": {
    "useApifyProxy": 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 = {
    "locations": [
        "New York"
    ],
    "keywords": [
        "coffee shops"
    ],
    "urls": [],
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scraperforge/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 = {
    "locations": ["New York"],
    "keywords": ["coffee shops"],
    "urls": [],
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("scraperforge/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 '{
  "locations": [
    "New York"
  ],
  "keywords": [
    "coffee shops"
  ],
  "urls": [],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call scraperforge/google-maps-extractor --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Google Maps Extractor",
        "description": "📍 Google Maps Extractor (google-maps-extractor) scrapes business data from Google Maps — names, addresses, phones, websites, ratings, reviews & hours. 🔎 Export to CSV/Excel or API. ⚡ Ideal for lead gen, local SEO, market research & competitor analysis. 🚀 Fast, accurate, easy to use.",
        "version": "0.1",
        "x-build-id": "nrykyOLBJOFbLiSjI"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scraperforge~google-maps-extractor/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scraperforge-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/scraperforge~google-maps-extractor/runs": {
            "post": {
                "operationId": "runs-sync-scraperforge-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/scraperforge~google-maps-extractor/run-sync": {
            "post": {
                "operationId": "run-sync-scraperforge-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",
                "required": [
                    "keywords"
                ],
                "properties": {
                    "locations": {
                        "title": "📍 Cities, regions, or neighborhoods",
                        "type": "array",
                        "description": "🏙️ Examples: *New York*, *Texas*, *Downtown Chicago* — mix and match for bulk coverage.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "keywords": {
                        "title": "🔎 What to find (keywords)",
                        "type": "array",
                        "description": "☕ Describe the businesses or places you care about — *coffee shops*, *dentists*, *coworking*, *hotels near airport*, and so on. 📝 Add many keywords to multiply your searches!",
                        "items": {
                            "type": "string"
                        }
                    },
                    "urls": {
                        "title": "🔗 Optional: Google Maps links",
                        "type": "array",
                        "description": "🌐 Bulk-friendly list of map links. ✨ Great when you’ve bookmarked exact searches.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxResults": {
                        "title": "🎯 How many places to collect",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "🔢 Total unique places across **all** locations, keywords, and URLs (duplicates are merged automatically). ✨ Default is friendly for quick tests; raise it for big lists.",
                        "default": 20
                    },
                    "proxyConfiguration": {
                        "title": "🌐 Connection & reliability",
                        "type": "object",
                        "description": "🎛️ Optional Apify Proxy — leave off for simple runs; turn on for heavier jobs or picky networks."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
