# Google Maps Scraper $0.50 Per 1K (`coder_luffy/google-maps-scraper`) Actor

Google Maps Scraper collects business listings from Google Maps search results, returning names, addresses, phone numbers, websites, ratings, and GPS coordinates for any business type and location

- **URL**: https://apify.com/coder\_luffy/google-maps-scraper.md
- **Developed by:** [Luffy](https://apify.com/coder_luffy) (community)
- **Categories:** Lead generation, Automation, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.50 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## 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: extract local business data from Google Maps

![Google Maps Scraper](https://i.imgur.com/tFEPmE5.png)

Google Maps Scraper pulls verified business listings from Google Maps and delivers structured, ready-to-use data. Give it a list of search queries and get back names, addresses, phone numbers, websites, ratings, GPS coordinates, opening hours, and more — for every business it finds. No API key required.

### What data does this actor extract?

For each business the actor returns:

- Business name
- Full address (street, city, state, ZIP — parsed separately)
- Phone number in local and international format
- Website URL
- Star rating and review count
- GPS coordinates (latitude and longitude)
- Business categories
- Google Maps place ID and direct Maps link
- Neighborhood or district
- Timezone
- Today's opening hours and current open/closed status
- Thumbnail image URL
- Business attributes (Women-owned, LGBTQ+ friendly, Veteran-owned, Black-owned, etc.)
- Accessibility features (Wheelchair accessible entrance, parking, restroom, etc.)

### Sample output

![Results table view](https://i.imgur.com/s5Dts8j.png)

![JSON output example](https://i.imgur.com/nxViOe2.png)

```json
{
    "name": "Ultra Roof Repair Miami",
    "full_address": "333 SE 2nd Ave Suite #3995, Miami, FL 33131",
    "city": "Miami",
    "state": "FL",
    "state_full": "Florida",
    "zip_code": "33131",
    "country": "US",
    "latitude": 25.7712953,
    "longitude": -80.1897732,
    "rating": 4.9,
    "review_count": 312,
    "phone": "(305) 676-8110",
    "phone_international": "+13056768110",
    "website": "https://ultraroofrepair.com/miami/",
    "categories": ["Roofing contractor"],
    "place_id": "ChIJpTgec7232YgRl8EICVm7KUU",
    "place_id_hex": "0x88d8b6f77e9e3893:0x554a7bb79088c197",
    "neighborhood": "Downtown Miami",
    "timezone": "America/New_York",
    "maps_path": "/g/11bzq4h5m3",
    "google_maps_url": "https://www.google.com/maps/place/?q=place_id:ChIJpTgec7232YgRl8EICVm7KUU",
    "thumbnail_url": "https://lh3.googleusercontent.com/...",
    "hours_today": "8 AM–5 PM",
    "open_now_text": "Closed · Opens 8 AM",
    "attributes": ["Women-owned"],
    "accessibility": ["Wheelchair accessible entrance", "Wheelchair accessible parking lot"],
    "query": "roof repair services in miami, FL, USA",
    "scraped_at": "2026-05-19T10:22:31.445Z"
}
````

### Output fields

| Field | Type | Description |
|-------|------|-------------|
| `name` | string | Business name as listed on Google Maps |
| `full_address` | string | Complete street address including city, state, and ZIP |
| `city` | string | City extracted from the address |
| `state` | string | State abbreviation (e.g. FL, NY, CA) |
| `state_full` | string | Full state name (e.g. Florida, New York, California) |
| `zip_code` | string | ZIP or postal code |
| `country` | string | Two-letter country code (e.g. US, GB) |
| `latitude` | number | GPS latitude coordinate |
| `longitude` | number | GPS longitude coordinate |
| `rating` | number | Average star rating (1.0 to 5.0) |
| `review_count` | integer | Total number of Google Maps reviews |
| `phone` | string | Phone in local format, e.g. (305) 555-1234 |
| `phone_international` | string | Phone in international format, e.g. +13055551234 |
| `website` | string | Business website URL |
| `categories` | array | Business category labels from Google Maps |
| `place_id` | string | Unique Google Maps place identifier (ChIJ... format) |
| `place_id_hex` | string | Hexadecimal internal place identifier |
| `neighborhood` | string | Neighborhood or district name |
| `timezone` | string | IANA timezone, e.g. America/New\_York |
| `maps_path` | string | Short Google Maps path, e.g. /g/abc123 |
| `google_maps_url` | string | Direct Google Maps URL for this business |
| `thumbnail_url` | string | Business thumbnail image URL from Google |
| `hours_today` | string | Today's hours, e.g. 8 AM–5 PM or Open 24 hours |
| `open_now_text` | string | Current status, e.g. Open or Closed · Opens 8 AM |
| `attributes` | array | Identity labels: Women-owned, LGBTQ+ friendly, Veteran-owned, etc. |
| `accessibility` | array | Accessibility features: Wheelchair accessible entrance, etc. |
| `query` | string | The search query that returned this result |
| `scraped_at` | string | ISO 8601 timestamp of when this record was collected |

### Input

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `searchQueries` | array | required | One or more search queries. Each can return up to 200 results. |
| `language` | string | `en` | Language code for results (e.g. `en`, `es`, `fr`, `ja`). |
| `country` | string | `us` | Two-letter country code to localize results (e.g. `us`, `gb`, `ca`). |
| `maxResultsPerQuery` | integer | `200` | Max results per query. The actor paginates automatically. |
| `maxTotalResults` | integer | `2000000` | Total result cap across all queries per run. |
| `proxyConfiguration` | object | Datacenter (Anywhere) | Proxy type and location. Supports Datacenter, Residential, and custom proxies. Optional. |

#### Example input

```json
{
    "searchQueries": [
        "roof repair services in miami, FL, USA",
        "plumbers in los angeles, CA",
        "dentist near downtown chicago, IL",
        "plumbers near 90210",
        "restaurants near zip 10001 New York",
        "coffee shops near Times Square New York",
        "electricians in 77001 Houston TX",
        "italian restaurants in new york, NY",
        "real estate agents in houston, TX",
        "lawyers in washington, DC",
        "auto repair shops in phoenix, AZ",
        "gyms near boston, MA",
        "electricians in seattle, WA",
        "hotels in las vegas, NV",
        "wedding photographers in atlanta, GA",
        "pediatricians in dallas, TX",
        "dog groomers in denver, CO",
        "landscaping services in portland, OR",
        "plumber repair in London, UK",
        "gyms near 94102 San Francisco CA"
    ],
    "language": "en",
    "country": "us",
    "maxResultsPerQuery": 200,
    "proxyConfiguration": { "useApifyProxy": true }
}
```

### Use cases

- **Lead generation**: build targeted B2B or B2C prospect lists for any business type and city — contractors, dentists, lawyers, gyms, restaurants — without manual searching
- **Sales prospecting**: collect names, phone numbers, and websites for cold outreach campaigns across specific zip codes or neighborhoods
- **Market research**: map competitor density by running the same category query across multiple cities or ZIP codes and comparing result counts and ratings
- **Local SEO benchmarking**: pull star ratings and review counts for every competitor in a category to see where your listing stands
- **CRM enrichment**: append verified addresses, phone numbers, and Google Maps links to existing contact records using place IDs
- **Real estate research**: find businesses near a target property by querying specific zip codes — schools, shops, restaurants, transit — to build a neighborhood profile
- **Franchise scouting**: identify gaps in coverage for a specific category by querying multiple cities and looking for underserved areas
- **Event planning**: find vendors, venues, caterers, and photographers in a specific city or neighborhood in one batch run
- **Directory building**: collect complete business listings for a geographic area to power a local directory or maps application
- **International research**: works across countries — switch `country` and `language` to collect listings in the UK, Canada, Japan, Germany, and more

### Pricing

$0.50 per 1,000 results. Default cap is 2,000,000 results per run. Add more queries to collect more data.

### Integrations

Connect Google Maps Scraper with other tools via [Apify integrations](https://apify.com/integrations). Works with Make, Zapier, Slack, Airbyte, GitHub, Google Sheets, Google Drive, and others. [Webhooks](https://docs.apify.com/integrations/webhooks) let you trigger downstream actions the moment results are ready.

### FAQ

**How many results does each query return?**
Up to 200 per query by default. The actor paginates automatically to reach this number. If Google has fewer results for a specific query, you get whatever is available — the actor stops cleanly when there's nothing left.

**Can I search by ZIP code instead of city?**
Yes. Queries like `"plumbers near 90210"` or `"dentists in zip 10001 New York"` work the same as city-name queries.

**Can I run many queries at once?**
Yes, up to 5 run in parallel. Pass in hundreds and they process in batches automatically.

**Are duplicates removed?**
Yes. Results are deduplicated by Google Maps place ID across all queries in the same run. If the same business appears in two queries, you get one record.

**Does it work for countries outside the US?**
Yes. Set `language` and `country` to match your target region. For example, `language: "en"`, `country: "gb"` for the UK, or `language: "ja"`, `country: "jp"` for Japan. Phone numbers and addresses are returned in local format.

**Do I need a Google API key?**
No. Just provide your queries and run.

**What proxies should I use?**
Datacenter proxies work for most cases. If you see empty results or partial data, switch to Residential proxies in the proxy settings.

**Results arrive progressively — is that expected?**
Yes. The actor pushes each page of results to the dataset as it collects them, so you see data appear immediately rather than waiting for the full run to finish.

[![Try Google Maps Scraper](https://i.imgur.com/UdE6VNB.png)](https://apify.com/kawsarlog/google-maps-scraper)

# Actor input Schema

## `searchQueries` (type: `array`):

One or more Google Maps search queries. Each query can return up to 200 results. Use specific phrases like 'plumbers in Austin, TX', 'dentist near 10001', or 'restaurants in downtown Chicago, IL' for best results.

## `language` (type: `string`):

Language code for results (e.g. 'en' for English, 'es' for Spanish, 'fr' for French, 'ja' for Japanese). Affects the language of returned business names and addresses.

## `country` (type: `string`):

Two-letter country code to localize results (e.g. 'us', 'gb', 'ca', 'au', 'jp'). Use this to bias results toward a specific country.

## `maxResultsPerQuery` (type: `integer`):

Maximum number of results to collect per search query. The actor paginates automatically to reach this number. Fewer results are returned if Google has less data for that query.

## `maxTotalResults` (type: `integer`):

Maximum total results to collect across all queries in one run. Use this as a safety cap for large query lists.

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

Select proxies to use for requests. Helps avoid IP blocking and rate limits. Datacenter proxies are fastest; Residential proxies are harder to detect.

## Actor input object example

```json
{
  "searchQueries": [
    "roof repair services in miami, FL, USA",
    "dentist near downtown chicago, IL",
    "plumbers near 90210",
    "restaurants near zip 10001 New York",
    "lawyers in washington, DC",
    "coffee shops near Times Square New York",
    "electricians in 77001 Houston TX",
    "italian restaurants in new york, NY",
    "real estate agents in houston, TX",
    "auto repair shops in phoenix, AZ",
    "gyms near boston, MA",
    "electricians in seattle, WA",
    "hotels in las vegas, NV",
    "wedding photographers in atlanta, GA",
    "dog groomers in denver, CO",
    "landscaping services in portland, OR",
    "plumber repair in London, UK",
    "restaurants in Tokyo Japan",
    "pediatricians in dallas, TX",
    "gyms near 94102 San Francisco CA"
  ],
  "language": "en",
  "country": "us",
  "maxResultsPerQuery": 200,
  "maxTotalResults": 2000000,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# 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 = {
    "searchQueries": [
        "restaurants near zip 10001 New York",
        "italian restaurants in new york, NY"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("coder_luffy/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 = {
    "searchQueries": [
        "restaurants near zip 10001 New York",
        "italian restaurants in new york, NY",
    ],
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("coder_luffy/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 '{
  "searchQueries": [
    "restaurants near zip 10001 New York",
    "italian restaurants in new york, NY"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call coder_luffy/google-maps-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Google Maps Scraper $0.50 Per 1K",
        "description": "Google Maps Scraper collects business listings from Google Maps search results, returning names, addresses, phone numbers, websites, ratings, and GPS coordinates for any business type and location",
        "version": "0.0",
        "x-build-id": "724ytPtNAdfu3QsFN"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/coder_luffy~google-maps-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-coder_luffy-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/coder_luffy~google-maps-scraper/runs": {
            "post": {
                "operationId": "runs-sync-coder_luffy-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/coder_luffy~google-maps-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-coder_luffy-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": [
                    "searchQueries"
                ],
                "properties": {
                    "searchQueries": {
                        "title": "Search queries",
                        "type": "array",
                        "description": "One or more Google Maps search queries. Each query can return up to 200 results. Use specific phrases like 'plumbers in Austin, TX', 'dentist near 10001', or 'restaurants in downtown Chicago, IL' for best results.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "language": {
                        "title": "Language",
                        "type": "string",
                        "description": "Language code for results (e.g. 'en' for English, 'es' for Spanish, 'fr' for French, 'ja' for Japanese). Affects the language of returned business names and addresses.",
                        "default": "en"
                    },
                    "country": {
                        "title": "Country",
                        "type": "string",
                        "description": "Two-letter country code to localize results (e.g. 'us', 'gb', 'ca', 'au', 'jp'). Use this to bias results toward a specific country.",
                        "default": "us"
                    },
                    "maxResultsPerQuery": {
                        "title": "Max results per query",
                        "minimum": 1,
                        "maximum": 400,
                        "type": "integer",
                        "description": "Maximum number of results to collect per search query. The actor paginates automatically to reach this number. Fewer results are returned if Google has less data for that query.",
                        "default": 200
                    },
                    "maxTotalResults": {
                        "title": "Max total results",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum total results to collect across all queries in one run. Use this as a safety cap for large query lists.",
                        "default": 2000000
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Select proxies to use for requests. Helps avoid IP blocking and rate limits. Datacenter proxies are fastest; Residential proxies are harder to detect."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
