# Google Maps Reviews Scraper (`khadinakbar/google-maps-reviews-scraper`) Actor

Scrape all reviews from any Google Maps place by URL, Place ID, CID, or business name. Get rating, text, reviewer, date, owner response, and sentiment hint.

- **URL**: https://apify.com/khadinakbar/google-maps-reviews-scraper.md
- **Developed by:** [Khadin Akbar](https://apify.com/khadinakbar) (community)
- **Categories:** Lead generation, SEO tools, MCP servers
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.30 / 1,000 review scrapeds

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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 Reviews Scraper — Ratings, Text, Owner Replies

**What it does:** Extract every review from any Google Maps place in structured JSON — rating, text, reviewer, date, owner reply, and a rating-derived sentiment bucket. Accepts Google Maps URLs, Place IDs, CIDs, or a business name plus location.

**When to use it:** reputation monitoring, competitive review research, sentiment analysis, AI-agent workflows that need review data for a specific place. **Do NOT use it** for finding business lead contact info — that lives in [`khadinakbar/google-maps-leads-scraper`](https://apify.com/khadinakbar/google-maps-leads-scraper).

---

### Output at a glance

| Field | Type | Example |
|---|---|---|
| `reviewId` | string | `ChZDSUhNMG9nS0VJQ0FnSURwLVlPajJBRRAB` |
| `placeName` | string | `Joe's Pizza` |
| `placeUrl` | string | `https://www.google.com/maps/place/...` |
| `placeAddress` | string | `7 Carmine St, New York, NY 10014` |
| `placeRating` | number | `4.6` |
| `placeReviewCount` | integer | `12,847` |
| `rating` | integer (1–5) | `5` |
| `text` | string | `Best slice in the Village — the classic is unreal.` |
| `publishedAtText` | string | `a month ago` |
| `publishedAt` | ISO-8601 | `2026-03-25T13:24:00.000Z` |
| `ownerResponse` | string\|null | `Thanks for visiting!` |
| `sentimentHint` | string | `positive` / `neutral` / `negative` |
| `photos` | string[] | image URLs attached to the review |
| `likesCount` | integer | `3` |
| `reviewerName` | string\|null | null unless `includePersonalData: true` |
| `reviewUrl` | string | permalink to this review |
| `scrapedAt` | ISO-8601 | timestamp of extraction |

`sentimentHint` is rating-derived (4–5 positive, 3 neutral, 1–2 negative) — not ML-based. Feed the `text` into your own NLP pipeline for true sentiment.

---

### Pricing — $0.30 per 1,000 reviews

| Event | Price | When charged |
|---|---|---|
| Actor start | $0.00005 | One-time per GB of memory at run start |
| Review scraped | $0.0003 | Per individual review pushed to the dataset |

**Typical costs:**
- 100 reviews: **~$0.03**
- 500 reviews: **~$0.15**
- 5,000 reviews: **~$1.50**

No tiered games. Same price whether you're on Apify FREE or DIAMOND. Cheaper than most competitors (compass FREE tier charges $0.60/1K, `api-ninja` $0.30/1K, `memo23` effectively $0.32/1K including its $0.07 start fee).

---

### Inputs

You must provide **one** of:

- `startUrls` — array of Google Maps URLs (place URLs, search URLs, CID URLs).
- `placeIds` — array of Place IDs (e.g., `ChIJ...`).
- `searchQuery` + optional `location` — business name and city/region; the scraper clicks through to the first matching place.

Optional parameters:

| Param | Default | Notes |
|---|---|---|
| `maxReviews` | `100` | Cap per place. Google typically exposes up to ~4,000 reviews even for very popular places. |
| `reviewsSort` | `newest` | `newest` \| `mostRelevant` \| `highestRanking` \| `lowestRanking` |
| `language` | `en` | UI language for Google Maps; affects relative-date labels. |
| `includePersonalData` | `false` | GDPR toggle — when false, `reviewerName`, `reviewerUrl`, and `reviewerPhotoUrl` are nulled. Enable only if you have a legitimate basis under your applicable privacy law. |
| `proxyConfiguration` | Apify Residential | Do not override unless you know your proxy handles Google. |

---

### Usage

#### Via the Apify UI

Paste a Google Maps URL into `startUrls`, set `maxReviews`, and hit Start.

#### Via the Apify API (Node.js)

```js
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });

const run = await client.actor('khadinakbar/google-maps-reviews-scraper').call({
    startUrls: [
        { url: 'https://www.google.com/maps/place/Joe%27s+Pizza/@40.7299934,-74.0025633,17z' },
    ],
    maxReviews: 200,
    reviewsSort: 'newest',
    language: 'en',
    includePersonalData: false,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
````

#### Via the Apify API (Python)

```python
from apify_client import ApifyClient

client = ApifyClient(token="APIFY_TOKEN")

run = client.actor("khadinakbar/google-maps-reviews-scraper").call(run_input={
    "startUrls": [{"url": "https://www.google.com/maps/place/Joe%27s+Pizza/..."}],
    "maxReviews": 200,
    "reviewsSort": "newest",
})

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["rating"], item["text"])
```

#### Via MCP (AI agents)

The actor is exposed on Apify MCP as `apify--google-maps-reviews-scraper`. Claude, GPT, and other agents can call it directly with a Google Maps URL to pull reviews for reasoning.

```
https://mcp.apify.com?tools=khadinakbar/google-maps-reviews-scraper
```

***

### Use cases

- **Reputation monitoring** — watch a single location's newest reviews.
- **Competitive analysis** — pull ratings and text from a competitor's flagship store.
- **Sentiment mining** — feed `text` into an NLP pipeline; `rating` gives a clean supervised label.
- **Owner-reply auditing** — agencies verifying their clients are replying to negatives.
- **AI agent research** — chain with `khadinakbar/google-maps-leads-scraper` to pull business + reviews in one flow.

***

### Frequently asked

**How many reviews can I get per place?** Google typically caps accessible reviews at ~3,500–4,000 even for places with tens of thousands. Use `maxReviews` to set your own cap.

**Is this compliant?** The scraper reads publicly visible reviews. `includePersonalData` defaults to `false` so reviewer names and profile URLs are stripped by default. If you enable it, you are responsible for your legal basis (GDPR Article 6 / equivalent in your jurisdiction).

**Why don't dates match exactly?** Google shows relative dates ("a month ago"). `publishedAt` is an ISO approximation derived from that label — not a precise timestamp. The source of truth is `publishedAtText`.

**My run returned 0 reviews — what happened?** Most common causes: (1) the URL was a search URL that returned no matches, (2) Google temporarily served a consent/captcha page that we couldn't dismiss, (3) the place has no reviews. Re-run with a direct place URL if in doubt.

**Can I schedule this?** Yes — use Apify Schedules to run daily or weekly and diff the dataset against the previous run.

***

### Legal

The Actor extracts publicly available reviews from Google Maps. You are responsible for complying with Google's Terms of Service and all applicable data-protection laws (GDPR, CCPA, etc.) when using the extracted data. The author is not affiliated with Google.

***

### Related actors by the same author

- [Google Maps Leads Scraper — Emails, Phones & B2B Leads](https://apify.com/khadinakbar/google-maps-leads-scraper)
- [B2B Lead Finder + Enrichment](https://apify.com/khadinakbar/b2b-lead-finder-enrichment)
- [Google Shopping Scraper](https://apify.com/khadinakbar/google-shopping-scraper)
- See the full portfolio at [apify.com/khadinakbar](https://apify.com/khadinakbar).

# Actor input Schema

## `startUrls` (type: `array`):

List of Google Maps URLs to scrape reviews from. Accepts place URLs (https://www.google.com/maps/place/...), search URLs, CID URLs (?cid=...), and shortened maps.app.goo.gl links. Each URL yields reviews for one place. Do NOT paste Google Search result URLs — only maps.google.com / google.com/maps URLs are supported.

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

Google Place IDs (format ChIJ... or 0x...:0x...). Each is resolved to a place page and its reviews are scraped. Example: 'ChIJLU7jZClu5kcR4PcOOO\_ouTY' for Eiffel Tower. Leave empty if you are providing startUrls — either input works.

## `searchQuery` (type: `string`):

Free-text business name or keyword (e.g., 'Joe's Pizza Manhattan' or 'Apple Store Regent Street'). Used with the location field to find one place and scrape its reviews. Leave empty if you are providing startUrls or placeIds — do NOT use this for broad searches, use a specific business name.

## `location` (type: `string`):

City, region, or country used to disambiguate the searchQuery (e.g., 'New York, NY' or 'London, UK'). Ignored when startUrls or placeIds are provided. Leave empty for global search on searchQuery.

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

Maximum reviews to scrape per place. Use 10–50 for testing, 100–500 for typical monitoring, 1000+ for deep analysis. Google usually caps accessible reviews at around 4000 even for high-volume places. Billing is per review scraped, so set this to match your budget.

## `reviewsSort` (type: `string`):

Order in which reviews are fetched from Google. 'newest' is best for monitoring recent feedback, 'mostRelevant' matches Google's default, 'highestRanking' / 'lowestRanking' for best/worst first. Affects which reviews you hit the maxReviews cap on.

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

Language for the Google Maps UI and for review translations. 'en' returns English UI, reviews stay in their original language. Affects Google's 'N reviews' parsing and the text of the 'a month ago' date labels.

## `includePersonalData` (type: `boolean`):

When true, includes reviewer name, profile URL, and profile photo URL. When false (default), these are nulled out and only a stable reviewer hash is returned. Personal data is regulated by GDPR in the EU — keep disabled unless you have a legitimate purpose and documented basis. reviewId is always returned regardless of this setting.

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

Proxy used to scrape Google Maps. Defaults to Apify Residential proxy which bypasses most Google bot checks. Do not override unless you know your proxy can handle Google.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.google.com/maps/place/?q=place_id:ChIJLU7jZClu5kcR4PcOOO_ouTY"
    }
  ],
  "placeIds": [],
  "searchQuery": "Joe's Pizza Manhattan",
  "location": "New York, NY",
  "maxReviews": 100,
  "reviewsSort": "newest",
  "language": "en",
  "includePersonalData": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `reviews` (type: `string`):

One record per review. Fields follow the dataset\_schema.json definitions.

## `debugScreenshots` (type: `string`):

JPEG snapshots captured when extraction could not locate the place panel.

# 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 = {
    "startUrls": [
        {
            "url": "https://www.google.com/maps/place/?q=place_id:ChIJLU7jZClu5kcR4PcOOO_ouTY"
        }
    ],
    "maxReviews": 100,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("khadinakbar/google-maps-reviews-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 = {
    "startUrls": [{ "url": "https://www.google.com/maps/place/?q=place_id:ChIJLU7jZClu5kcR4PcOOO_ouTY" }],
    "maxReviews": 100,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("khadinakbar/google-maps-reviews-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 '{
  "startUrls": [
    {
      "url": "https://www.google.com/maps/place/?q=place_id:ChIJLU7jZClu5kcR4PcOOO_ouTY"
    }
  ],
  "maxReviews": 100,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call khadinakbar/google-maps-reviews-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Google Maps Reviews Scraper",
        "description": "Scrape all reviews from any Google Maps place by URL, Place ID, CID, or business name. Get rating, text, reviewer, date, owner response, and sentiment hint.",
        "version": "0.2",
        "x-build-id": "cDqa7f6IZMmW4hbf6"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/khadinakbar~google-maps-reviews-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-khadinakbar-google-maps-reviews-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/khadinakbar~google-maps-reviews-scraper/runs": {
            "post": {
                "operationId": "runs-sync-khadinakbar-google-maps-reviews-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/khadinakbar~google-maps-reviews-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-khadinakbar-google-maps-reviews-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": {
                    "startUrls": {
                        "title": "🔗 Google Maps URLs",
                        "type": "array",
                        "description": "List of Google Maps URLs to scrape reviews from. Accepts place URLs (https://www.google.com/maps/place/...), search URLs, CID URLs (?cid=...), and shortened maps.app.goo.gl links. Each URL yields reviews for one place. Do NOT paste Google Search result URLs — only maps.google.com / google.com/maps URLs are supported.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "placeIds": {
                        "title": "🗂 Place IDs",
                        "type": "array",
                        "description": "Google Place IDs (format ChIJ... or 0x...:0x...). Each is resolved to a place page and its reviews are scraped. Example: 'ChIJLU7jZClu5kcR4PcOOO_ouTY' for Eiffel Tower. Leave empty if you are providing startUrls — either input works.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "searchQuery": {
                        "title": "🔍 Search Query (alternative to URLs)",
                        "type": "string",
                        "description": "Free-text business name or keyword (e.g., 'Joe's Pizza Manhattan' or 'Apple Store Regent Street'). Used with the location field to find one place and scrape its reviews. Leave empty if you are providing startUrls or placeIds — do NOT use this for broad searches, use a specific business name."
                    },
                    "location": {
                        "title": "📍 Location (with searchQuery)",
                        "type": "string",
                        "description": "City, region, or country used to disambiguate the searchQuery (e.g., 'New York, NY' or 'London, UK'). Ignored when startUrls or placeIds are provided. Leave empty for global search on searchQuery."
                    },
                    "maxReviews": {
                        "title": "⭐ Max reviews per place",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum reviews to scrape per place. Use 10–50 for testing, 100–500 for typical monitoring, 1000+ for deep analysis. Google usually caps accessible reviews at around 4000 even for high-volume places. Billing is per review scraped, so set this to match your budget.",
                        "default": 100
                    },
                    "reviewsSort": {
                        "title": "📅 Sort reviews by",
                        "enum": [
                            "newest",
                            "mostRelevant",
                            "highestRanking",
                            "lowestRanking"
                        ],
                        "type": "string",
                        "description": "Order in which reviews are fetched from Google. 'newest' is best for monitoring recent feedback, 'mostRelevant' matches Google's default, 'highestRanking' / 'lowestRanking' for best/worst first. Affects which reviews you hit the maxReviews cap on.",
                        "default": "newest"
                    },
                    "language": {
                        "title": "🌍 Language",
                        "enum": [
                            "en",
                            "es",
                            "fr",
                            "de",
                            "it",
                            "pt",
                            "nl",
                            "pl",
                            "ru",
                            "ja",
                            "ko",
                            "zh-CN",
                            "ar",
                            "tr",
                            "hi",
                            "id",
                            "vi",
                            "th",
                            "sv",
                            "no",
                            "da",
                            "fi",
                            "cs",
                            "el",
                            "he"
                        ],
                        "type": "string",
                        "description": "Language for the Google Maps UI and for review translations. 'en' returns English UI, reviews stay in their original language. Affects Google's 'N reviews' parsing and the text of the 'a month ago' date labels.",
                        "default": "en"
                    },
                    "includePersonalData": {
                        "title": "🔒 Include reviewer personal data (GDPR)",
                        "type": "boolean",
                        "description": "When true, includes reviewer name, profile URL, and profile photo URL. When false (default), these are nulled out and only a stable reviewer hash is returned. Personal data is regulated by GDPR in the EU — keep disabled unless you have a legitimate purpose and documented basis. reviewId is always returned regardless of this setting.",
                        "default": false
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Proxy used to scrape Google Maps. Defaults to Apify Residential proxy which bypasses most Google bot checks. Do not override unless you know your proxy can handle Google.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
