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

📍 Google Maps Scraper extracts rich business data from Google Maps—names, categories, addresses, phones, emails, websites, ratings, reviews, hours & coordinates. ⚙️ Bulk scrape and export CSV/JSON. 🚀 Ideal for lead gen, local SEO, market research & sales.

- **URL**: https://apify.com/scrapemesh/google-maps-scraper.md
- **Developed by:** [ScrapeMesh](https://apify.com/scrapemesh) (community)
- **Categories:** AI, Automation, Lead generation
- **Stats:** 2 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 rich business details from public Google Maps pages at scale. It helps you scrape Google Maps business listings for lead generation, local SEO, and market research by gathering names, categories, addresses, phones, websites, ratings, reviews, hours, and coordinates. Built for marketers, developers, data analysts, and researchers, this Google Maps places scraper delivers structured outputs (CSV/JSON) and a consolidated maps.json for seamless workflows — enabling automated pipelines and repeatable insights at scale. 🚀

### What data / output can you get?

This Google Business Profile scraper returns structured place-level fields so you can extract data from Google Maps cleanly and consistently.

- name — Business name (e.g., “Sample Coffee”)
- website — Official website URL (e.g., “https://samplecoffee.com”)
- avg_rating — Average rating (e.g., 4.6)
- total_reviews — Total review count (e.g., 128)
- street_address — Street line (e.g., “123 Main St”)
- city — Locality (e.g., “New York”)
- state — Region/state code (e.g., “NY”)
- zip — Postal/ZIP code (e.g., “10001”)
- country_code — Country code (e.g., “US”)
- full_address — Combined address string
- tags — Categories/labels from Maps (array)
- notes — Additional notes when available
- place_id — Unique Google identifier for deduplication
- phone — Phone number (e.g., “+1 212-555-0100”)
- lat — Latitude (e.g., 40.75)
- long — Longitude (e.g., -73.99)
- hours — Opening hours by day (array of objects with day, hours, open24Hour, close24Hour)
- success — Boolean success flag

Bonus outputs:
- Optional per-place reviews when enabled, returned with author metadata and ratings
- A final, sorted list saved as maps.json in the Key-Value Store for one-click export

You can export results from the Apify Dataset in CSV or JSON, and use the consolidated maps.json for downstream processing.

### Key features

- 🛡️ Resilient proxy ladder with auto-fallback  
  Direct → datacenter → residential with sticky residential sessions and detailed logs. This improves reliability for any Google Maps scraping service workflow.

- 🗺️ Grid-based viewport coverage  
  Discovers more businesses per area by scanning multiple points within a resolved viewport for each location, acting as a robust Google Maps business scraper for broader coverage.

- 🧼 Deduplication by place_id  
  Ensures clean datasets by preventing duplicates across grid points and inputs.

- 🧮 Live dataset writes + final maps.json  
  Pushes each place as it’s found to avoid data loss and stores a final, sorted list in the Key-Value Store as maps.json.

- ⭐ Sorting options for insights  
  Supports result sorting by rating, review_count, name, relevance, or distance in the final consolidation for better prioritization.

- 💬 Optional review capture  
  When enabled, scrape Google Maps reviews with best-effort retrieval and push review records to the dataset alongside place items.

- 📦 Bulk inputs & scale  
  Accepts multiple locations, keywords, and direct Google Maps URLs to operate as a scalable Google Maps leads extractor and Google Maps scraper tool.

- 👩‍💻 Built with Python on Apify  
  Production-grade infrastructure with Python-based logic, making it easy to integrate via the Apify API for Google Maps scraper Python workflows.

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

1. Sign in to your Apify account and open the Google Maps Scraper actor.
2. Provide input in the web form:
   - Add one or more “locations” (e.g., “New York”).
   - Add one or more “keywords” (e.g., “coffee shops”) — this field is required.
   - Optionally paste direct Google Maps search URLs.
   - Set “maxResults” to control the total number of places to return.
   - Configure “proxyConfiguration” or leave it blank to start direct; the actor automatically falls back if blocked.
3. Start the run. The actor resolves viewports, scans grid points, and writes items live to the Dataset.
4. Watch logs for progress, including grid coverage and proxy events.
5. When finished:
   - Download structured results from the Dataset in CSV/JSON.
   - Retrieve the consolidated, sorted output at OUTPUT → maps.json in the Key-Value Store.

Pro tip: Combine the Dataset API with your internal automation to build a Google Maps scraper API pipeline for CRM enrichment or analytics.

### Use cases

- Local SEO + listings enrichment — Build complete profiles (addresses, phones, websites, hours, ratings) for geo-targeted categories.
- B2B lead generation — Discover and export prospect lists by city and niche with a reliable Google Maps leads extractor.
- Competitive analysis — Compare ratings, review counts, and coverage across neighborhoods or regions.
- Market research & mapping — Aggregate places by category and geography for spatial analysis and reporting.
- Data engineering pipelines — Orchestrate Apify runs and consume results programmatically for downstream modeling.

### Why choose Google Maps Scraper?

This Google Maps scraper tool is built for precision, scale, and reliability on Apify’s infrastructure.

- ✅ Accurate, structured outputs: Clean JSON/CSV with normalized fields and place_id-based deduplication.
- 🌍 Broad discovery: Grid-based coverage captures more listings per area than simple one-off lookups.
- ⚙️ Automation-first: Live dataset writes plus a final maps.json for repeatable workflows and versioning.
- 👩‍💻 Developer-friendly: Python-based actor on Apify with API access for automation and integration.
- 🛡️ Robust anti-blocking: Automatic proxy fallback from direct to datacenter to sticky residential sessions.
- 💸 Cost-effective scaling: Run bulk batches with transparent progress and reliable outcomes.
- 🔁 Better than browser extensions: No flaky sessions or manual clicks — this is a production-grade Google Maps scraping service.

In short, it’s a dependable Google My Business scraper/Google Business Profile scraper alternative to unstable tools, focused on data quality and automation.

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

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

Guidelines for compliant use:
- Only collect publicly visible business information.
- Follow applicable data regulations (e.g., GDPR, CCPA) and respect regional laws.
- Review and comply with Google’s terms of service for your use case.
- Use outputs responsibly and avoid spam or misuse.

Always consult your legal team for edge cases or jurisdiction-specific requirements.

### Input parameters & output format

Example JSON input
```json
{
  "locations": ["New York"],
  "keywords": ["coffee shops"],
  "urls": [
    "https://www.google.com/maps/search/coffee+shops+in+New+York/"
  ],
  "maxResults": 50,
  "proxyConfiguration": { "useApifyProxy": false }
}
````

Parameters

- locations (array of strings)\
  Description: List of location names (e.g., New York, Florida).\
  Default: \[]\
  Required: No

- keywords (array of strings)\
  Description: Search keywords or user-specified terms (supports bulk).\
  Default: \[]\
  Required: Yes

- urls (array of strings)\
  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).\
  Minimum: 1, Maximum: 10000\
  Default: 20\
  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 JSON output (Dataset place item)

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

Example JSON output (Dataset review record pushed when reviews are enabled)

```json
{
  "place_id": "abcd1234",
  "reviews": [
    {
      "author_name": "John Doe",
      "author_url": "https://www.google.com/maps/contrib/...",
      "rating": 5,
      "text": "Great coffee and friendly staff!",
      "time": "1700000000",
      "relative_time": "2 weeks ago",
      "author_reviews_count": 12,
      "author_photo": "https://lh3.googleusercontent.com/...",
      "likes": 3
    }
  ],
  "review_count": 1
}
```

Consolidated output (Key-Value Store: maps.json)\
The actor saves a final, sorted list of place items (potentially including “reviews” and “review\_count” if enabled) to the Key-Value Store as 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,
    "reviews": [],
    "review_count": 0
  }
]
```

Notes

- The Dataset contains one item per place plus optional review records (as separate items) when review capture is enabled.
- maps.json contains only place items, optionally enriched with “reviews” and “review\_count”.

### FAQ

#### Does this Google Maps Scraper collect reviews?

Yes. When review capture is enabled, the actor will scrape Google Maps reviews on a best-effort basis and push them to the Dataset. The final maps.json can also include “reviews” and “review\_count” per place.

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

Yes. Runs are subject to your Apify plan, and this actor includes trial minutes as configured on the Apify platform. You can start small and scale as needed.

#### Do I need a login, cookies, or a Google account?

No. This Google Maps scraping service works without logging into Google. It operates on public Google Maps pages and manages access with an automatic proxy fallback system.

#### Can I integrate it via API or with Python?

Yes. This is an Apify actor, so you can trigger runs and fetch datasets via the Apify API. It’s built as a Google Maps scraper Python solution under the hood, making it developer-friendly for automation pipelines.

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

You control the cap using “maxResults.” The actor stops early when it reaches this limit across all searches and inputs.

#### What’s the difference between this and a Google Maps scraper Chrome extension?

Extensions are prone to breakage and manual intervention. This production-grade actor runs on Apify, supports bulk automation, resilient proxies, and structured outputs — a more reliable Google Maps data extractor for professional use.

#### Does it extract emails?

No. This is not a Google Maps email extractor. It focuses on public place fields such as name, address, phone, website, ratings, reviews, hours, and coordinates.

#### Is it safe and compliant to use?

Yes, when used responsibly. It collects publicly available data and includes no login or private profile access. Ensure compliance with local laws and Google’s terms for your specific use case.

### Closing CTA / Final thoughts

Google Maps Scraper is built to reliably extract structured business data from Google Maps at scale. With grid-based discovery, robust proxy fallback, and clean CSV/JSON outputs plus a consolidated maps.json, it’s ideal for marketers, analysts, developers, and researchers. Plug it into the Apify API to run automated pipelines, enrich CRMs, and power data-driven outreach. Start extracting smarter location insights today with a dependable Google Maps scraper API 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("scrapemesh/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("scrapemesh/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 scrapemesh/google-maps-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Google Maps Scraper",
        "description": "📍 Google Maps Scraper extracts rich business data from Google Maps—names, categories, addresses, phones, emails, websites, ratings, reviews, hours & coordinates. ⚙️ Bulk scrape and export CSV/JSON. 🚀 Ideal for lead gen, local SEO, market research & sales.",
        "version": "0.1",
        "x-build-id": "ze5T40iTf3U7F2LZc"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapemesh~google-maps-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapemesh-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/scrapemesh~google-maps-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapemesh-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/scrapemesh~google-maps-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapemesh-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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```