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

Extract business data from Google Maps with precision 📍🏢 Scrape names, addresses, phone numbers, ratings, reviews, websites, and more from any location search. Perfect for lead generation, local SEO, competitor research, and market analysis. Scale your data collection effortlessly 🚀

- **URL**: https://apify.com/scrapebase/google-maps-scraper.md
- **Developed by:** [ScrapeBase](https://apify.com/scrapebase) (community)
- **Categories:** Lead generation, SEO tools, Automation
- **Stats:** 3 total users, 0 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 Scraper

Google Maps Scraper is a production-ready Google Maps data extractor that collects structured business details from public Google Maps search results. It solves the pain of manual copy-paste and incomplete lead lists by automating extraction of names, addresses, ratings, phones, hours, and more — making it a powerful Google Maps business listings scraper and Google Places scraper for lead generation, local SEO, and market analysis. Built for marketers, developers, data analysts, and researchers, it scales from quick lookups to city-wide scans with reliability and precision.

### What data / output can you get?

Below are real fields returned in the dataset and final maps.json output. Examples reflect typical values you’ll see:

| Data type        | Description                                           | Example value |
| ---              | ---                                                   | --- |
| name             | Place or business name                                | “Sample Coffee” |
| website          | Cleaned external website URL                          | “https://samplecoffee.com” |
| avg_rating       | Average Google rating (numeric)                       | 4.6 |
| total_reviews    | Total number of Google reviews (numeric)              | 128 |
| street_address   | Street line                                           | “123 Main St” |
| city             | City                                                  | “New York” |
| state            | State/region                                          | “NY” |
| zip              | Postal/ZIP code                                       | “10001” |
| country_code     | Two-letter country code                               | “US” |
| full_address     | Concatenated address components                       | “123 Main St New York NY 10001 US” |
| tags             | Categories/labels captured from Maps                  | ["Coffee shop"] |
| notes            | Additional place notes if present                     | null |
| place_id         | Unique Google Place ID                                | “abcd1234” |
| phone            | Phone number (if available)                           | “+1 212-555-0100” |
| lat              | Latitude                                              | 40.75 |
| long             | Longitude                                             | -73.99 |
| hours            | Normalized opening hours by day (array of objects)    | [{"day":"Monday","hours":"8 AM–6 PM",...}] |
| success          | Extraction success flag                               | true |

Bonus data:
- Optional per-place review capture adds reviews (array) and review_count to the final maps.json and to dedicated dataset items when enabled.
- Results are written live to the Apify Dataset during the run and persisted as maps.json in the Key-Value Store.

### Key features

- 🛡️ **Automatic proxy fallback (direct → datacenter → residential, sticky)**  
  Resilient proxy ladder with clear logging. Starts direct, falls back to datacenter, then switches to residential proxies with stickiness for the rest of the run when needed.

- 🗺️ **Grid-based viewport coverage**  
  Expands geographic coverage by scanning across a generated grid per location, maximizing discovery of businesses within the area.

- 🧩 **Bulk inputs: locations, keywords, and direct URLs**  
  Run city/region + keyword combinations and/or process direct Google Maps search URLs at scale.

- 🔁 **Live dataset writes + final merged maps.json**  
  Avoid data loss with incremental writes to the Dataset and a final, sorted list saved as maps.json in the Key-Value Store.

- 🗂️ **Deduplication by place_id**  
  Ensures each business appears once, even when discovered from multiple grid points or sources.

- ⭐ **Optional reviews capture (best-effort)**  
  Enable per-place review extraction to turn this into a focused Google Maps reviews scraper for qualitative insights.

- 🔤 **Sorting options (rating, review_count, name, relevance)**  
  Final results can be sorted to match your workflow’s needs.

- 🧪 **Built in Python, Apify-native**  
  A reliable Google Maps scraper Python implementation optimized for Apify infrastructure and automation.

- ⚙️ **Transparent logs and progress updates**  
  Detailed logging of grid points, proxy events, and review progress for observability and debugging.

### How to use Google Maps Scraper - step by step

1. Sign in to your Apify account and open the Google Maps Scraper actor.
2. Add input:
   - locations: a list of city/region names (e.g., “New York”).
   - keywords: a list of search terms (e.g., “coffee shops”). This field is required.
   - urls: optional list of direct Google Maps search URLs.
   - maxResults: set the global cap for places to collect.
   - proxyConfiguration: leave blank to start direct; the actor auto-fallbacks as needed.
3. Start the run. The actor resolves a viewport for each location/URL and sweeps it using a grid strategy.
4. Monitor logs for grid progress, deduplication counts, and any proxy mode changes.
5. (Optional) Advanced via API: you can pass sortOrder, maxComments, and gridSize to control sorting, review capture depth, and grid resolution.
6. Review results:
   - Live items are added to the Apify Dataset during the run.
   - The final merged list is saved to the Key-Value Store as maps.json.

Pro tip: Chain this Google Maps leads scraper into your enrichment workflow by consuming maps.json or the Dataset in subsequent Apify runs.

### Use cases

| Use case name | Description |
| --- | --- |
| Local SEO + competitor mapping | Track category density, ratings, and review counts across neighborhoods to prioritize optimizations and spot gaps. |
| Sales prospecting & lead gen | Build targeted lists of businesses with phones, websites, and locations — a practical Google Maps leads scraper workflow. |
| Market analysis by city/region | Compare categories across multiple cities using grid-based extraction for consistent geographic coverage. |
| Data enrichment pipelines | Merge place_id-based records with your CRM or BI data for deeper segmentation and outreach. |
| Academic & geospatial research | Quantify retail presence, services distribution, and urban patterns using structured latitude/longitude and address fields. |
| URL-driven campaigns | Feed direct Maps search URLs to run reproducible queries for campaign tracking or audits. |
| Review intelligence (opt-in) | Capture top reviews per place to add qualitative insights to quantitative metrics. |

### Why choose Google Maps Scraper?

This Google Business Profile scraper is purpose-built for precision, scale, and resilience on Apify infrastructure.

- ✅ Accurate structured output with address components, ratings, phones, coordinates, and hours
- 🌍 Grid-based coverage for broad, consistent discovery
- 🧱 Resilient proxy ladder with residential stickiness after fallback
- 🧰 Developer-friendly: Python implementation and transparent logs
- 🔁 Live dataset writes plus final sorted maps.json for safe, repeatable workflows
- 🧼 Clean deduplication by place_id across sources and grid points
- 🆚 Built for reliability vs. brittle browser extensions and ad-hoc scripts

In short, it’s a production-grade Google Maps scraping tool that balances scale, stability, and clean output.

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

Yes — when used responsibly. This actor collects data from public Google Maps pages and does not access private or authenticated content.

Guidelines:
- Only extract publicly available information.
- Comply with local laws and regulations (e.g., GDPR, CCPA) applicable to your use case.
- Review and respect the platform’s terms; you are responsible for how you use the data.
- Consult your legal team for edge cases or commercial reuse questions.

### Input parameters & output format

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

Parameters (from the actor input schema):

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

Advanced options (supported via input JSON, not in the UI schema):

- sortOrder (string): “relevance” | “rating” | “review\_count” | “distance” | “name”. Default: “relevance”.
- maxComments (integer): Number of reviews to fetch per place; 0 disables reviews. Default: 0.
- gridSize (integer): Grid dimension for viewport coverage. Default: 15.

Example JSON output (place item pushed to Dataset and stored in maps.json)

```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
}
```

When reviews are enabled (maxComments > 0), the actor also pushes review records per place to the Dataset and augments the corresponding place object in maps.json:

```json
{
  "place_id": "abcd1234",
  "reviews": [
    {
      "author_name": "Jane Doe",
      "author_url": "https://maps.google.com/?cid=...",
      "rating": 5,
      "text": "Great coffee and friendly staff!",
      "time": "1711920000",
      "relative_time": "2 months ago",
      "author_reviews_count": 42,
      "author_photo": "https://lh3.googleusercontent.com/...",
      "likes": 3
    }
  ],
  "review_count": 1
}
```

Notes:

- The final maps.json contains the sorted array of place objects and, if enabled, embedded “reviews” and “review\_count” fields per place.
- Some fields may be missing or null when not present on the public Google Maps page (e.g., website, phone, hours).

### Related tools

- 🔎 Google Maps contact info extractor — Focus on phones and websites from public listings
- 🧭 Google My Business scraper — Capture structured profiles for local SEO audits
- 📝 Google Maps reviews scraper — Enrich place data with qualitative review content

### FAQ

#### Is there a free trial or starter allowance?

Yes. This actor lists a monthly plan at $19.99 and includes 120 trial minutes in the Apify Store. You can start with the trial to evaluate performance before upgrading.

#### Do I need to use the official Google API?

No. This is a Google Maps scraper without API usage. It collects public data from the web experience with built-in proxy handling.

#### Does it capture reviews?

Yes, optionally. Set maxComments > 0 in the input to enable per-place reviews. Reviews are best-effort and depend on availability and access.

#### How many results can I fetch per run?

Up to maxResults across all searches in a run (default 20, maximum 10,000). The actor stops early when the cap is reached.

#### What fields do you extract?

The actor extracts name, website, avg\_rating, total\_reviews, address components, tags, notes, place\_id, phone, lat/long, hours, success, and — when enabled — reviews and review\_count.

#### How does proxy fallback work?

The actor starts with a direct connection. If blocked, it automatically falls back to a datacenter proxy, and then to a residential proxy with sticky mode for the remainder of the run. All transitions are logged.

#### Can I sort results?

Yes. You can sort the final output by relevance, rating, review\_count, distance, or name using the sortOrder input (advanced option via JSON).

#### Is this better than a Chrome extension?

For reliability and scale, yes. Unlike fragile browser extensions, this Google Maps scraping tool runs on Apify infrastructure with automatic proxy fallback, live dataset writes, and final maps.json for reproducible workflows.

### Closing CTA / Final thoughts

Google Maps Scraper is built for fast, reliable extraction of structured business data from public Google Maps results. With grid-based coverage, automatic proxy fallback, deduplication by place\_id, and optional review capture, it’s ideal for marketers, developers, analysts, and researchers.

Run it from the Apify Console for quick lists, or pass advanced JSON inputs to tailor sorting, grid size, and review depth. Developers can plug the Dataset and maps.json into automation or enrichment pipelines for downstream analysis.

Start extracting smarter local insights, build clean lead lists, and power your Google Maps web scraping service with a robust, production-ready workflow.

# 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("scrapebase/google-maps-scraper").call(input);

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

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

```

## Python example

```python
from apify_client import ApifyClient

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

# Prepare the Actor input
run_input = {
    "locations": ["New York"],
    "keywords": ["coffee shops"],
    "urls": [],
    "proxyConfiguration": { "useApifyProxy": False },
}

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

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

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

```

## CLI example

```bash
echo '{
  "locations": [
    "New York"
  ],
  "keywords": [
    "coffee shops"
  ],
  "urls": [],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call scrapebase/google-maps-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Google Maps Scraper",
        "description": "Extract business data from Google Maps with precision 📍🏢 Scrape names, addresses, phone numbers, ratings, reviews, websites, and more from any location search. Perfect for lead generation, local SEO, competitor research, and market analysis. Scale your data collection effortlessly 🚀",
        "version": "0.1",
        "x-build-id": "SbmvJt2NRpP7rNqlH"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapebase~google-maps-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapebase-google-maps-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/scrapebase~google-maps-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapebase-google-maps-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/scrapebase~google-maps-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapebase-google-maps-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```