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

Scrape Google Maps reviews at scale — no login, no limits.

- **URL**: https://apify.com/reviewly/google-maps-reviews-scraper.md
- **Developed by:** [Reviewly](https://apify.com/reviewly) (community)
- **Categories:** AI, Developer tools, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.25 / 1,000 record scrapeds

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 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 — Extract Reviews at Scale, No Login Required

> Scrape hundreds of Google Maps reviews per place in minutes. No Google account, no API key, no limits. Get ratings, text, reviewer profiles, photos, and more — ready for analysis or export.

**Perfect for:** Reputation monitoring · Competitor research · Sentiment analysis · Lead generation · Market research

---

### 📌 What This Actor Does

This Actor extracts customer reviews from any Google Maps business listing. Paste one or more Google Maps URLs (or place IDs) and get back a structured dataset of reviews with ratings, text, dates, reviewer info, and photos.

**Who is it for?**
- **Marketing teams** tracking brand reputation across locations
- **Agencies** running competitor analysis for clients
- **Developers** building sentiment analysis or review aggregation tools
- **Data analysts** researching consumer trends and ratings

---

### ✨ Key Features

- **No authentication required** — works without a Google account or OAuth tokens
- **Bulk scraping** — process multiple places in a single run
- **Flexible input** — accepts Google Maps URLs, place IDs (hex, ChIJ, CID), or a mix of both
- **Sort control** — scrape by Newest, Most Relevant, Highest, or Lowest rated reviews
- **Date filtering** — stop pagination automatically when reviews are older than your cutoff date
- **Language filter** — return only reviews in a specific language (28 languages supported)
- **Auto-pagination** — fetches all pages automatically up to your `maxReviews` limit
- **Translation support** — captures Google's auto-translated text alongside the original
- **Photo URLs** — includes direct links to review photos
- **Privacy-ready** — toggle off personal data (reviewer names, profile URLs) to stay GDPR-compliant
- **Residential proxy support** — built-in proxy rotation to avoid blocks

---

### 🧠 Why This Actor is Different

| Feature | This Actor | Most Alternatives |
|---|---|---|
| No Google login needed | ✅ | ❌ Requires OAuth token |
| Bulk multi-place support | ✅ | Often single-place only |
| Auto-translated text | ✅ | ❌ |
| Language filter | ✅ 28 languages | ❌ |
| Date cutoff pagination | ✅ | ❌ |
| Reviewer stats (Local Guide, review count) | ✅ | ❌ |
| Photo URLs per review | ✅ | Rarely |
| GDPR personalData gate | ✅ | ❌ |

Most Google Maps review scrapers on the market require you to supply a personal Google OAuth refresh token, which ties the scraper to your own account and risks account bans. This Actor requires **no authentication at all** — it uses the same public API key bundled in the Google Maps iOS app, so your account is never at risk.

---

### ⚙️ Input Configuration

#### Input Fields

| Field | Type | Default | Description |
|---|---|---|---|
| `startUrls` | array | — | Google Maps place URLs to scrape |
| `placeIds` | array | — | Place IDs in any supported format |
| `maxReviews` | integer | `100` | Max reviews to scrape per place (1–10,000) |
| `reviewsSort` | select | `newest` | Sort order for reviews |
| `reviewsStartDate` | string | — | Stop scraping reviews older than this date (`YYYY-MM-DD`) |
| `language` | select | All | Filter reviews by language |
| `personalData` | boolean | `true` | Include reviewer name, profile URL, avatar |
| `proxyConfiguration` | object | Residential | Apify proxy settings |

#### Supported Place ID Formats

You can pass places using **any** of these formats in `startUrls` or `placeIds`:

````

https://www.google.com/maps/place/Eiffel+Tower/@48.8584...   ← Google Maps URL
ChIJN1t\_tDeuEmsRUsoyG83frY4                                  ← ChIJ (Places API)
0x47e66e1f06e2b70f:0x40b82c3688c9c610                        ← Hex place ID
14724890234567890123                                          ← Numeric CID

````

#### Sort Options

| Value | Description |
|---|---|
| `newest` | Most recent reviews first *(recommended for monitoring)* |
| `most_relevant` | Google's default ranking |
| `highest` | 5-star reviews first |
| `lowest` | 1-star reviews first |

#### Example Input (JSON)

```json
{
  "startUrls": [
    { "url": "https://www.google.com/maps/place/Eiffel+Tower/@48.8584,2.2945,17z" },
    { "url": "https://www.google.com/maps/place/Louvre+Museum/@48.8606,2.3376,17z" }
  ],
  "maxReviews": 500,
  "reviewsSort": "newest",
  "reviewsStartDate": "2024-01-01",
  "language": "en",
  "personalData": true,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"]
  }
}
````

> **Tip:** Use `reviewsStartDate` with `reviewsSort: "newest"` to efficiently collect only recent reviews without downloading the entire review history.

***

### 📤 Output Format

Each review is saved as a separate record in the Apify dataset.

#### Sample Output

```json
{
  "placeId": "0x48761b2b32ecd5b1:0xa9d484d5c5bfbbb4",
  "sort": "newest",
  "reviewId": "ChdDSUhNMG9nS0VJQ0FnSUQtNXZfcWdnRRAB",
  "rating": 5,
  "reviewText": "Amazing place, great atmosphere and friendly staff!",
  "language": "en",
  "languageName": "English",
  "translatedText": null,
  "relativeDate": "a week ago",
  "photos": [
    "https://lh5.googleusercontent.com/p/AF1QipN..."
  ],
  "reviewerName": "John Smith",
  "reviewerId": "108234567890123456789",
  "reviewerProfileUrl": "https://www.google.com/maps/contrib/108234567890123456789",
  "reviewerAvatarUrl": "https://lh3.googleusercontent.com/a/...",
  "reviewerStats": "Local Guide · 47 reviews"
}
```

#### Field Reference

| Field | Type | Description |
|---|---|---|
| `placeId` | string | Hex place ID of the scraped business |
| `sort` | string | Sort mode used for this run |
| `reviewId` | string | Unique review identifier |
| `rating` | integer | Star rating (1–5) |
| `reviewText` | string | Original review text (null if rating-only) |
| `language` | string | ISO 639-1 language code (e.g. `"en"`, `"fr"`) |
| `languageName` | string | Human-readable language name |
| `translatedText` | string | Google's auto-translation (null if same language) |
| `relativeDate` | string | Relative date string from Google (e.g. `"3 months ago"`) |
| `photos` | array | Direct URLs to review photos |
| `reviewerName` | string | Reviewer's display name *(personalData)* |
| `reviewerId` | string | Reviewer's Google ID *(personalData)* |
| `reviewerProfileUrl` | string | Link to reviewer's Google Maps profile *(personalData)* |
| `reviewerAvatarUrl` | string | Reviewer's profile photo URL *(personalData)* |
| `reviewerStats` | string | Reviewer badge, e.g. `"Local Guide · 161 reviews"` *(personalData)* |

> Fields marked *(personalData)* are only included when `personalData` is set to `true`.

***

### ▶️ How to Use

#### Option 1: Apify Console (No Code)

1. Go to the Actor page in the [Apify Store](https://apify.com/store)
2. Click **Try for free**
3. Paste one or more Google Maps URLs into **Start URLs**
4. Set your `maxReviews`, sort order, and optional filters
5. Click **Start** and wait for the run to finish
6. Download your dataset as JSON, CSV, or Excel

#### Option 2: Apify API

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/YOUR_ACTOR_ID/runs?token=YOUR_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "startUrls": [{ "url": "https://www.google.com/maps/place/..." }],
    "maxReviews": 200,
    "reviewsSort": "newest",
    "language": "en"
  }'
```

#### Option 3: Scheduled Runs (Monitoring)

1. Open the Actor and click **Schedules**
2. Set a daily or weekly schedule
3. Connect the output to Google Sheets, Slack, or your CRM via [Apify integrations](https://apify.com/integrations)

***

### 📈 Use Cases

#### 1. Reputation Monitoring

Track new reviews for your business locations on a weekly basis. Get notified when negative reviews appear so you can respond quickly.

#### 2. Competitor Analysis

Scrape reviews for competitor businesses in your city. Identify recurring complaints in 1-star reviews to find gaps you can fill.

#### 3. Sentiment Analysis

Feed review text into NLP tools (OpenAI, HuggingFace) to classify sentiment, extract topics, and detect trends over time.

#### 4. Lead Generation for Agencies

Find businesses with low ratings and many negative reviews — these are warm leads for reputation management services.

#### 5. Market Research

Aggregate reviews from hundreds of locations in a category (e.g. all coffee shops in Paris) to understand what customers value most.

***

### 🛠️ Advanced Tips

#### Getting More Reviews Faster

- Set `maxReviews` up to `10000` per place
- Use `reviewsSort: "newest"` with `reviewsStartDate` to skip old reviews on repeat runs
- Run multiple places in parallel by adding them all to `startUrls`

#### Proxy Configuration

Residential proxies are strongly recommended and pre-configured by default. Using datacenter proxies may result in blocks or CAPTCHAs. Keep the default `RESIDENTIAL` group for best results.

#### Processing Large Datasets

For datasets over 10,000 records, use the [Apify Dataset API](https://docs.apify.com/api/v2#/reference/datasets) to stream results page by page instead of downloading all at once.

#### Integrations

Connect directly to:

- **Google Sheets** — via Apify's built-in Google Sheets integration
- **Airtable / Notion** — via Zapier or Make
- **Your database** — using the Apify API webhook on run completion

***

### ❓ FAQ

**Q: Do I need a Google account or API key?**
No. This Actor requires no authentication whatsoever. Just paste your Google Maps URLs and run.

**Q: How many reviews can I scrape per place?**
Up to 10,000 reviews per place per run. Google Maps itself doesn't surface more than that.

**Q: Is the `relativeDate` field accurate?**
It's approximate. Google returns relative strings like "3 months ago" rather than exact timestamps. The `reviewsStartDate` filter uses these strings to estimate the cutoff, with a precision of roughly ±2 weeks.

**Q: Can I scrape reviews in multiple languages at once?**
Yes — leave `language` set to "All Languages" to get reviews in every language. Use the `language` field in your output to filter later.

**Q: Why are some reviews missing `reviewText`?**
Some Google Maps reviews are rating-only (no written text). These are still included in the output with `reviewText: null`.

**Q: What happens if a place has fewer reviews than `maxReviews`?**
The Actor will scrape all available reviews and stop naturally. You won't be charged for unused capacity.

**Q: Will this work on Google Maps listings outside the US?**
Yes — the Actor works for any Google Maps listing worldwide, in any country or language.

**Q: What proxy should I use?**
Residential proxies are required for reliable results. The default Apify Residential proxy group is pre-selected and works out of the box.

***

### 📞 Support

Having trouble or need a custom feature?

- **Email:** <me@ahmedhrid.com>
- **Issues:** Use the **Issues** tab on this Actor's page in the Apify Store
- **Apify Community:** [community.apify.com](https://community.apify.com)

# Actor input Schema

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

Google Maps place URLs to scrape reviews from. Paste any Google Maps link for a business or place.

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

Google place identifiers. Accepted formats:

- Hex: 0xdb3c95bddcce0f9:0xc896d2098108a5d6
- ChIJ (from Places API): ChIJN1t\_tDeuEmsRUsoyG83frY4
- CID (numeric): 14724890234567890
- Full Google Maps URL

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

Maximum number of reviews to extract per place.

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

How to sort the reviews.

## `reviewsStartDate` (type: `string`):

Only return reviews newer than this date (ISO format: YYYY-MM-DD). Pagination stops when reviews older than this date are encountered. Approximate — based on relative date strings from the API.

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

Only return reviews in this language. Leave empty to return all languages.

## `reviewsOrigin` (type: `string`):

Which reviews to include. Currently "all" is supported.

## `personalData` (type: `boolean`):

Include reviewer personal data: name, profile URL, avatar URL, reviewer ID. Disable to comply with privacy regulations.

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

Apify proxy. Residential proxies recommended.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.google.com/maps/place/Yellowstone+National+Park/@44.5857951,-110.5140571,9z/data=!3m1!4b1!4m5!3m4!1s0x5351e55555555555:0xaca8f930348fe1bb"
    }
  ],
  "placeIds": [
    "ChIJabcdEFGHijklMNOPqrstUVWX",
    "0xdb3c95bddcce0f9:0xc896d2098108a5d6"
  ],
  "maxReviews": 100,
  "reviewsSort": "newest",
  "reviewsStartDate": "2024-01-01",
  "language": "",
  "reviewsOrigin": "all",
  "personalData": true,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# 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/Yellowstone+National+Park/@44.5857951,-110.5140571,9z/data=!3m1!4b1!4m5!3m4!1s0x5351e55555555555:0xaca8f930348fe1bb"
        }
    ],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("reviewly/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/Yellowstone+National+Park/@44.5857951,-110.5140571,9z/data=!3m1!4b1!4m5!3m4!1s0x5351e55555555555:0xaca8f930348fe1bb" }],
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("reviewly/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/Yellowstone+National+Park/@44.5857951,-110.5140571,9z/data=!3m1!4b1!4m5!3m4!1s0x5351e55555555555:0xaca8f930348fe1bb"
    }
  ],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call reviewly/google-maps-reviews-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=reviewly/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 Google Maps reviews at scale — no login, no limits.",
        "version": "0.0",
        "x-build-id": "DGzNiiCWmmXhBBceD"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/reviewly~google-maps-reviews-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-reviewly-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/reviewly~google-maps-reviews-scraper/runs": {
            "post": {
                "operationId": "runs-sync-reviewly-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/reviewly~google-maps-reviews-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-reviewly-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": "Start URLs",
                        "type": "array",
                        "description": "Google Maps place URLs to scrape reviews from. Paste any Google Maps link for a business or place.",
                        "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 identifiers. Accepted formats:\n- Hex: 0xdb3c95bddcce0f9:0xc896d2098108a5d6\n- ChIJ (from Places API): ChIJN1t_tDeuEmsRUsoyG83frY4\n- CID (numeric): 14724890234567890\n- Full Google Maps URL",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxReviews": {
                        "title": "Max Reviews Per Place",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of reviews to extract per place.",
                        "default": 100
                    },
                    "reviewsSort": {
                        "title": "Sort Order",
                        "enum": [
                            "newest",
                            "most_relevant",
                            "highest",
                            "lowest"
                        ],
                        "type": "string",
                        "description": "How to sort the reviews.",
                        "default": "newest"
                    },
                    "reviewsStartDate": {
                        "title": "Reviews Start Date",
                        "type": "string",
                        "description": "Only return reviews newer than this date (ISO format: YYYY-MM-DD). Pagination stops when reviews older than this date are encountered. Approximate — based on relative date strings from the API."
                    },
                    "language": {
                        "title": "Language Filter",
                        "enum": [
                            "",
                            "en",
                            "fr",
                            "ar",
                            "es",
                            "de",
                            "it",
                            "pt",
                            "nl",
                            "ru",
                            "zh",
                            "ja",
                            "ko",
                            "tr",
                            "pl",
                            "sv",
                            "da",
                            "fi",
                            "nb",
                            "el",
                            "cs",
                            "ro",
                            "hu",
                            "he",
                            "id",
                            "th",
                            "vi",
                            "uk",
                            "hi"
                        ],
                        "type": "string",
                        "description": "Only return reviews in this language. Leave empty to return all languages.",
                        "default": ""
                    },
                    "reviewsOrigin": {
                        "title": "Reviews Origin",
                        "enum": [
                            "all"
                        ],
                        "type": "string",
                        "description": "Which reviews to include. Currently \"all\" is supported.",
                        "default": "all"
                    },
                    "personalData": {
                        "title": "Include Personal Data",
                        "type": "boolean",
                        "description": "Include reviewer personal data: name, profile URL, avatar URL, reviewer ID. Disable to comply with privacy regulations.",
                        "default": true
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Apify proxy. Residential proxies recommended."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
