# Google Hotels Scraper - Prices, Ratings, Vendor & Room Rates (`sourabhbgp/google-hotels-scraper`) Actor

Scrape Google Hotels by destination and dates for prices, star class, ratings, reviews, amenities, coordinates, photos, and booking links. Turn on detail mode to add every booking site's rate and each room type's price. Export to JSON, CSV, or Excel.

- **URL**: https://apify.com/sourabhbgp/google-hotels-scraper.md
- **Developed by:** [Sourabh Kumar](https://apify.com/sourabhbgp) (community)
- **Categories:** Travel
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.00 / 1,000 hotel results

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

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

### Google Hotels scraper: prices, per-vendor rates, room types & ratings

Search Google Hotels for any destination and dates, and get back the hotels with prices, star class, guest ratings, review counts, amenities, coordinates, photos, and booking links. Flip on one option and each hotel is enriched with the full price breakdown: every booking site's rate and every room type.

**$4 per 1,000 hotels. No subscription. No residential proxies or browser needed, which keeps runs cheap and fast.**

Works worldwide, in any of 14 currencies, for any city, neighborhood, or landmark you can search.

#### Search results, or the full price breakdown

Most Google Hotels scrapers stop at the search card: one headline price per hotel. This one can go a level deeper. Turn on **Scrape room and vendor details** and every hotel also carries `vendors[]` (Booking.com, Expedia, Hotels.com, Agoda, the hotel's own site, and ~20 more, each with its nightly and total price) and `rooms[]` (each room type with its rate plans). That per-vendor and per-room pricing is the data you need for rate monitoring, and it is exactly what the search card hides.

### Why this scraper?

- 💸 **$4 per 1,000 hotels.** Flat rate whether you pull search cards or the full price breakdown.
- 🏷️ **Every vendor's price, not just the headline.** See what Booking, Expedia, Agoda, and the hotel's own site each charge for the same stay.
- 🛏️ **Room-by-room rates.** Each room type with its rate plans, so you can compare a King Guest Room against a Junior Suite across sites.
- ⚡ **No residential proxies, no browser.** Standard proxies handle it, which keeps runs fast and cheap.
- 🌍 **Global and multi-currency.** Any destination, priced in USD, EUR, GBP, INR, JPY, and 9 more.
- 🗺️ **Ready to join.** Every hotel carries a stable Google hotel id and, in detail mode, a Google Maps place id and coordinates.
- 🧾 **You only pay for real hotels.** Blocked or empty runs do not bill you; duplicates across pages are removed before charging.

### What data can you extract?

<table>
  <tr><td>🏨 Hotel name</td><td>💵 Per-night price</td><td>⭐ Star class</td><td>🌟 Guest rating</td></tr>
  <tr><td>🗣️ Review count</td><td>🛎️ Amenities</td><td>📍 Coordinates</td><td>🖼️ Photos</td></tr>
  <tr><td>📅 Check-in / check-out</td><td>🔗 Booking link</td><td>🆔 Google hotel id</td><td>🌐 Google Hotels URL</td></tr>
  <tr><td>🏷️ Per-vendor prices</td><td>🛏️ Room types & rates</td><td>🏠 Address</td><td>🗺️ Google Maps place id</td></tr>
</table>

The bottom row (per-vendor prices, room types, address, place id, description) is populated only when **Scrape room and vendor details** is turned on.

### How to scrape Google Hotels: step by step

1. [Create a free Apify account](https://console.apify.com/sign-up). Takes 30 seconds, no card needed.
2. Open [Google Hotels Scraper](https://console.apify.com/actors/1oZcalQXjt8Nba90c?addFromActorId=1oZcalQXjt8Nba90c) in the Apify Console.
3. Type a destination like `hotels in Paris`, set your dates, and pick a currency. Turn on the room-and-vendor option if you want the full price breakdown.
4. Click **Start**. Search-only runs finish in well under a minute; detail runs take longer because each hotel is priced individually.
5. Export as JSON, CSV, or Excel, or pull the results through the API.

### How much does Google Hotels Scraper cost?

You pay **$4 per 1,000 hotels** ($0.004 each), the same rate for search-only and full-detail runs. The Apify Free plan includes $5 of usage a month, roughly **1,250 hotels**. The $29/month Starter plan covers about **7,250 hotels**. There is also a small actor-start fee per run (a fraction of a cent at the default memory). Turning on the detail option does not change the per-hotel price, but each hotel then costs a little more compute because it is priced individually.

### Input

```json
{
  "query": "hotels in Paris",
  "checkIn": "2026-09-15",
  "checkOut": "2026-09-18",
  "adults": 2,
  "currency": "USD",
  "maxItems": 50,
  "scrapeRoomDetails": true
}
````

| Field | Type | Default | Notes |
|---|---|---|---|
| `query` | string | required | Destination phrase, e.g. `hotels in Paris`, `hotels near Times Square New York`, `beach resorts in Bali`. |
| `checkIn` | string | ~2 weeks out | Check-in date, `YYYY-MM-DD`. Prices depend on the dates, so set them for a real trip. |
| `checkOut` | string | 1 night after check-in | Check-out date, `YYYY-MM-DD`. |
| `adults` | integer | 2 | Adult guests (1 to 20). Prices and availability adjust to the party size. |
| `currency` | string | `USD` | One of 14: USD, EUR, GBP, INR, JPY, AUD, CAD, CHF, CNY, AED, SGD, BRL, MXN, ZAR. |
| `maxItems` | integer | 50 | Upper limit on hotels returned. |
| `scrapeRoomDetails` | boolean | false | Add each hotel's per-vendor and per-room price breakdown. Slower, since each hotel is priced individually. |

Google Hotels serves a curated set per query, often a few dozen. For wider coverage, run several specific queries by neighborhood or landmark (`hotels in Le Marais Paris`, `hotels near Eiffel Tower`) rather than one broad city query.

### Output

Search-only run (one object per hotel):

```json
{
  "query": "hotels in Paris",
  "hotelId": "5585600554652909757",
  "name": "Hotel Camille Paris Gare de Lyon, Tapestry Collection by Hilton",
  "priceFormatted": "$179",
  "pricePerNight": 179,
  "currency": "USD",
  "starClass": 4,
  "rating": 4.1,
  "reviewCount": 407,
  "amenities": [18, 29],
  "latitude": 48.846255,
  "longitude": 2.371999,
  "checkIn": "2026-09-15",
  "checkOut": "2026-09-18",
  "nights": 3,
  "bookingLink": "https://www.google.com/aclk?sa=l&ai=...",
  "url": "https://www.google.com/travel/search?q=Hotel%20Camille%20Paris...",
  "images": ["https://encrypted-tbn0.gstatic.com/images?q=..."]
}
```

With **Scrape room and vendor details** on, the same hotel also carries `address`, `description`, `googlePlaceId`, and the price breakdown:

```json
{
  "name": "Hotel Camille Paris Gare de Lyon, Tapestry Collection by Hilton",
  "pricePerNight": 179,
  "address": "5 Rue de Lyon, 75012 Paris, France",
  "googlePlaceId": "ChIJl38YpgRy5kcRgqEJRq81bGw",
  "description": "Refined rooms & suites in an upscale hotel featuring a chic lounge, plus breakfast & Wi-Fi.",
  "vendors": [
    { "name": "Hotel Camille Paris Gare de Lyon, Tapestry Collection by Hilton", "pricePerNight": 398, "priceTotal": 1193, "bookingLink": "https://www.google.com/travel/lodging/clk?..." },
    { "name": "Super.com", "pricePerNight": 364, "priceTotal": 1091, "bookingLink": "https://www.google.com/travel/lodging/clk?..." },
    { "name": "Booking.com", "pricePerNight": 381, "priceTotal": 1142, "bookingLink": "https://www.google.com/travel/lodging/clk?..." }
  ],
  "rooms": [
    { "roomType": "KING GUEST ROOM", "pricePerNight": 329, "ratePlans": [
      { "pricePerNight": 329, "bookingLink": "https://www.google.com/aclk?..." },
      { "pricePerNight": 350, "bookingLink": "https://www.google.com/aclk?..." }
    ] },
    { "roomType": "KING DELUXE ROOM WITH VIEW", "pricePerNight": 339, "ratePlans": [ { "pricePerNight": 339, "bookingLink": "https://www.google.com/aclk?..." } ] }
  ]
}
```

**Two different prices, on purpose.** The top-level `pricePerNight` (`$179` here) is Google's headline search-card price, the lead-in rate it shows in results. The `vendors[]` and `rooms[]` prices are the live, bookable rates on the detail panel (cheapest vendor $364/night, cheapest room $329/night for the same dates). They often differ, because the search card is a teaser and the breakdown is what each site actually charges. Surfacing that gap is the point of detail mode.

### Use cases

- 💹 **Rate monitoring**: track a hotel's price across Booking, Expedia, Agoda, and its own site over time.
- 🏨 **Comp-set benchmarking**: compare your property's rates against nearby competitors for the same dates.
- 📊 **Market research**: pull priced inventory for a whole city or neighborhood in one run.
- 🧭 **OTA parity checks**: spot where a booking site is undercutting or overpricing a hotel's direct rate.
- 🗺️ **Travel product feeds**: build a priced hotel dataset with coordinates, photos, and Maps place ids.
- 🎯 **Deal discovery**: find hotels where a specific vendor's rate is well below the headline.
- 📅 **Seasonal pricing studies**: re-run the same query across date ranges to chart how rates move.

### Limitations

- **Curated result set per query.** Google returns a curated few-dozen hotels per search, not an exhaustive list. Run neighborhood or landmark queries to widen coverage.
- **Headline price vs. live prices differ.** The search-card `pricePerNight` is a teaser and will not always match the vendor or room prices in detail mode (see the Output note).
- **Room data is not universal.** Google does not publish room-level rates for every hotel; when it is missing, the hotel still returns its vendor prices, with `rooms` empty.
- **Amenities are numeric codes.** The `amenities` field holds Google's internal amenity codes, not text labels.
- **Dates are required for prices.** If you omit dates the actor fills in a default stay (about two weeks out), because Google returns no priced results without them.

### FAQ

#### How much does Google Hotels Scraper cost?

It uses pay-per-result pricing. You pay **$4 for 1,000 hotels**. The Apify Free plan gives you $5 in usage credits a month, enough for around 1,250 hotels. If you run regularly, the $29/month Starter plan covers about 7,250 hotels.

No subscription lock-in. Pause whenever.

#### Is it legal to scrape Google Hotels?

Scraping public data is generally allowed in the US and most of the EU, as long as you don't collect personal data covered by GDPR or CCPA without a lawful basis. This actor only touches publicly accessible pages, but how you use the output is on you.

Apify's full breakdown: [Is web scraping legal?](https://blog.apify.com/is-web-scraping-legal/).

#### Can I integrate Google Hotels Scraper with other tools?

Push results into **Make, Zapier, Slack, Airbyte, GitHub, Google Sheets, Google Drive**, and more. Apify treats every actor as a webhook source, so anything that consumes webhooks or pulls from an API works.

Full list: [Apify integrations](https://docs.apify.com/platform/integrations).

#### Can I use Google Hotels Scraper with the Apify API?

Yes. Every run is available via the Apify REST API:

```bash
curl -X POST "https://api.apify.com/v2/acts/sourabhbgp~google-hotels-scraper/runs?token=APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"query": "hotels in Paris", "checkIn": "2026-09-15", "checkOut": "2026-09-18", "scrapeRoomDetails": true}'
```

Docs: [Apify API reference](https://docs.apify.com/api/v2).

#### Can I use Google Hotels Scraper through an MCP Server?

Yes. Apify ships an MCP server that exposes every actor as a tool, so Claude Desktop, Cursor, and any other MCP-capable client can call it. Setup: [Apify MCP docs](https://docs.apify.com/platform/integrations/mcp).

### Your feedback

Bug, missing field, or odd behavior? Drop a note in the [Issues tab](https://console.apify.com/actors/1oZcalQXjt8Nba90c/issues). Reports go to a human and fixes usually ship the same week.

# Actor input Schema

## `query` (type: `string`):

What to search on Google Hotels. Use a destination phrase, for example 'hotels in Paris', 'hotels near Times Square New York', or 'beach resorts in Bali'.

## `checkIn` (type: `string`):

Check-in date in YYYY-MM-DD format. Leave empty to default to a stay about two weeks from today (prices depend on the dates, so set them for a specific trip).

## `checkOut` (type: `string`):

Check-out date in YYYY-MM-DD format. Leave empty to default to one night after check-in.

## `adults` (type: `integer`):

Number of adult guests. Prices and availability adjust to the party size.

## `currency` (type: `string`):

Currency for the prices.

## `maxItems` (type: `integer`):

Upper limit on hotels returned. Google Hotels serves a curated set per query (often a few dozen), so a broad query returns fewer than a very large cap. For more coverage, run several specific queries (by neighborhood or landmark, e.g. 'hotels in Le Marais Paris', 'hotels near Eiffel Tower').

## `scrapeRoomDetails` (type: `boolean`):

For every hotel found, also fetch the full price breakdown: each booking vendor (Booking.com, Expedia, the hotel's own site, and others) with its nightly and total price, plus the individual room types and their nightly rates. This is the premium data no search-only scraper returns. It adds two extra requests per hotel, so it runs slower. Room-level data is not published by Google for every hotel; when it is missing the hotel still returns its vendor prices.

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

Proxy settings. The default (Apify datacenter, auto-routed) is cheapest and works. Pick a country close to your target market for locale-accurate availability.

## Actor input object example

```json
{
  "query": "hotels in Paris",
  "checkIn": "2026-08-03",
  "checkOut": "2026-08-04",
  "adults": 2,
  "currency": "USD",
  "maxItems": 50,
  "scrapeRoomDetails": false,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `results` (type: `string`):

View the scraped hotels in the dataset.

# 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 = {
    "query": "hotels in Paris",
    "adults": 2,
    "maxItems": 50,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("sourabhbgp/google-hotels-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 = {
    "query": "hotels in Paris",
    "adults": 2,
    "maxItems": 50,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("sourabhbgp/google-hotels-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 '{
  "query": "hotels in Paris",
  "adults": 2,
  "maxItems": 50,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call sourabhbgp/google-hotels-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Google Hotels Scraper - Prices, Ratings, Vendor & Room Rates",
        "description": "Scrape Google Hotels by destination and dates for prices, star class, ratings, reviews, amenities, coordinates, photos, and booking links. Turn on detail mode to add every booking site's rate and each room type's price. Export to JSON, CSV, or Excel.",
        "version": "0.0",
        "x-build-id": "Jdiqw0msVzgHfCUVO"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/sourabhbgp~google-hotels-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-sourabhbgp-google-hotels-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/sourabhbgp~google-hotels-scraper/runs": {
            "post": {
                "operationId": "runs-sync-sourabhbgp-google-hotels-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/sourabhbgp~google-hotels-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-sourabhbgp-google-hotels-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "query"
                ],
                "properties": {
                    "query": {
                        "title": "Search query",
                        "type": "string",
                        "description": "What to search on Google Hotels. Use a destination phrase, for example 'hotels in Paris', 'hotels near Times Square New York', or 'beach resorts in Bali'."
                    },
                    "checkIn": {
                        "title": "Check-in date",
                        "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
                        "type": "string",
                        "description": "Check-in date in YYYY-MM-DD format. Leave empty to default to a stay about two weeks from today (prices depend on the dates, so set them for a specific trip)."
                    },
                    "checkOut": {
                        "title": "Check-out date",
                        "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
                        "type": "string",
                        "description": "Check-out date in YYYY-MM-DD format. Leave empty to default to one night after check-in."
                    },
                    "adults": {
                        "title": "Adults",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "Number of adult guests. Prices and availability adjust to the party size."
                    },
                    "currency": {
                        "title": "Currency",
                        "enum": [
                            "USD",
                            "EUR",
                            "GBP",
                            "INR",
                            "JPY",
                            "AUD",
                            "CAD",
                            "CHF",
                            "CNY",
                            "AED",
                            "SGD",
                            "BRL",
                            "MXN",
                            "ZAR"
                        ],
                        "type": "string",
                        "description": "Currency for the prices.",
                        "default": "USD"
                    },
                    "maxItems": {
                        "title": "Max hotels",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Upper limit on hotels returned. Google Hotels serves a curated set per query (often a few dozen), so a broad query returns fewer than a very large cap. For more coverage, run several specific queries (by neighborhood or landmark, e.g. 'hotels in Le Marais Paris', 'hotels near Eiffel Tower')."
                    },
                    "scrapeRoomDetails": {
                        "title": "Scrape room and vendor details",
                        "type": "boolean",
                        "description": "For every hotel found, also fetch the full price breakdown: each booking vendor (Booking.com, Expedia, the hotel's own site, and others) with its nightly and total price, plus the individual room types and their nightly rates. This is the premium data no search-only scraper returns. It adds two extra requests per hotel, so it runs slower. Room-level data is not published by Google for every hotel; when it is missing the hotel still returns its vendor prices.",
                        "default": false
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Proxy settings. The default (Apify datacenter, auto-routed) is cheapest and works. Pick a country close to your target market for locale-accurate availability.",
                        "default": {
                            "useApifyProxy": 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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
