# Google Hotels Scraper (`scrapebase/google-hotels-scraper`) Actor

🏨 Scrape hotel data from Google Travel — prices, ratings, reviews, amenities, photos & more. Get structured JSON ready for APIs, apps & dashboards. Smart proxy, rich output.

- **URL**: https://apify.com/scrapebase/google-hotels-scraper.md
- **Developed by:** [ScrapeBase](https://apify.com/scrapebase) (community)
- **Categories:** Automation, Lead generation, AI
- **Stats:** 4 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$19.99/month + usage

To use this Actor, you pay a monthly rental fee to the developer. The rent is subtracted from your prepaid usage every month after the free trial period.You also pay for the Apify platform usage, which gets cheaper the higher Apify subscription plan you have.

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

## 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

Google Hotels Scraper is a fast, reliable scraper for Google Travel hotel results that turns live listings into structured datasets with prices, ratings, amenities, photos, GPS, and contact details. It solves the complexity of large-scale Google Hotels scraping by handling pagination, parsing provider offers, and applying smart proxy fallback — ideal for marketers, developers, data analysts, and researchers who need a dependable google hotels scraper tool for apps, APIs, and dashboards. At scale, this google hotels data extraction workflow helps you monitor pricing, enrich listings, and build analytics-ready pipelines.

### What data / output can you get?

Below are the real JSON fields saved to the Apify dataset. You can export results to JSON, CSV, or Excel from the dataset.

| Data type | Description | Example value |
| --- | --- | --- |
| title | Hotel name extracted from the property page | “Hotel Example Prague” |
| url | Canonical Google Travel hotel entity URL | https://www.google.com/travel/hotels/entity/ChIJ... |
| website | Outbound site/booking link discovered on the page | https://www.booking.com/hotel/xx.html |
| address | Formatted street address | “Na Příkopě 12, 110 00 Praha 1, Czechia” |
| phone | International phone number (validated) | “+420 123 456 789” |
| photos | Array of image URLs (sampled from Googleusercontent) | ["https://lh3.googleusercontent.com/p/photo1.jpg"] |
| thumbnail | Primary image URL (first available photo) | https://lh3.googleusercontent.com/gps-cs-s/... |
| rating | Star rating (0–5) parsed from page data | 4.4 |
| reviews | Total review count (integer) | 1287 |
| stars | Star score (falls back to rating when available) | 4.0 |
| amenities | List of amenities captured from Location/Details pages | ["Free Wi‑Fi","Breakfast included","Parking"] |
| gps | Latitude/longitude object (from page, link, or geocode) | {"lat": 50.087, "lng": 14.421} |
| prices | Array of provider offers with parsed price and link | [{"provider":"Booking.com","price":150,"link":"https://www.google.com/travel/clk?..."}] |
| priceRange | Computed min–max from the prices array | “150 - 155” |
| aboutHotel | Long-form description text (when available) | “Centrally located property near Old Town...” |
| healthAndSafety | List of health & safety highlights | ["Enhanced cleaning","Contactless check-in"] |
| addressAndContact | Address/phone plus check-in/out times from details | {"address":"…","phone":"…","checkIn":"From 14:00","checkOut":"Until 11:00"} |
| searchQuery | The specific query string that produced the item | “Prague hotels” |

Bonus: Media-rich fields (photos, thumbnail) and geo metadata (gps) make it a practical google maps hotel scraper alternative for location-based analysis and visualization.

### Key features

- 🔄 Smart proxy fallback & escalation  
  Automatic retry and proxy escalation (none → datacenter → residential) to keep your google hotels scraping resilient against rate limits and blocks.

- 💰 Provider price parsing  
  Extracts multi-provider offers from Google Travel (e.g., Booking.com, Expedia, Hotels.com, Trip.com) and computes a priceRange — perfect for a google hotel prices scraper.

- 🧭 Rich hotel profiles from multiple pages  
  Fetches the main page plus /location and /details for deeper fields like amenities, aboutHotel, healthAndSafety, gps, and addressAndContact.

- 🗺️ Accurate geodata for mapping  
  Captures gps (lat/lng) from links and page scripts, with an optional geocode fallback from address — great for mapping and spatial analysis with a google travel hotels scraper.

- ⚙️ Batch scraping & parallel processing  
  Processes hotels in small concurrent batches to balance speed and reliability. Control scale via maxResults (1–5000 per search).

- 🗓️ Date- and party-aware search  
  Inputs include checkInDate, checkOutDate, numberOfAdults, numberOfChildren, and currencyCode — making it a practical google hotel availability scraper complement for time-bound pricing.

- 📦 Structured, export-ready output  
  Clean JSON records with consistent fields (title, rating, reviews, prices, amenities, gps, media) ready for CSV/JSON/Excel exports and BI dashboards.

- 🧑‍💻 Developer-friendly on Apify  
  Runs as a production-ready Apify actor. Integrate with the Apify API or SDK to automate pipelines and build your own google hotels api alternative without managing browsers.

- 🏷️ Global coverage via Google Travel  
  Works wherever Google Hotels results are available, letting you scrape google hotel listings across cities and markets.

### How to use Google Hotels Scraper - step by step

1. 🔑 Sign in to Apify  
   Create a free Apify account or log in to your dashboard.

2. 🔎 Find the actor  
   Search for “Google Hotels Scraper” and open the actor page.

3. 🧾 Add input data  
   In searchQuery, enter one or more strings like “Prague hotels”, “Paris center”, or any city/area keywords for bulk runs.

4. ⏱️ Set dates & guests  
   Configure checkInDate, checkOutDate, numberOfAdults, and numberOfChildren to align prices with your travel window and party size.

5. 💱 Choose a currency  
   Set currencyCode (e.g., EUR, USD, GBP) to normalize price outputs.

6. 📈 Control scale  
   Set maxResults (1–5000) to limit how many hotel entities to collect per query.

7. 🛡️ Configure proxy (optional)  
   Leave proxyConfiguration as-is to start free; the actor auto-upgrades to stronger proxies only if needed.

8. ▶️ Run the actor  
   Click Start. The run will fetch results, follow hotel entity pages, and push structured items to the dataset.

9. 💾 Download results  
   Open the run’s Dataset tab and export to JSON, CSV, or Excel for analysis or downstream processing.

Pro tip: Add multiple cities to searchQuery for a single run that scrapes google hotels SERP results across markets. Connect the dataset to your pipelines via the Apify API for end-to-end automation.

### Use cases

| Use case name | Description |
| --- | --- |
| Travel agencies — competitor price tracking | Monitor prices across providers and compute priceRange to optimize offers and promotions. |
| Revenue management — dynamic pricing insights | Compare nightly rates from Booking.com/Expedia and detect spreads for pricing decisions. |
| Market research — rating & review trend analysis | Aggregate rating and reviews counts for sentiment proxies and market benchmarking. |
| Travel apps — listings enrichment | Enrich hotel profiles with website, amenities, photos, and gps for richer UX and SEO. |
| Mapping & geospatial analysis | Use gps lat/lng to visualize supply and hotspots, a robust google maps hotel scraper alternative. |
| Data analysts — dashboards & BI | Build live dashboards from structured JSON exports for city-level or chain-level KPIs. |
| Academic research — tourism & price studies | Collect multi-city datasets to analyze accommodation costs and tourism patterns over time. |
| Developer pipelines — API-based ingestion | Treat the actor as a google hotels scraper API source for ETL into warehouses and ML models. |

### Why choose Google Hotels Scraper?

This actor combines precision extraction with production-grade reliability, giving you clean hotel data and resilient crawling in one package.

- ⚡ Accurate, structured fields (ready for CSV/JSON/Excel)
- 🔄 Resilient scraping with smart proxy escalation
- 🌍 Scales from single cities to multi-market batches (1–5000 per query)
- 🧑‍💻 Built for developers — integrate via Apify API and SDK
- 🛡️ Ethical-by-design with throttling and responsible defaults
- 🧱 More stable than browser extensions or ad-hoc scripts
- 🔎 Ideal alternative when a formal google hotels api isn’t available

In short, it’s a reliable google hotels scraper tool for teams who value clean data, automation, and stability.

### Is it legal / ethical to use Google Hotels Scraper?

Yes — when done responsibly. This actor extracts publicly available information from Google Travel hotel pages and does not require authentication.

Guidelines for responsible use:
- Only collect public data and avoid sensitive information.
- Respect website terms and robots directives where applicable.
- Do not overload servers; keep runs reasonable and use proxies responsibly.
- Use data for analysis, research, or fair competition, and consult your legal team for specific compliance (e.g., GDPR/CCPA) in your jurisdiction.

### Input parameters & output format

#### Example input JSON
```json
{
  "searchQuery": [
    "Prague hotels",
    "Paris city center accommodation"
  ],
  "maxResults": 10,
  "checkInDate": "2026-12-01",
  "checkOutDate": "2026-12-05",
  "numberOfAdults": 2,
  "numberOfChildren": 0,
  "currencyCode": "EUR",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
````

#### Parameters

| Field | Type | Required | Default | Description |
| --- | --- | --- | --- | --- |
| searchQuery | array (stringList) | Yes | None (prefill: \["Prague hotels"]) | Type cities, areas, or keywords — e.g. ‘Prague hotels’, ‘Paris center’, ‘Manhattan NYC’. Add multiple for bulk scraping. |
| maxResults | integer | No | 10 | Pick 1–5000 hotels per search. Tip: start with 10–20 to test, then scale up. |
| checkInDate | string (YYYY-MM-DD) | No | 2026-12-01 | Your arrival date. Prices depend on this. |
| checkOutDate | string (YYYY-MM-DD) | No | 2026-12-05 | Your departure date. Must be after check-in. |
| numberOfAdults | integer | No | 2 | How many adults? (1–10). Affects room options & pricing. |
| numberOfChildren | integer | No | 0 | How many children? (0–10). Optional — affects availability. |
| currencyCode | string (3-letter) | No | EUR | 3-letter code: EUR, USD, GBP, BRL, TRY, etc. Prices shown in this currency. |
| proxyConfiguration | object | No | prefill: {"useApifyProxy": false} | Leave default to start free. Actor auto-upgrades to paid proxy only if needed. |

#### Example output JSON

```json
[
  {
    "thumbnail": "https://lh3.googleusercontent.com/gps-cs-s/...",
    "url": "https://www.google.com/travel/hotels/entity/ChIJ.../",
    "title": "Hotel Example Prague",
    "website": "https://www.booking.com/hotel/xx.html",
    "address": "Na Příkopě 12, 110 00 Praha 1, Czechia",
    "phone": "+420 123 456 789",
    "photos": [
      "https://lh3.googleusercontent.com/p/photo1.jpg",
      "https://lh3.googleusercontent.com/p/photo2.jpg"
    ],
    "rating": 4.4,
    "reviews": 1287,
    "prices": [
      {
        "provider": "Booking.com",
        "price": 150,
        "link": "https://www.google.com/travel/clk?..."
      },
      {
        "provider": "Expedia",
        "price": 155,
        "link": "https://www.google.com/travel/clk?..."
      }
    ],
    "priceRange": "150 - 155",
    "stars": 4.0,
    "amenities": [
      "Free Wi‑Fi",
      "Breakfast included",
      "Parking"
    ],
    "gps": {
      "lat": 50.087,
      "lng": 14.421
    },
    "aboutHotel": "Centrally located property near Old Town with modern rooms and amenities.",
    "healthAndSafety": [
      "Enhanced cleaning",
      "Contactless check-in"
    ],
    "addressAndContact": {
      "address": "Na Příkopě 12, 110 00 Praha 1, Czechia",
      "phone": "+420 123 456 789",
      "checkIn": "From 14:00",
      "checkOut": "Until 11:00"
    },
    "searchQuery": "Prague hotels"
  }
]
```

Note: Some fields may be empty when the source page does not expose them (e.g., phone, aboutHotel, healthAndSafety). The actor fills gps from page links first and may fall back to geocoding from address when needed.

### FAQ

#### Can this scrape hotel prices from Google?

Yes. The actor captures provider offers in the prices array and summarizes them in priceRange. This makes it a practical google hotel prices scraper for monitoring Booking.com, Expedia, and others.

#### Does it collect reviews or sentiments?

It extracts rating (0–5) and reviews (total count). It does not collect individual review texts in this actor.

#### How many hotels can I scrape per run?

You control this with maxResults. The input schema supports 1–5000 hotels per search query, and you can add multiple queries to searchQuery for bulk runs.

#### Can I run multiple cities at once?

Yes. Add multiple strings (e.g., “Prague hotels”, “Paris center”) to the searchQuery array to scrape google hotel listings across cities in one run.

#### Does it support different currencies?

Yes. Set currencyCode (e.g., EUR, USD, GBP) and the actor will request prices in that currency.

#### Do I need to configure a proxy?

Proxy is optional. The actor starts without a proxy and auto-escalates to datacenter or residential proxies if requests are blocked, improving reliability for google hotels scraping.

#### Is this a Google Hotels API?

No. It’s a scraper that produces structured JSON from Google Travel hotel pages — a dependable google hotels api alternative when you need data without formal API access.

#### How do I export results?

After the run, open the Dataset and export to JSON, CSV, or Excel. These formats make it easy to integrate with BI tools, databases, or apps.

### Final thoughts

Google Hotels Scraper is built for accurate, structured hotel data at scale. With smart proxy fallback, batch processing, and rich fields (prices, amenities, gps, photos), it helps marketers, developers, analysts, and researchers scrape Google hotel results reliably. Integrate via the Apify API to automate ingestion into your data stack, or export CSV/JSON/Excel for quick analysis. Start extracting smarter, faster, and more complete Google Travel hotel data for your next project.

# Actor input Schema

## `searchQuery` (type: `array`):

📍 Type cities, areas, or keywords — e.g. 'Prague hotels', 'Paris center', 'Manhattan NYC'. Add multiple for bulk scraping!

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

🎯 Pick 1–5000 hotels per search. Tip: start with 10–20 to test, then scale up.

## `checkInDate` (type: `string`):

🗓️ Your arrival date (YYYY-MM-DD). Prices depend on this!

## `checkOutDate` (type: `string`):

🗓️ Your departure date (YYYY-MM-DD). Must be after check-in.

## `numberOfAdults` (type: `integer`):

How many adults? (1–10) Affects room options & pricing.

## `numberOfChildren` (type: `integer`):

How many children? (0–10) Optional — affects availability.

## `currencyCode` (type: `string`):

💵 3-letter code: EUR, USD, GBP, BRL, TRY, etc. Prices shown in this currency.

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

🛡️ Leave default to start free. Actor auto-upgrades to paid proxy only if needed.

## Actor input object example

```json
{
  "searchQuery": [
    "Prague hotels"
  ],
  "maxResults": 10,
  "checkInDate": "2026-12-01",
  "checkOutDate": "2026-12-05",
  "numberOfAdults": 2,
  "numberOfChildren": 0,
  "currencyCode": "EUR",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# 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 = {
    "searchQuery": [
        "Prague hotels"
    ],
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapebase/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 = {
    "searchQuery": ["Prague hotels"],
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("scrapebase/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 '{
  "searchQuery": [
    "Prague hotels"
  ],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call scrapebase/google-hotels-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Google Hotels Scraper",
        "description": "🏨 Scrape hotel data from Google Travel — prices, ratings, reviews, amenities, photos & more. Get structured JSON ready for APIs, apps & dashboards. Smart proxy, rich output.",
        "version": "0.1",
        "x-build-id": "c9CPzQ5LEaAkYvlAT"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapebase~google-hotels-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapebase-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/scrapebase~google-hotels-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapebase-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/scrapebase~google-hotels-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapebase-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": [
                    "searchQuery"
                ],
                "properties": {
                    "searchQuery": {
                        "title": "🔍 Where to search?",
                        "type": "array",
                        "description": "📍 Type cities, areas, or keywords — e.g. 'Prague hotels', 'Paris center', 'Manhattan NYC'. Add multiple for bulk scraping!",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxResults": {
                        "title": "📊 How many hotels?",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "🎯 Pick 1–5000 hotels per search. Tip: start with 10–20 to test, then scale up.",
                        "default": 10
                    },
                    "checkInDate": {
                        "title": "📅 Check-in",
                        "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
                        "type": "string",
                        "description": "🗓️ Your arrival date (YYYY-MM-DD). Prices depend on this!",
                        "default": "2026-12-01"
                    },
                    "checkOutDate": {
                        "title": "📅 Check-out",
                        "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
                        "type": "string",
                        "description": "🗓️ Your departure date (YYYY-MM-DD). Must be after check-in.",
                        "default": "2026-12-05"
                    },
                    "numberOfAdults": {
                        "title": "👥 Adults",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "How many adults? (1–10) Affects room options & pricing.",
                        "default": 2
                    },
                    "numberOfChildren": {
                        "title": "👶 Children",
                        "minimum": 0,
                        "maximum": 10,
                        "type": "integer",
                        "description": "How many children? (0–10) Optional — affects availability.",
                        "default": 0
                    },
                    "currencyCode": {
                        "title": "💱 Currency",
                        "minLength": 3,
                        "maxLength": 3,
                        "type": "string",
                        "description": "💵 3-letter code: EUR, USD, GBP, BRL, TRY, etc. Prices shown in this currency.",
                        "default": "EUR"
                    },
                    "proxyConfiguration": {
                        "title": "🔒 Proxy (optional)",
                        "type": "object",
                        "description": "🛡️ Leave default to start free. Actor auto-upgrades to paid proxy only if needed."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
