# Google Maps Places Scraper (`jdtpnjtp/google-maps-places-scraper`) Actor

Scrape Google Maps places by text, nearby or radius search, plus place details. Extract name, category, rating, reviews count, phone, website, address, coordinates and hours. Keywords, coordinates or place IDs in. Pay per result.

- **URL**: https://apify.com/jdtpnjtp/google-maps-places-scraper.md
- **Developed by:** [Data Forge](https://apify.com/jdtpnjtp) (community)
- **Categories:** Lead generation, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.50 / 1,000 place results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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 Places Scraper

Extract Google Maps places at scale, by keyword and by identifier, and turn local listings into clean structured rows. **Places from $0.76 / 1,000 results.** Sweep hundreds of search terms across dozens of cities in one run and pull thousands of business records without a Google Maps API key, quota dashboard or subscription.

The Google Maps Places Scraper covers three search modes plus place detail enrichment, so you can build a lead list, map a market or feed a data pipeline straight from Apify.

### What does the Google Maps Places Scraper do?

It queries Google Maps and returns one flat row per place. Pick a mode based on how you want to target results:

| Mode | What it returns | Best for |
|---|---|---|
| Text search | Places matching a keyword, centered on a map point | "coffee in Brooklyn", "dentist", broad keyword sweeps |
| Nearby search | Places around an exact lat/lng point | mapping a single neighborhood or POI cluster |
| Radius search | Places within a set distance (50 m to 200 km) of a point | precise catchment areas and territory planning |
| Place details | One rich record per identifier (name, URL, place_id, feature id, CID or coordinates) | enriching a known list of businesses |

Turn on "Fan out search results to place detail" and the scraper enriches each listing with a second detail pass, adding status, timezone, plus code and the deeper payload.

### What data can you get from Google Maps?

Each place row carries the fields buyers ask for most:

- **Name** - business name
- **Category** - primary category (Coffee shop, Hotel, Dentist)
- **Rating** - average star rating 1.0 to 5.0
- **Reviews count** - number of reviews
- **Phone** - listed phone number
- **Website** - official website URL
- **Address** - single-line street address
- **Coordinates** - latitude and longitude
- **Price range** - $ to $$$$ price level
- **Place ID / Feature ID / CID** - stable Google identifiers
- **Thumbnail** - representative image URL

Place-detail rows add **status** (operational state), **plus code**, **timezone**, and a `data` payload holding opening hours, attributes, photos and the rest of the place object.

### How to scrape Google Maps places

1. Open the Google Maps Places Scraper and look at the input form. The **Search queries** field is prefilled with `coffee`, so you can click **Start** and get real rows on the first run with zero typing.
2. Replace the prefill with your own keywords (one per line), or paste Place identifiers to resolve known businesses.
3. Choose a **Search type** - text, nearby or radius - and set the center latitude and longitude (required for nearby and radius).
4. Set **Max results per query** (1 to 100) and apply optional filters: minimum rating, price level, open now.
5. Toggle **Fan out search results to place detail** when you want the deeper record per place.
6. Click **Start**, then export the dataset as JSON, CSV, Excel or Google Sheets, or pull it from the Apify API.

#### Input example

```json
{
  "searchQueries": ["coffee", "specialty coffee roaster"],
  "searchType": "text",
  "latitude": "40.7128",
  "longitude": "-74.0060",
  "maxResults": 40,
  "ratingMin": "4.0",
  "includePlaceDetails": false
}
````

#### Output example

A search listing row (`row_type: place_result`):

```json
{
  "query": "coffee",
  "row_type": "place_result",
  "place_id": "ChIJ2WrMN9MFv5kRrHkZxnG8nq4",
  "data_id": "0x89c259a9b3117469:0x64df84a3a3f0e0d3",
  "name": "Blue Bottle Coffee",
  "address": "54 Mint St, New York, NY 10013",
  "rating": 4.5,
  "review_count": 1287,
  "category": "Coffee shop",
  "price_range": "$$",
  "phone": "+1 510-653-3394",
  "website": "https://bluebottlecoffee.com",
  "latitude": 40.7211,
  "longitude": -74.0021,
  "thumbnail": "https://lh5.googleusercontent.com/p/AF1QipM=w408-h306-k-no"
}
```

A place-detail row (`row_type: place_detail`):

```json
{
  "query": "Blue Bottle Coffee",
  "row_type": "place_detail",
  "place_id": "ChIJ2WrMN9MFv5kRrHkZxnG8nq4",
  "data_id": "0x89c259a9b3117469:0x64df84a3a3f0e0d3",
  "cid": "7268823264583647443",
  "name": "Blue Bottle Coffee",
  "address": "54 Mint St, New York, NY 10013, United States",
  "rating": 4.5,
  "review_count": 1287,
  "category": "Coffee shop",
  "price_range": "$$",
  "phone": "+1 510-653-3394",
  "website": "https://bluebottlecoffee.com",
  "latitude": 40.7211,
  "longitude": -74.0021,
  "thumbnail": "https://lh5.googleusercontent.com/p/AF1QipM=w408-h306-k-no",
  "status": "OPERATIONAL",
  "plus_code": "87G7PXRW+9C",
  "timezone": "America/New_York"
}
```

### How much does it cost to scrape Google Maps places?

Pricing is pay per result, so you only pay for the rows you keep:

- **Place result** - $0.00076 per listing row, or **$0.76 / 1,000 places**.
- **Place detail** - $0.0013 per detail row, or **$1.30 / 1,000 places**.

Your **$5 in free Apify credits** covers about **6,500 place rows** (5 / 0.00076) before you spend a cent. A listing-only run of 10,000 places costs $7.60. Error rows and your own bad input are never charged.

### What can you use Google Maps places data for?

- **Local lead generation** - build call lists of businesses with phone, website and address by category and city.
- **Sales territory planning** - map prospects inside a radius around a branch or sales rep.
- **Market research** - size a category (how many gyms, clinics or cafes) in a metro and compare ratings.
- **Competitor monitoring** - track rivals' ratings, review counts and price levels over time.
- **Data enrichment** - resolve a list of place names or URLs into clean records with coordinates and IDs.
- **Store locator and directory feeds** - power maps, listings and apps with structured place data.
- **Real estate and site selection** - score neighborhoods by nearby amenities and demand signals.

### Is it legal to scrape Google Maps?

Yes. The Google Maps Places Scraper collects only public business information that anyone can view on Google Maps without logging in. It does not touch private accounts or protected data. You stay responsible for how you use the output: review GDPR, CCPA and local rules before processing personal data, and follow Google's terms of service. For high-volume or sensitive projects, check with your legal team first.

### Related scrapers

Part of the Data Forge Google Maps fleet:

- **Google Maps Scraper** - the umbrella actor for end-to-end Maps scraping across places, emails and reviews.
- **Google Maps Email Extractor** - find business emails behind Maps listings for lead generation.
- **Google Maps Reviews Scraper** - pull review text, ratings and reviewer data per place.

### FAQ

**Do I need a Google Maps API key?**
No. There is no Google key, billing project or quota dashboard to set up. The scraper handles data collection for you.

**Can I run it from the API or a script?**
Yes. Start runs and fetch the dataset through the Apify API, the Apify client SDKs, scheduler and webhooks, or the Apify MCP server for AI agents.

**What is the difference between place\_result and place\_detail rows?**
Place-result rows come from a search and carry core listing fields. Place-detail rows are richer single-place records with status, timezone, plus code and the deeper payload. Use `row_type` to tell them apart.

**How many places can I get per query?**
Up to 100 per search query. Run many queries or cities in one input to scale into the thousands.

**What export formats are supported?**
JSON, CSV, Excel, HTML and Google Sheets from the Console, plus programmatic access via the Apify API.

**Why are some fields null?**
Google does not list the same fields across places (some have no phone, website or price). Null means Google exposed no value, not a scraping error.

### Support

Built and maintained by **Data Forge**. Need custom fields, higher volume or a quick answer?

[![Telegram](https://img.shields.io/badge/Telegram-Chat-26A5E4?style=for-the-badge\&logo=telegram\&logoColor=white)](https://t.me/j4dtpnj2tp)
[![WhatsApp](https://img.shields.io/badge/WhatsApp-Message-25D366?style=for-the-badge\&logo=whatsapp\&logoColor=white)](https://wa.me/380686031542)
[![Email](https://img.shields.io/badge/Email-Contact-EA4335?style=for-the-badge\&logo=gmail\&logoColor=white)](mailto:jdtpnjtp@gmail.com)

# Actor input Schema

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

Keyword searches (e.g. `coffee`, `italian restaurants`, `dentist`). Each query is run with the search type and center below and returns matching places. Optional if you provide Place identifiers.

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

Resolve specific places to full detail. Each item can be a place name, a Google Maps URL, a place\_id (ChIJ...), a feature id (0x...:0x...), a numeric CID, or `lat,lng` coordinates. Each returns one full place-details row.

## `searchType` (type: `string`):

How keyword searches run. Text = map search centered on the coordinates below. Nearby = places around a point. Radius = places within a distance of a point.

## `latitude` (type: `string`):

Latitude of the search center (e.g. 40.7128). Required for Nearby and Radius search; optional for Text (defaults near New York - put the city in your query for other locations).

## `longitude` (type: `string`):

Longitude of the search center (e.g. -74.0060). Required for Nearby and Radius search.

## `radiusMeters` (type: `integer`):

Search radius in meters for Radius search (50 to 200000).

## `zoom` (type: `integer`):

Map zoom for Text / Nearby search (13 = city, 15 = neighborhood, 17 = street).

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

Upper bound on places returned per search query (1 to 100). 20 = quick sample, 60 = solid dataset.

## `includePlaceDetails` (type: `boolean`):

When on, every place from a search row is enriched with a second call pulling its full place page (address, hours, attributes, owner info). This adds a place-details charge per result on top of the listing event. Leave off for a fast, cheap listing-only run.

## `ratingMin` (type: `string`):

Keep only places at or above this average rating (text search only).

## `priceLevel` (type: `string`):

Keep only places at this price level (text search only).

## `openNow` (type: `boolean`):

Keep only places open right now (text search, best-effort).

## Actor input object example

```json
{
  "searchQueries": [
    "coffee"
  ],
  "placeIds": [],
  "searchType": "text",
  "radiusMeters": 1000,
  "zoom": 14,
  "maxResults": 20,
  "includePlaceDetails": false,
  "ratingMin": "",
  "priceLevel": "",
  "openNow": false
}
```

# Actor output Schema

## `dataset` (type: `string`):

The default dataset. Each row carries one result discriminated by row\_type, with common fields flattened to top-level columns and the full payload under `data`. Use the Overview / Places / Details tabs to view per-vertical tables.

## `summary` (type: `string`):

A single JSON object written to the default key-value store under the OUTPUT key. Contains place\_results, place\_details, errors, total\_rows, estimated\_cost\_usd, limit\_reached and actor\_version.

# 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": [
        "coffee"
    ],
    "placeIds": [],
    "maxResults": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("jdtpnjtp/google-maps-places-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": ["coffee"],
    "placeIds": [],
    "maxResults": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("jdtpnjtp/google-maps-places-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": [
    "coffee"
  ],
  "placeIds": [],
  "maxResults": 20
}' |
apify call jdtpnjtp/google-maps-places-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Google Maps Places Scraper",
        "description": "Scrape Google Maps places by text, nearby or radius search, plus place details. Extract name, category, rating, reviews count, phone, website, address, coordinates and hours. Keywords, coordinates or place IDs in. Pay per result.",
        "version": "1.0",
        "x-build-id": "iahqipsB4j1c7NqN5"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/jdtpnjtp~google-maps-places-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-jdtpnjtp-google-maps-places-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/jdtpnjtp~google-maps-places-scraper/runs": {
            "post": {
                "operationId": "runs-sync-jdtpnjtp-google-maps-places-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/jdtpnjtp~google-maps-places-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-jdtpnjtp-google-maps-places-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",
                "properties": {
                    "searchQueries": {
                        "title": "Search queries",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Keyword searches (e.g. `coffee`, `italian restaurants`, `dentist`). Each query is run with the search type and center below and returns matching places. Optional if you provide Place identifiers.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "placeIds": {
                        "title": "Place identifiers",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Resolve specific places to full detail. Each item can be a place name, a Google Maps URL, a place_id (ChIJ...), a feature id (0x...:0x...), a numeric CID, or `lat,lng` coordinates. Each returns one full place-details row.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "searchType": {
                        "title": "Search type",
                        "enum": [
                            "text",
                            "nearby",
                            "radius"
                        ],
                        "type": "string",
                        "description": "How keyword searches run. Text = map search centered on the coordinates below. Nearby = places around a point. Radius = places within a distance of a point.",
                        "default": "text"
                    },
                    "latitude": {
                        "title": "Center latitude",
                        "type": "string",
                        "description": "Latitude of the search center (e.g. 40.7128). Required for Nearby and Radius search; optional for Text (defaults near New York - put the city in your query for other locations)."
                    },
                    "longitude": {
                        "title": "Center longitude",
                        "type": "string",
                        "description": "Longitude of the search center (e.g. -74.0060). Required for Nearby and Radius search."
                    },
                    "radiusMeters": {
                        "title": "Radius (meters)",
                        "minimum": 50,
                        "maximum": 200000,
                        "type": "integer",
                        "description": "Search radius in meters for Radius search (50 to 200000).",
                        "default": 1000
                    },
                    "zoom": {
                        "title": "Map zoom",
                        "minimum": 1,
                        "maximum": 21,
                        "type": "integer",
                        "description": "Map zoom for Text / Nearby search (13 = city, 15 = neighborhood, 17 = street).",
                        "default": 14
                    },
                    "maxResults": {
                        "title": "Max results per query",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Upper bound on places returned per search query (1 to 100). 20 = quick sample, 60 = solid dataset.",
                        "default": 20
                    },
                    "includePlaceDetails": {
                        "title": "Fan out search results to full place detail",
                        "type": "boolean",
                        "description": "When on, every place from a search row is enriched with a second call pulling its full place page (address, hours, attributes, owner info). This adds a place-details charge per result on top of the listing event. Leave off for a fast, cheap listing-only run.",
                        "default": false
                    },
                    "ratingMin": {
                        "title": "Minimum rating",
                        "enum": [
                            "",
                            "2.0",
                            "2.5",
                            "3.0",
                            "3.5",
                            "4.0",
                            "4.5"
                        ],
                        "type": "string",
                        "description": "Keep only places at or above this average rating (text search only).",
                        "default": ""
                    },
                    "priceLevel": {
                        "title": "Price level",
                        "enum": [
                            "",
                            "$",
                            "$$",
                            "$$$",
                            "$$$$"
                        ],
                        "type": "string",
                        "description": "Keep only places at this price level (text search only).",
                        "default": ""
                    },
                    "openNow": {
                        "title": "Open now only",
                        "type": "boolean",
                        "description": "Keep only places open right now (text search, best-effort).",
                        "default": false
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
