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

🗺️ Google Maps Extractor (google-maps-extractor) pulls public business data—names, addresses, phones, websites, ratings, reviews & hours. ⚡ Fast, accurate, geo-targeted. 📊 Export CSV/JSON for lead gen, local SEO & market research. 🔎 Filter by category & location.

- **URL**: https://apify.com/scrapebase/google-maps-extractor.md
- **Developed by:** [ScrapeBase](https://apify.com/scrapebase) (community)
- **Categories:** Automation, Lead generation, Social media
- **Stats:** 4 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 Extractor

Google Maps Extractor is a fast, reliable Google Maps scraper that automates grid-based searches to extract public business listings at scale. It solves the “hidden pockets” problem by covering map viewports thoroughly, deduplicates results, and exports clean records for lead gen, local SEO, and data analysis. Built for marketers, developers, data analysts, and researchers, this Google Maps data extractor helps teams scrape Google Maps business listings and turn them into ready-to-use datasets at scale.

### What is Google Maps Extractor?

Google Maps Extractor is an Apify actor that scrapes public Google Maps business data and exports it to CSV/JSON for enrichment and outreach. It tackles rate limits and blocks with automatic proxy escalation, and uses grid-based coverage to maximize results for each location-keyword combination or direct Maps URL. For sales teams, SEOs, developers, and analysts, this Google Places extractor enables repeatable, large-scale discovery of business listings with structured outputs to power lead pipelines and market intelligence.

### What data / output can you get?

This Google Maps business extractor returns structured, deduplicated items with key business attributes and quality signals. Below are the main fields as they appear in the dataset:

| Data field | Description | Example |
| --- | --- | --- |
| name | Place or business name | “Sample Coffee” |
| website | Resolved website URL (cleaned) | “https://samplecoffee.com” |
| avg_rating | Average star rating | 4.6 |
| total_reviews | Total count of reviews | 128 |
| full_address | Concatenated address string | “123 Main St New York NY 10001 US” |
| phone | Primary phone number (if available) | “+1 212-555-0100” |
| place_id | Google Maps place identifier | “abcd1234” |
| lat | Latitude | 40.7500 |
| long | Longitude | -73.9900 |
| hours | Opening hours array (best-effort) | [{ “day”: “Monday”, “hours”: “8 AM–6 PM”, … }] |
| tags | Categories/labels array (if present) | [“Coffee shop”] |
| success | Success flag for the item | true |

Notes:
- When reviews are fetched, additional dataset entries may include reviews data (see Output Format below).
- Export results in Apify as JSON, CSV, or Excel. The final, sorted array is also stored as maps.json in the Key-Value Store, making it a convenient Google Maps to CSV scraper workflow.

### Key features

- ⚡ Bold coverage with grid-based viewports  
  Systematically scans across the area for each query to avoid missing listings—ideal for teams that need a robust Google Maps listing scraper.

- 🧠 Automatic proxy ladder  
  Resilient harvesting with escalation from direct → datacenter → residential (sticky fallback) to reduce rate limits and blocks.

- 🧹 Clean, deduplicated output  
  Deduplicates by place_id and writes structured items to the Apify Dataset and a final maps.json summary.

- 📦 Bulk inputs & flexible sources  
  Mix location + keyword pairs or supply direct Google Maps URLs in one run—great for a Google Maps data extraction tool that scales.

- 💬 Optional reviews capture  
  Fetch review details per place when configured—ideal for teams using a Google Maps reviews scraper for quality signals.

- 🔁 Sort and export-ready  
  Saves a final, sorted list to Key-Value Store and supports download as CSV/JSON from the dataset—your Google Maps to CSV scraper workflow in one place.

- 🧩 Developer-friendly & automation-ready  
  Integrate via the Apify platform and API with your pipelines (Zapier/Make/n8n), or use it as a Google Maps lead extractor in custom ETL jobs.

- 🛡️ Production reliability  
  Clear logs, retries, and proxy management make it a robust Google Maps data mining software alternative to browser extensions.

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

1. Sign in to Apify  
   Create or log in to your Apify account to access the Google Maps Extractor.

2. Open the actor on Apify Console  
   Search for “Google Maps Extractor” by scrapebase and open the actor page.

3. Add input data  
   - locations: list of places or regions (e.g., “New York”, “Florida”).  
   - keywords: search terms such as “coffee shops”, “plumbers”, etc.  
   - urls: optional direct Google Maps search URLs.  
   - maxResults: cap the total number of places across the whole run.  
   - proxyConfiguration: leave default (direct) or configure Apify Proxy.

4. Configure proxy as needed  
   Start direct by default; the actor escalates to datacenter and then residential (sticky) if blocked.

5. Run the actor  
   Click Start. Watch logs for viewport coverage, proxy changes, and progress across grid points.

6. Monitor progress  
   The actor deduplicates by place_id and streams items into the Dataset as they’re discovered.

7. Download results  
   - Dataset: Export JSON, CSV, or Excel.  
   - Key-Value Store: Download maps.json for the final sorted list.

Pro tip: Automate end-to-end flows by triggering this Google Maps data extractor from the Apify API and piping results to your CRM or enrichment stack.

### Use cases

| Use case | Description |
| --- | --- |
| Sales outreach lead lists | Build targeted lead lists by city and category to feed outreach sequences with fresh business data. |
| Local SEO & competitor scans | Analyze categories, ratings, and review counts across neighborhoods for Google My Business insights. |
| Franchise territory planning | Map and measure coverage across regions to support territory planning and site selection. |
| Data enrichment pipelines | Enrich existing place records with phones, websites, and geocoordinates via a Google Places extractor. |
| Market research & benchmarking | Compare ratings and review volumes for competitive benchmarking across multiple geos. |
| Academic & urban studies | Collect structured business location data to support research on density, services, or accessibility. |
| Automation & ETL workflows | Integrate structured outputs into n8n, Make, or custom pipelines for repeatable data loads. |

### Why choose Google Maps Extractor?

A production-ready Google Maps business extractor that prioritizes accuracy, automation, and scale.

- 🎯 Precision coverage: Grid-based viewports minimize blind spots compared to simple single-view crawls.
- 🚀 Built for scale: Handles bulk inputs across multiple cities, categories, and direct URLs.
- 👩‍💻 Developer access: Apify-native tooling makes it API-friendly and easy to integrate into Python or low-code workflows.
- 🔒 Public-only data: Designed to extract from public Google Maps pages without login.
- 💸 Cost-effective automation: Reduce manual copy-paste and unstable browser tooling.
- 🔌 Plays well with stacks: Export to CSV/JSON and connect with Zapier, Make, or data warehouses.
- 🧱 More reliable than extensions: Avoid flaky Google Maps scraper Chrome extension behavior with server-side resilience and proxy management.

Bottom line: If you need to scrape Google Maps business listings reliably and at scale, this tool delivers structured output and hands-off stability.

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

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

Guidelines for compliant use:
- Only collect publicly available information.
- Consult and respect Google’s terms of service.
- Follow applicable data protection laws (e.g., GDPR, CCPA).
- Avoid misuse of contact data; ensure your downstream use is lawful.
- When in doubt, consult your legal team for your jurisdiction and use case.

### Input parameters & output format

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

Input fields

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

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

- urls (array of strings)\
  Description: Direct Google Maps search URLs (optional, supports bulk).\
  Default: none\
  Required: No

- maxResults (integer)\
  Description: Maximum number of places to return (cap across all searches).\
  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

Output format

- Dataset: Streams one item per discovered place with the fields below. When reviews are fetched, additional dataset entries are pushed containing reviews for a specific place\_id.
- Key-Value Store: maps.json contains the final, sorted array of place items.

Example dataset item (place)

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

Example dataset item (reviews for a place)

```json
{
  "place_id": "abcd1234",
  "reviews": [
    {
      "author_name": "Jane Doe",
      "author_url": "https://www.google.com/maps/contrib/123",
      "rating": 5,
      "text": "Great coffee and friendly staff!",
      "time": "1692211200",
      "relative_time": "a year ago",
      "author_reviews_count": 42,
      "author_photo": "https://example.com/photo.jpg",
      "likes": 3
    }
  ],
  "review_count": 1
}
```

Note: maps.json in the Key-Value Store contains the final sorted list of place items (place records may include a “reviews” array when fetched).

### FAQ

#### Is there a free trial or test period?

Yes. The Apify Store listing typically includes trial minutes so you can test the Google Maps scraper before committing. Check the actor page for current pricing and trial details.

#### Do I need to log in or use browser cookies?

No. This Google Maps data extractor works on public pages without login. It also avoids fragile browser automation by using HTTP requests and robust parsing.

#### Can I export data to CSV or Excel?

Yes. You can export from the Apify Dataset in JSON, CSV, or Excel formats. The final sorted array is also saved as maps.json in the Key-Value Store.

#### Can it extract reviews as well?

Yes. When reviews are fetched, the actor pushes additional dataset entries containing review objects for each place\_id. This makes it useful as a Google Maps reviews scraper when you need qualitative signals.

#### What happens if Google blocks my requests?

The actor escalates automatically: direct → datacenter → residential (sticky) with retries. Logs clearly show each proxy switch and retry behavior.

#### How many results can I collect in one run?

Use maxResults to cap the number of places across all searches in a run. The actor stops early once this cap is reached.

#### Can I combine keywords, locations, and URLs?

Yes. Provide location + keyword pairs and/or direct Google Maps URLs in the same run. The extractor processes all inputs and deduplicates by place\_id.

#### How is this better than a Google Maps scraper Chrome extension?

Unlike browser extensions, this Google Maps business extractor runs on server infrastructure with proxy management, retries, and grid-based coverage—making it more reliable for large-scale jobs.

### Closing CTA / Final thoughts

Google Maps Extractor is built for structured, large-scale Google Maps business data extraction you can trust. With grid coverage, automatic proxy fallback, and clean deduplicated outputs, it powers lead generation, local SEO, and market research for marketers, developers, data analysts, and researchers. Export to CSV/JSON, automate via Apify’s API, and plug results into your pipelines effortlessly. Start extracting smarter, scalable business 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("scrapebase/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("scrapebase/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 scrapebase/google-maps-extractor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=scrapebase/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) pulls public business data—names, addresses, phones, websites, ratings, reviews & hours. ⚡ Fast, accurate, geo-targeted. 📊 Export CSV/JSON for lead gen, local SEO & market research. 🔎 Filter by category & location.",
        "version": "0.1",
        "x-build-id": "gfuoiHRbeBVk59f3V"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapebase~google-maps-extractor/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapebase-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/scrapebase~google-maps-extractor/runs": {
            "post": {
                "operationId": "runs-sync-scrapebase-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/scrapebase~google-maps-extractor/run-sync": {
            "post": {
                "operationId": "run-sync-scrapebase-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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```