# Google Maps Business Scraper – Extract Leads Free (`sovanza.inc/google-maps-business-scraper---extract-leads-free`) Actor

Extract Google Maps business data like contacts, reviews, and locations from search URLs and export it for analysis and outreach.

- **URL**: https://apify.com/sovanza.inc/google-maps-business-scraper---extract-leads-free.md
- **Developed by:** [Sovanza](https://apify.com/sovanza.inc) (community)
- **Categories:** Lead generation, Jobs, Developer tools
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

$15.00/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.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 Business Scraper – Extract Leads, Reviews & Insights

Extract Google Maps business data including names, phone numbers, websites, reviews, ratings, and locations with this scraper. Ideal for lead generation, local SEO, and competitor analysis. Export in JSON, CSV, or Excel format from your Apify dataset.

### What is Google Maps Scraper?

Google Maps Scraper is a local business data extraction tool built on Apify that pulls business listings, contact details, reviews, and location data from Google Maps using **search URLs** and/or **Place IDs**. It is designed for:

- Lead generation agencies  
- SEO professionals  
- Sales teams  
- Local businesses  
- Data analysts  

Instead of manually searching and copying data, you can extract many business leads in a structured dataset for outreach and analysis.

### Why This Google Maps Scraper is Powerful

This actor is built for real business outcomes (leads → outreach → analysis):

- Extract high-quality local business leads (name, phone, website, address, coordinates)  
- Collect **review text** (author, rating, date) up to your configured limit per place  
- Analyze ratings, review counts, and listing details for competitor research  
- Scale across cities and industries by running multiple search URLs in one actor run  
- Automate data collection via Apify API, schedules, and webhooks  

**Note:** This actor does **not** crawl linked websites for email addresses. You get **phone**, **website URL**, and **social links** from Maps where shown; use your own enrichment workflow if you need emails.

### What Data Does Google Maps Scraper Extract?

This actor outputs one dataset item per business. Fields reflect what is available on Google Maps for that listing (DOM changes can occasionally affect individual fields).

#### Business information

- Business name  
- Category / industry  
- Full address; **city** and **postal code** (parsed from address when possible)  
- **Google Maps URL** and **Place ID**  

#### Contact details

- Phone number  
- Website URL  
- **Social media links** (when present on the listing)  

#### Reputation and engagement

- Average **rating** and **review count**  
- **Reviews** array: `authorName`, `rating`, `date`, `text` (up to `maxReviews` per business)  

#### Location data

- **Latitude** and **longitude** (when available from the page/URL)  

#### Additional insights

- **Opening hours** (as scraped from the panel)  
- **Business status** (e.g. open/closed where shown)  
- **Price level** where available  
- **Photos count** and **image URLs** (`images`) — in fast mode (low `maxReviews`) image extraction may be reduced for speed  
- **Popular times** (when exposed in the UI; structure may vary)  
- **Scrape timestamp** (`timestamp`)  

➡️ All structured fields are exportable as **JSON, CSV, or Excel** from the Apify dataset.

### Advanced Features

- **Flexible input:** One or more **Google Maps search URLs** (e.g. “Restaurants in Dubai”) and/or **Place IDs** for direct place pages.  
- **Pagination:** Scrolls the results list to load up to `maxResults` businesses per search URL.  
- **Bulk extraction:** Combine multiple `searchUrls` and `placeIds` in a single run.  
- **Concurrency:** `maxConcurrency` controls how many places are processed in parallel (see timeouts below).  
- **Proxy country:** Optional Apify Proxy country selection to reduce blocks.  
- **Automation:** Apify API, schedules, webhooks, and integrations (Sheets, Zapier, Make, CRMs via API).  

### How to Use Google Maps Scraper on Apify

#### Using the actor

1. Open **Google Maps Business Scraper** on the Apify platform.  
2. Configure **Input** (see below). For larger runs with reviews, increase **Run timeout** in **Run options** (default Apify timeout is often 300 seconds).  
3. Click **Start**.  
4. Open the **Dataset** tab and export **JSON**, **CSV**, or **Excel**, or pull results via the Apify API.  

#### Local development

**Option A — run script (recommended):**

```powershell
cd google-maps-business-scraper
.\run_local.ps1
````

Creates a `.venv`, installs dependencies, installs Playwright Chromium, and runs `main.py`. Use `INPUT.json` for input; if missing, defaults from the actor apply.

**Option B — manual:**

```bash
pip install -r requirements.txt
playwright install chromium
python main.py
```

Local output is written to `output.json` in the actor folder (same shape as the Apify dataset).

### Input configuration

Example `INPUT.json`:

```json
{
  "searchUrls": ["https://www.google.com/maps/search/Restaurants+in+Dubai"],
  "placeIds": [],
  "maxResults": 100,
  "maxReviews": 20,
  "maxConcurrency": 2,
  "proxyCountry": "AUTO_SELECT_PROXY_COUNTRY"
}
```

| Field | Type | Description |
|--------|------|-------------|
| `searchUrls` | array | One or more Google Maps **search** URLs. Results are loaded with pagination/infinite scroll. |
| `placeIds` | array | Optional: Google **Place IDs** to open place pages directly (e.g. `ChIJ…`). |
| `maxResults` | integer | Maximum businesses per search URL (default **100**, max **1000**). With many results and reviews, raise **Run timeout** (e.g. 600–900 s). |
| `maxReviews` | integer | Max reviews per business (**0** skips reviews). Use **5 or fewer** for faster runs. |
| `maxConcurrency` | integer | Places scraped in parallel (**1–4**, default **2**). Lower if runs time out. |
| `proxyCountry` | string | `AUTO_SELECT_PROXY_COUNTRY`, `US`, `GB`, `AE`, `SA`, `DE`, `FR` — for use with Apify Proxy. |

### Output

Each dataset item follows `.actor/dataset_schema.json`. Typical fields:

| Field | Description |
|--------|-------------|
| `businessName` | Business name |
| `category` | Category / type |
| `googleMapsUrl` | Link to the place on Google Maps |
| `placeId` | Place ID |
| `address` | Full address string |
| `city` | Parsed city when possible |
| `postalCode` | Postal code when detected in address |
| `latitude`, `longitude` | Coordinates (nullable) |
| `phone` | Phone number |
| `website` | Website URL |
| `socialMediaLinks` | Array of social URLs |
| `rating` | Average rating |
| `reviewCount` | Total review count |
| `priceLevel` | Price level when shown |
| `openingHours` | Hours text |
| `businessStatus` | Status (e.g. open/closed) |
| `photosCount` | Photo count when available |
| `images` | Array of image URLs |
| `reviews` | Array of `{ authorName, rating, date, text }` |
| `popularTimes` | Popular times objects when available |
| `timestamp` | ISO scrape time |

Example (illustrative; real pages vary):

```json
{
  "businessName": "Example Cafe",
  "category": "Cafe",
  "googleMapsUrl": "https://www.google.com/maps/place/?q=place_id:ChIJ...",
  "placeId": "ChIJ...",
  "address": "123 Main St - Dubai - United Arab Emirates",
  "city": "Dubai",
  "phone": "+971 4 000 0000",
  "website": "https://example.com",
  "rating": "4.5",
  "reviewCount": "120",
  "reviews": [
    {
      "authorName": "Jane D.",
      "rating": "5",
      "date": "Jan 2025",
      "text": "Great coffee and service."
    }
  ],
  "latitude": 25.2048,
  "longitude": 55.2708,
  "timestamp": "2025-03-30T12:00:00.000Z"
}
```

On failure after retries, the actor may push an item that includes an `error` field (not part of the static dataset schema file).

### How extraction works

- **Search flow:** Opens each `searchUrl`, scrolls the results feed (`_scroll_results_panel`) to load up to `maxResults` items, collects place links, then opens each place and runs `extract_business_from_detail_panel()`.
- **Place ID flow:** Opens the place URL for each ID and uses the same extraction logic.
- **Selectors** live in `extract_business_from_detail_panel()` and related helpers. Google’s DOM changes over time; missing fields may require selector updates in `main.py`.

### Performance and timeouts

- **Default Apify run timeout** is often **300 seconds**. If the run stops with few results, open **Run options** and set **Timeout** to **600** or **900** seconds.
- **Fast mode** (when `maxReviews` is low, e.g. ≤ 5): shorter waits and lighter image work so more places can finish within tight timeouts.
- **`maxReviews: 0`:** Skips review scraping for maximum throughput.
- **`maxConcurrency`:** If jobs still time out, try **1**.

### Proxy and reliability

- Use **Apify Proxy** on the platform; `proxyCountry` selects region when using proxy.
- The actor rotates user agents and applies random delays between actions to reduce blocking.

### API route (example)

See `routes/google_maps.example.js` for a sample **POST /api/scraper/google-maps** handler that calls this actor and returns `{ success, data }`. Point it at your Apify actor ID and `APIFY_TOKEN` as needed.

### FAQ

**How can this scraper help with lead generation?**\
It collects business names, phones, websites, addresses, and coordinates from Maps listings in bulk, so you can build outreach lists without manual copy-paste.

**Does this actor extract emails?**\
No. It does not visit business websites to parse emails. Use the **website** field with your own enrichment tools or processes if you need email addresses.

**How accurate is the data?**\
Data is taken from live Maps UI. Business owners can change listings at any time—validate critical fields before campaigns.

**Can I scrape multiple cities?**\
Yes. Add multiple `searchUrls` (one query per city or niche) or run separate searches; combine with `maxResults` per search.

**How do I use this for local SEO?**\
Export competitors’ ratings, review counts, and review text for a location to compare positioning and messaging.

**Can agencies use this for prospecting?**\
Yes—filter by category and area, then prioritize businesses by rating, review volume, or missing website fields (as present in your export).

**Can I automate runs?**\
Yes—Apify schedules, API, and webhooks support recurring extraction and downstream CRM or sheet workflows.

**What is the best way to maximize coverage?**\
Use distinct search queries (e.g. different categories) rather than repeating the same keyword, and tune `maxResults` and `maxReviews` for your time budget.

**Is scraping Google Maps allowed?**\
Only use data in compliance with Google’s terms of service and applicable privacy and marketing laws. Use collected data responsibly, especially for commercial outreach.

### SEO keywords (high-intent)

google maps scraper, google maps data scraper, google maps lead scraper, google maps business scraper, scrape google maps data, google maps scraping api, local business scraper, lead generation scraper, google maps leads tool

### Limitations

- No email extraction from websites in this actor.
- Field availability depends on what Google shows for each listing; some fields may be empty.
- Heavy review counts and high `maxResults` need longer run timeouts and may hit rate limits—tune `maxReviews`, `maxConcurrency`, and proxy settings.

### License

Use and deploy in line with Apify’s terms and your own compliance obligations. See your repository or Apify actor settings for license details if specified.

# Actor input Schema

## `searchUrls` (type: `array`):

One or more Google Maps search URLs (e.g. Restaurants in Dubai). Results will be scraped with pagination/infinite scroll.

## `placeIds` (type: `array`):

Optional: one or more Google Place IDs to scrape directly (e.g. ChIJa8kjo4fZz0gRjjwq3uZabFw).

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

Maximum number of businesses to scrape per search URL. On Apify, default run timeout is 5 min — for 8+ results with reviews, set Run timeout to 600–900 s in Input → Run options.

## `maxReviews` (type: `integer`):

Maximum number of reviews to scrape per business (0 to skip reviews). Use 5 or less for faster runs.

## `maxConcurrency` (type: `integer`):

Number of places to scrape in parallel (2 = faster). If runs time out on Apify, try 1 or increase Run timeout in Run options.

## `proxyCountry` (type: `string`):

Country for proxy to avoid blocks (use with Apify proxy).

## Actor input object example

```json
{
  "searchUrls": [
    "https://www.google.com/maps/search/Restaurants+in+Dubai"
  ],
  "maxResults": 100,
  "maxReviews": 20,
  "maxConcurrency": 2,
  "proxyCountry": "AUTO_SELECT_PROXY_COUNTRY"
}
```

# 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 = {
    "searchUrls": [
        "https://www.google.com/maps/search/Restaurants+in+Dubai"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("sovanza.inc/google-maps-business-scraper---extract-leads-free").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 = { "searchUrls": ["https://www.google.com/maps/search/Restaurants+in+Dubai"] }

# Run the Actor and wait for it to finish
run = client.actor("sovanza.inc/google-maps-business-scraper---extract-leads-free").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 '{
  "searchUrls": [
    "https://www.google.com/maps/search/Restaurants+in+Dubai"
  ]
}' |
apify call sovanza.inc/google-maps-business-scraper---extract-leads-free --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Google Maps Business Scraper – Extract Leads Free",
        "description": "Extract Google Maps business data like contacts, reviews, and locations from search URLs and export it for analysis and outreach.",
        "version": "0.0",
        "x-build-id": "IDQ5fdKFxmNf5YtIT"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/sovanza.inc~google-maps-business-scraper---extract-leads-free/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-sovanza.inc-google-maps-business-scraper---extract-leads-free",
                "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/sovanza.inc~google-maps-business-scraper---extract-leads-free/runs": {
            "post": {
                "operationId": "runs-sync-sovanza.inc-google-maps-business-scraper---extract-leads-free",
                "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/sovanza.inc~google-maps-business-scraper---extract-leads-free/run-sync": {
            "post": {
                "operationId": "run-sync-sovanza.inc-google-maps-business-scraper---extract-leads-free",
                "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",
                "properties": {
                    "searchUrls": {
                        "title": "Search URL(s)",
                        "type": "array",
                        "description": "One or more Google Maps search URLs (e.g. Restaurants in Dubai). Results will be scraped with pagination/infinite scroll.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "placeIds": {
                        "title": "Place ID(s)",
                        "type": "array",
                        "description": "Optional: one or more Google Place IDs to scrape directly (e.g. ChIJa8kjo4fZz0gRjjwq3uZabFw).",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxResults": {
                        "title": "Maximum results per search",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum number of businesses to scrape per search URL. On Apify, default run timeout is 5 min — for 8+ results with reviews, set Run timeout to 600–900 s in Input → Run options.",
                        "default": 100
                    },
                    "maxReviews": {
                        "title": "Maximum reviews per business",
                        "minimum": 0,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Maximum number of reviews to scrape per business (0 to skip reviews). Use 5 or less for faster runs.",
                        "default": 20
                    },
                    "maxConcurrency": {
                        "title": "Parallel places",
                        "minimum": 1,
                        "maximum": 4,
                        "type": "integer",
                        "description": "Number of places to scrape in parallel (2 = faster). If runs time out on Apify, try 1 or increase Run timeout in Run options.",
                        "default": 2
                    },
                    "proxyCountry": {
                        "title": "Proxy country",
                        "enum": [
                            "AUTO_SELECT_PROXY_COUNTRY",
                            "US",
                            "GB",
                            "AE",
                            "SA",
                            "DE",
                            "FR"
                        ],
                        "type": "string",
                        "description": "Country for proxy to avoid blocks (use with Apify proxy).",
                        "default": "AUTO_SELECT_PROXY_COUNTRY"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```