# Agoda Reviews Scraper (`solidcode/agoda-reviews-scraper`) Actor

\[💰 $2.0 / 1K] Extract guest reviews from Agoda hotels and accommodations. Collect ratings, reviewer details, stay info, and management responses. Filter by language, rating, and reviewer country.

- **URL**: https://apify.com/solidcode/agoda-reviews-scraper.md
- **Developed by:** [SolidCode](https://apify.com/solidcode) (community)
- **Categories:** Travel, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 results

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

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## Agoda Reviews Scraper

Pull guest reviews from any Agoda hotel or accommodation — ratings, reviewer profiles, stay details, and management responses — for as many properties as you need in one run. Built for hospitality teams, market researchers, and travel data analysts who need structured Agoda review data at scale without building or maintaining their own pipeline.

### Why This Scraper?

- **Management responses captured verbatim** — every reply includes the responder's name, response date, and the full response text. Audit how properties handle criticism or showcase service quality without leaving the dataset.
- **Reviewer profile on every row** — country of origin, traveler type (Solo, Couple, Family, Business), booked room type, and length of stay surface as structured fields, not buried in free text.
- **4 Agoda-native sort modes** — Most Recent, Highest Rated, Lowest Rated, and Most Helpful. The sort is honored by Agoda's own API, so you get the same ordering a guest would see on-site.
- **Batch input — URLs or numeric IDs** — paste a list of hotel page URLs, supply bare Agoda hotel IDs, or mix both in the same run. No one-at-a-time lookups.
- **Reviewer language preserved on every row** — the `reviewLanguage` ISO code (`en`, `ja`, `ko`, `de`, `zh-tw`, …) appears on each row so you can group or filter reviews by language after collection without re-running the actor.
- **Both rating number and label on every row** — `rating` gives the 1–10 numeric score; `ratingText` gives Agoda's bucket label ("Exceptional", "Excellent", "Very good", "Good", "Review score") for direct display or segmentation without a lookup table.
- **Optional hotel metadata embedded on every row** — toggle `Include Hotel Info on Every Row` to add the hotel name, overall rating, and URL to each review. Invaluable when scraping multiple hotels into one flat CSV for downstream analysis.
- **Honest pagination — no silent caps** — set `maxReviewsPerHotel` to 1,000 and you get 1,000 reviews (or all available, whichever is smaller). The last page is always kept whole, so you never lose a review mid-page.

### Use Cases

**Hospitality Reputation Management**
Track your property's newest reviews as they arrive. Pull with `sort: Most Recent` on a weekly schedule to catch issues before they accumulate. The `responseText` field lets you verify your team is actually replying — not just that replies were promised.

**Hotel Market Research & Competitive Benchmarking**
Collect reviews for 10–50 competing hotels in one run. Compare rating distributions, traveler-type breakdowns, and room-type sentiment across the competitive set. The `hotelName` field on every row makes it trivial to pivot in Excel or any BI tool.

**Sentiment Analysis & ML Training Data**
Each review row carries distinct `reviewPositives`, `reviewNegatives`, and `reviewComments` fields — pre-split by the reviewer, not by you. Combine with the numeric rating and Agoda's label bucket for high-quality labeled training data for hospitality sentiment models.

**Travel Aggregator Sourcing**
Agoda pools reviews from its own platform and partner booking sources, deduplicated per property. The `reviewProviderText` field identifies the source of each review, giving you cross-platform coverage without managing multiple scraper setups.

**Reviewer-Demographic Insights**
Group reviews by `reviewerGroupName` (Solo, Couple, Family with young children, Business) and `reviewerCountryName` to understand which traveler segments rate a property well and which do not. Filter on `reviewerLengthOfStay` to separate weekend breaks from week-long visits.

### Getting Started

#### Minimal — One Hotel URL

Paste any Agoda hotel page URL and collect 100 reviews with defaults:

```json
{
    "startUrls": ["https://www.agoda.com/the-peninsula-bangkok/hotel/bangkok-th.html"]
}
````

#### Sort + Cap — Recent Reviews with a Limit

Collect the 500 most recent reviews using a numeric hotel ID:

```json
{
    "hotelIds": ["10715"],
    "sort": "mostRecent",
    "maxReviewsPerHotel": 500
}
```

#### Multi-Hotel Benchmarking

Compare top-rated reviews across three competing properties:

```json
{
    "startUrls": [
        "https://www.agoda.com/the-peninsula-bangkok/hotel/bangkok-th.html",
        "https://www.agoda.com/the-okura-prestige-bangkok/hotel/bangkok-th.html",
        "https://www.agoda.com/mandarin-oriental-bangkok-hotel/hotel/bangkok-th.html"
    ],
    "sort": "highestRated",
    "maxReviewsPerHotel": 200,
    "includeHotelInfo": true
}
```

#### Lean Output — Reviews Only, No Hotel Metadata

When you are scraping a single hotel and already know which property the data belongs to, strip hotel metadata to keep rows compact:

```json
{
    "hotelIds": ["10715"],
    "maxReviewsPerHotel": 1000,
    "includeHotelInfo": false,
    "includeManagementResponses": false
}
```

### Input Reference

#### Hotels to Scrape

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `startUrls` | string\[] | — | One or more Agoda hotel page URLs. Example: `https://www.agoda.com/hotel-name/hotel/city_name.html`. Use this or Hotel IDs — not both. |
| `hotelIds` | string\[] | — | Numeric Agoda hotel IDs (e.g. `6901`). Faster than URLs when you already have the ID — skips the URL-resolution step. |

#### Review Options

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `maxReviewsPerHotel` | integer | `100` | Maximum reviews to collect per hotel. Leave empty to collect all available. Large hotels may have tens of thousands — set a limit to control costs. |
| `sort` | select | `Most Recent` | Order in which to retrieve reviews: **Most Recent**, **Highest Rated**, **Lowest Rated**, or **Most Helpful**. |

#### Output Options

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `includeHotelInfo` | boolean | `true` | Adds hotel name, overall rating, and URL to every review row. Recommended when scraping multiple hotels so each row is self-identifying. |
| `includeManagementResponses` | boolean | `true` | Includes hotel management replies — response date, responder name, and full response text — on every applicable row. |

### Output

Each row is one review. Here is a representative example with all fields enabled:

```json
{
    "hotelReviewId": "73849201",
    "rating": 9.6,
    "ratingText": "Exceptional",
    "reviewTitle": "Flawless service as always",
    "reviewComments": "Staying at the Peninsula never disappoints. Staff remembered our names throughout the five-night stay.",
    "reviewPositives": "Staff attentiveness, room cleanliness, rooftop pool",
    "reviewNegatives": "",
    "reviewLanguage": "en",
    "reviewDate": "2024-11-15T08:42:00+07:00",
    "checkInDate": "2024-11-10T00:00:00+07:00",
    "checkOutDate": "2024-11-15T00:00:00+07:00",
    "reviewerName": "Sophie T.",
    "reviewerCountry": "GB",
    "reviewerCountryName": "United Kingdom",
    "reviewerGroupName": "Couple",
    "reviewerRoomTypeName": "Deluxe River View Room",
    "reviewerLengthOfStay": "5 nights",
    "reviewProviderText": "Agoda",
    "responseDate": "2024-11-18T09:20:18",
    "responderName": "The Peninsula Bangkok",
    "responseText": "Dear Sophie, thank you so much for your kind words and for celebrating with us.",
    "hotelId": 10715,
    "hotelName": "The Peninsula Bangkok",
    "hotelOverallRating": 9.4,
    "hotelAddress": null,
    "hotelUrl": "https://www.agoda.com/the-peninsula-bangkok/hotel/bangkok-th.html"
}
```

#### Core Review Content

| Field | Type | Description |
|-------|------|-------------|
| `hotelReviewId` | string | Unique Agoda review identifier |
| `rating` | number | Reviewer score from 1 to 10 |
| `ratingText` | string | Agoda's label bucket: "Exceptional", "Excellent", "Very good", "Good", or "Review score" |
| `reviewTitle` | string | Review headline as written by the guest |
| `reviewComments` | string | Full review body text |
| `reviewPositives` | string | What the guest liked (reviewer-filled structured field) |
| `reviewNegatives` | string | What the guest did not like (reviewer-filled structured field) |
| `reviewLanguage` | string | ISO language code of the review text (e.g. `en`, `ja`, `ko`, `de`) |
| `reviewDate` | string | ISO 8601 datetime with timezone offset when the review was published (e.g. `2024-11-15T08:42:00+07:00`) |
| `reviewProviderText` | string | Source platform (e.g. "Agoda", "Booking.com") |

#### Reviewer Profile & Stay Details

| Field | Type | Description |
|-------|------|-------------|
| `reviewerName` | string | Reviewer's display name |
| `reviewerCountry` | string | Reviewer's country as an ISO alpha-2 code (e.g. `GB`, `JP`, `US`) |
| `reviewerCountryName` | string | Reviewer's country as a full name (e.g. "United Kingdom") |
| `reviewerGroupName` | string | Traveler type: Solo, Couple, Family with young children, Business, etc. |
| `reviewerRoomTypeName` | string | Room type the reviewer booked |
| `reviewerLengthOfStay` | string | Formatted stay duration (e.g. "3 nights") |
| `checkInDate` | string | Guest check-in date as ISO 8601 datetime with timezone offset |
| `checkOutDate` | string | Guest check-out date as ISO 8601 datetime with timezone offset |

#### Management Response

Present on every row when `includeManagementResponses` is `true`. Fields are empty strings when no management response exists for a review.

| Field | Type | Description |
|-------|------|-------------|
| `responseDate` | string | ISO 8601 datetime when management published the response (e.g. `2024-11-18T09:20:18`) |
| `responderName` | string | Name or handle of the responder |
| `responseText` | string | Full text of the management reply |

#### Hotel Metadata

Present on every row when `includeHotelInfo` is `true`.

| Field | Type | Description |
|-------|------|-------------|
| `hotelId` | number | Agoda's numeric hotel identifier |
| `hotelName` | string | Hotel display name |
| `hotelOverallRating` | number | Hotel's aggregate rating score |
| `hotelAddress` | string | Hotel address (`null` — not returned by Agoda's review API) |
| `hotelUrl` | string | Agoda hotel page URL |

### Tips for Best Results

- **Use `sort: Most Recent` for ongoing reputation tracking.** Pull weekly and compare against your previous run using `reviewDate` to surface only new reviews. A cap of 50–100 per hotel is enough for most weekly sweeps.
- **Combine `includeManagementResponses: true` with `sort: Lowest Rated`** to audit how a property handles its harshest critics. Reviews with an empty `responseText` are unanswered complaints you can act on immediately.
- **Use `hotelIds` instead of URLs when you already have them.** Numeric IDs skip the URL-to-ID resolution step, making multi-hotel batch runs faster. You can find a hotel's ID in the Agoda URL structure or via a one-off URL scrape.
- **Keep `includeHotelInfo: true` for multi-hotel runs.** Every row carries `hotelName` and `hotelId`, so you can export a single flat CSV and pivot by property without a secondary join.
- **For sentiment ML training, pull 1,000+ reviews per hotel and group on `reviewLanguage` afterward.** The pre-split `reviewPositives` and `reviewNegatives` fields are ready-made labeled data — no sentence segmentation needed.
- **Agoda returns up to 50 reviews per page.** Setting `maxReviewsPerHotel` below 50 still yields up to 50 results because the last page is kept whole. At $2/1,000, the maximum overshoot cost is $0.10.
- **Start small to verify.** Set `maxReviewsPerHotel: 50` on your first run to confirm the hotel URL resolves and the data shape matches your needs, then scale up to thousands.

### Pricing

**$2.00 per 1,000 reviews** — pay per result returned.

| Reviews | Cost |
|---------|------|
| 100 | $0.20 |
| 1,000 | $2.00 |
| 10,000 | $20.00 |
| 100,000 | $200.00 |

**No compute charges — you only pay per result returned.**

A "result" is one review row in the output dataset.

### Integrations

Export your data in JSON, CSV, Excel, XML, or RSS and connect to your existing stack. Apify integrates natively with:

- **Zapier** / **Make** / **n8n** — trigger downstream workflows when new reviews land
- **Google Sheets** — export directly to a spreadsheet for stakeholder sharing
- **Slack** / **Email** — notify your team when runs complete
- **Webhooks** — push review data to any custom endpoint in real time
- **Apify API** — schedule runs, retrieve datasets, and integrate programmatically from any language

### Legal & Ethical Use

This actor collects publicly visible guest reviews from Agoda. Users are responsible for ensuring their use of the collected data complies with Agoda's Terms of Service, applicable data protection regulations (including GDPR where relevant), and any local laws governing the storage and processing of user-generated content. Do not use extracted data for spam, identity fraud, harassment, or any other unlawful purpose.

# Actor input Schema

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

Paste one or more Agoda hotel or accommodation page URLs. Example: https://www.agoda.com/hotel-name/hotel/city\_name.html. Use this OR Hotel IDs below — not both.

## `hotelIds` (type: `array`):

Numeric Agoda hotel IDs (e.g., 6901 for The Peninsula Bangkok). Each ID maps to one property. Use this OR Hotel URLs above.

## `maxReviewsPerHotel` (type: `integer`):

Maximum number of reviews to collect per hotel. Leave empty to collect all available reviews — large hotels may have 5,000–50,000 reviews, so set this to control cost. Each review is one billable result at $2 per 1,000.

## `sort` (type: `string`):

Order in which to retrieve reviews.

## `includeHotelInfo` (type: `boolean`):

When enabled, each review row includes the hotel name, overall rating, address, and URL. Useful when scraping multiple hotels so you can identify which hotel each review belongs to.

## `includeManagementResponses` (type: `boolean`):

When enabled, hotel management responses to reviews are included in the output (response date, responder name, response text).

## Actor input object example

```json
{
  "startUrls": [
    "https://www.agoda.com/the-peninsula-bangkok/hotel/bangkok-th.html"
  ],
  "hotelIds": [],
  "maxReviewsPerHotel": 100,
  "sort": "mostRecent",
  "includeHotelInfo": true,
  "includeManagementResponses": true
}
```

# Actor output Schema

## `overview` (type: `string`):

Table of reviews with key fields: hotel, reviewer, rating, date, and summary.

## `details` (type: `string`):

Complete review rows including all text fields, stay details, reviewer info, and management responses.

# 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": [
        "https://www.agoda.com/the-peninsula-bangkok/hotel/bangkok-th.html"
    ],
    "hotelIds": [],
    "maxReviewsPerHotel": 100,
    "sort": "mostRecent",
    "includeHotelInfo": true,
    "includeManagementResponses": true
};

// Run the Actor and wait for it to finish
const run = await client.actor("solidcode/agoda-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": ["https://www.agoda.com/the-peninsula-bangkok/hotel/bangkok-th.html"],
    "hotelIds": [],
    "maxReviewsPerHotel": 100,
    "sort": "mostRecent",
    "includeHotelInfo": True,
    "includeManagementResponses": True,
}

# Run the Actor and wait for it to finish
run = client.actor("solidcode/agoda-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": [
    "https://www.agoda.com/the-peninsula-bangkok/hotel/bangkok-th.html"
  ],
  "hotelIds": [],
  "maxReviewsPerHotel": 100,
  "sort": "mostRecent",
  "includeHotelInfo": true,
  "includeManagementResponses": true
}' |
apify call solidcode/agoda-reviews-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Agoda Reviews Scraper",
        "description": "[💰 $2.0 / 1K] Extract guest reviews from Agoda hotels and accommodations. Collect ratings, reviewer details, stay info, and management responses. Filter by language, rating, and reviewer country.",
        "version": "1.0",
        "x-build-id": "JmhrrTa0sagxCKyph"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/solidcode~agoda-reviews-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-solidcode-agoda-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/solidcode~agoda-reviews-scraper/runs": {
            "post": {
                "operationId": "runs-sync-solidcode-agoda-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/solidcode~agoda-reviews-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-solidcode-agoda-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": "Hotel URLs",
                        "type": "array",
                        "description": "Paste one or more Agoda hotel or accommodation page URLs. Example: https://www.agoda.com/hotel-name/hotel/city_name.html. Use this OR Hotel IDs below — not both.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "hotelIds": {
                        "title": "Hotel IDs",
                        "type": "array",
                        "description": "Numeric Agoda hotel IDs (e.g., 6901 for The Peninsula Bangkok). Each ID maps to one property. Use this OR Hotel URLs above.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxReviewsPerHotel": {
                        "title": "Max Reviews per Hotel",
                        "minimum": 1,
                        "maximum": 50000,
                        "type": "integer",
                        "description": "Maximum number of reviews to collect per hotel. Leave empty to collect all available reviews — large hotels may have 5,000–50,000 reviews, so set this to control cost. Each review is one billable result at $2 per 1,000.",
                        "default": 100
                    },
                    "sort": {
                        "title": "Sort Order",
                        "enum": [
                            "mostRecent",
                            "highestRated",
                            "lowestRated",
                            "mostHelpful"
                        ],
                        "type": "string",
                        "description": "Order in which to retrieve reviews.",
                        "default": "mostRecent"
                    },
                    "includeHotelInfo": {
                        "title": "Include Hotel Info on Every Row",
                        "type": "boolean",
                        "description": "When enabled, each review row includes the hotel name, overall rating, address, and URL. Useful when scraping multiple hotels so you can identify which hotel each review belongs to.",
                        "default": true
                    },
                    "includeManagementResponses": {
                        "title": "Include Management Responses",
                        "type": "boolean",
                        "description": "When enabled, hotel management responses to reviews are included in the output (response date, responder name, response text).",
                        "default": true
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
