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

\[💰 $1.0 / 1K] Extract hotel and vacation rental listings from Google Hotels — prices, ratings, amenities, images, GPS, and contact info. Filter by price, stars, amenities, property type, and guest rating across 190+ countries.

- **URL**: https://apify.com/solidcode/google-hotels-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 $1.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

## Google Hotels Scraper

Extract complete hotel and vacation rental data from Google Hotels at scale. Get property names, rates, star ratings, guest reviews, amenities, GPS coordinates, images, check-in/out times, phone numbers, and **25+ data fields** for any destination worldwide — with full support for dates, guest counts, filters, localization, and property-level detail lookups.

### Why This Scraper?

- **Two modes in one actor** — Search by location (e.g., "hotels in Paris") for browsable results, or pass property tokens to pull full details for specific hotels you already care about
- **25+ data fields per property** — Name, rate per night, total stay cost, star class, overall rating, review count, amenity list, full address, GPS coordinates, contact phone, check-in/out times, image gallery, deals, eco-certification, and more
- **Human-readable filters** — Pick amenities (Free Wi-Fi, Pool, Pet-friendly, EV charger…) and property types (Resorts, Boutique hotels, Hostels…) from a dropdown — no hunting down numeric IDs in Google's internal documentation
- **Vacation rentals mode** — Flip one toggle to search houses, villas, cabins, cottages, and apartments instead of hotels, with dedicated rental-type filters
- **Full localization** — 40+ countries, 19 languages, and 21 currencies so prices and property text match the market you're targeting
- **Batch input** — Feed an array of search queries or an array of property tokens and run them all in a single job
- **Clean numeric pricing** — `ratePerNight` and `totalRate` come back as `{ extracted: number, currency: "USD" }` objects, ready to sort, compare, and load into a spreadsheet
- **Transparent, pay-per-page pricing** — $0.02 per search page with no per-result surprises

### Use Cases

**Travel & Hospitality Market Research**
- Track nightly rates across a city, season, or competitive set
- Monitor availability and pricing trends for a destination over time
- Benchmark star class, guest ratings, and amenity mix against competitors

**Lead Generation & Sales**
- Build prospect lists of boutique hotels, resorts, or bed & breakfasts in any region
- Extract phone numbers and addresses for direct outreach campaigns
- Target independent properties by filtering out major chains on star class and property type

**Travel Content & Affiliate Sites**
- Populate "Best hotels in…" or "Top vacation rentals in…" directories with fresh data
- Keep rate cards, review counts, and amenity lists current on destination guides
- Enrich your own travel app with Google's curated property metadata

**Revenue Management & Compset Analysis**
- Pull competitor rates for the same check-in/out window and guest count
- Detect deal flags and discount badges across a market
- Compare your property's amenity coverage against neighbors

**Vacation Rental Intelligence**
- Survey houses, villas, and cabins by bedrooms, bathrooms, and location
- Track nightly rates for short-term rental competitors
- Build destination-specific rental inventories

### Getting Started

#### Simple Search

Just enter a location query — defaults handle the rest (2 adults, next-available dates, US/English/USD):

```json
{
    "searchQueries": ["hotels in Paris"]
}
````

#### Search with Dates & Guests

Target a specific stay window and party size:

```json
{
    "searchQueries": ["hotels in Tokyo", "ryokan in Kyoto"],
    "checkInDate": "2026-05-12",
    "checkOutDate": "2026-05-18",
    "adults": 2,
    "children": 1,
    "childrenAges": "7",
    "language": "en",
    "currency": "JPY",
    "country": "jp"
}
```

#### Filtered Search

Narrow by star rating, required amenities, and property type:

```json
{
    "searchQueries": ["hotels in Barcelona"],
    "checkInDate": "2026-06-10",
    "checkOutDate": "2026-06-14",
    "stars": ["4", "5"],
    "amenities": ["free_wifi", "pool", "air_conditioned"],
    "propertyTypes": ["boutique_hotels", "resorts"],
    "maxPages": 3
}
```

#### Vacation Rentals

Search houses, villas, and apartments instead of hotels:

```json
{
    "searchQueries": ["vacation rentals in Malibu"],
    "vacationRentals": true,
    "rentalTypes": ["villas", "houses"],
    "checkInDate": "2026-07-15",
    "checkOutDate": "2026-07-22",
    "adults": 4
}
```

#### Property Details by Token

Already have property tokens from a previous run? Pull full detail records directly:

```json
{
    "propertyTokens": ["ChkI9Pbw4oLblKdlGg0vZy8xMXc0NnJoMXg3EAE"],
    "checkInDate": "2026-08-01",
    "checkOutDate": "2026-08-05"
}
```

### Input Reference

#### Search

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `searchQueries` | string\[] | `["hotels in Paris"]` | Location-based search queries such as "hotels in Paris" or "Bali resorts". Each query produces its own set of results. |
| `propertyTokens` | string\[] | `[]` | Google Hotels property tokens (from earlier search results) to fetch full property details for specific properties. |

Provide at least one of the two. You can also combine them in a single run.

#### Dates & Guests

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `checkInDate` | string (YYYY-MM-DD) | 14 days from today | Check-in date. Must be today or a future date. |
| `checkOutDate` | string (YYYY-MM-DD) | day after check-in | Check-out date. Must be after check-in. |
| `adults` | integer | `2` | Number of adult guests (1–50). |
| `children` | integer | `0` | Number of child guests (0–50). |
| `childrenAges` | string | `""` | Comma-separated ages (e.g. "5,8,12"). Required when children > 0. Each age 0–17. |

#### Filters

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `stars` | string\[] | `[]` | Only include hotels with these star ratings. Options: `"1"` – `"5"`. |
| `amenities` | string\[] | `[]` | Only include properties that offer all of these amenities. Options: Free parking, Parking, Indoor pool, Outdoor pool, Pool, Fitness center, Restaurant, Free breakfast, Spa, Beach access, Child-friendly, Bar, Pet-friendly, Room service, Free Wi-Fi, Air-conditioned, All-inclusive available, Wheelchair accessible, EV charger. |
| `propertyTypes` | string\[] | `[]` | Only include these hotel property types. Options: Beach hotels, Boutique hotels, Hostels, Inns, Motels, Resorts, Spa hotels, Bed and breakfasts, Apartment hotels, Minshuku, Japanese-style business hotels, Ryokan. Ignored when Vacation Rentals mode is enabled. |

#### Vacation Rentals

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `vacationRentals` | boolean | `false` | Search vacation rentals (houses, villas, apartments) instead of hotels. |
| `rentalTypes` | string\[] | `[]` | Rental types to include. Options: Apartments, Bungalows, Cabins, Chalets, Cottages, Gîtes, Holiday villages, Houses, Houseboats, Villas, Apartment hotels. |

#### Localization

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `country` | string | `"us"` | Country code for localizing results (ISO 3166-1 alpha-2). 40+ countries supported. |
| `language` | string | `"en"` | Language for result text (ISO 639-1). 19 languages supported. |
| `currency` | string | `"USD"` | Currency for prices (ISO 4217). 21 currencies supported. |

#### Advanced

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `maxPages` | integer | `1` | Maximum number of result pages to fetch per search query. Set to `0` for all available pages. |

### Output

Each search produces one **metadata** record per query plus one **property** record per result. Here's a typical property row:

```json
{
    "query": "hotels in Paris",
    "pageNumber": 1,
    "type": "Hotel",
    "name": "Le Meurice",
    "description": "Elegant palace hotel across from the Tuileries with Michelin-starred dining.",
    "link": "https://www.google.com/travel/hotels/entity/ChkI...",
    "propertyToken": "ChkI9Pbw4oLblKdlGg0vZy8xMXc0NnJoMXg3EAE",
    "googlePlaceId": "ChIJyRd3u9Fu5kcRnvqiJqZULNk",
    "address": "228 Rue de Rivoli, 75001 Paris, France",
    "gpsCoordinates": { "latitude": 48.865074, "longitude": 2.328047 },
    "checkInTime": "15:00",
    "checkOutTime": "12:00",
    "ratePerNight": { "extracted": 1850, "currency": "USD", "formatted": "$1,850" },
    "totalRate": { "extracted": 3700, "currency": "USD", "formatted": "$3,700" },
    "deal": null,
    "dealDescription": null,
    "hotelClass": "5-star hotel",
    "extractedHotelClass": 5,
    "images": [
        "https://lh3.googleusercontent.com/...",
        "https://lh3.googleusercontent.com/..."
    ],
    "overallRating": 4.7,
    "reviews": 3421,
    "locationRating": 4.9,
    "amenities": [
        "Free Wi-Fi",
        "Spa",
        "Restaurant",
        "Bar",
        "Air conditioning",
        "Room service"
    ],
    "ecoCertified": false,
    "phone": "+33 1 44 58 10 10",
    "phoneLink": "tel:+33144581010",
    "nearbyPlaces": [],
    "essentialInfo": []
}
```

And a metadata row (one per query, on the first page):

```json
{
    "query": "hotels in Paris",
    "totalResults": 1427,
    "pagesProcessed": 1,
    "searchTimestamp": "2026-04-21T14:08:52Z",
    "filters": [],
    "refineBy": []
}
```

#### All Available Fields

**Property result fields**

| Field | Type | Description |
|-------|------|-------------|
| `query` | string | The search query this result came from |
| `pageNumber` | integer | 1-indexed page number |
| `type` | string | `"Hotel"` or `"Vacation rental"` |
| `name` | string | Property name |
| `description` | string | Short property description |
| `link` | string | Google Hotels URL for the property |
| `propertyToken` | string | Token usable with `propertyTokens` to fetch detailed info |
| `googlePlaceId` | string | Google Place ID for cross-referencing |
| `address` | string | Full formatted address |
| `gpsCoordinates` | object | `{ latitude, longitude }` |
| `checkInTime` | string | Local check-in time (e.g. `"15:00"`) |
| `checkOutTime` | string | Local check-out time |
| `ratePerNight` | object | `{ extracted, currency, formatted }` |
| `totalRate` | object | `{ extracted, currency, formatted }` for the full stay |
| `deal` | string | Deal badge name, if any |
| `dealDescription` | string | Deal details |
| `hotelClass` | string | Human-readable class label (e.g. `"4-star hotel"`, `"Entire villa"`) |
| `extractedHotelClass` | integer | Numeric star class 1–5 |
| `images` | string\[] | Image URLs |
| `overallRating` | number | Overall guest rating 0.0–5.0 |
| `reviews` | integer | Total review count |
| `locationRating` | number | Location-specific rating 0.0–5.0 |
| `amenities` | string\[] | Amenity labels the property offers |
| `ecoCertified` | boolean | Eco-certification flag |
| `phone` | string | Contact phone number |
| `phoneLink` | string | `tel:` link |
| `nearbyPlaces` | array | Nearby attractions and landmarks |
| `essentialInfo` | array | Highlighted info from Google (policies, features) |

**Extra fields when using `propertyTokens`**

| Field | Type | Description |
|-------|------|-------------|
| `excludedAmenities` | string\[] | Amenities the property explicitly does not offer |
| `detailedReviews` | array | Review score breakdown by category |

**Search metadata fields**

| Field | Type | Description |
|-------|------|-------------|
| `query` | string | The search query |
| `totalResults` | integer | Total results available on Google |
| `pagesProcessed` | integer | How many pages this run fetched |
| `searchTimestamp` | string | ISO 8601 timestamp of when the search ran |
| `filters` | array | Available filter options returned by Google |
| `refineBy` | array | Suggested refinements for narrowing the query |

### Tips for Best Results

- **Be specific in queries** — "hotels in Paris 1st arrondissement" returns tighter, more relevant results than "hotels in Paris"
- **Always set dates** — Rates and availability only appear when check-in and check-out are provided, and they drive Google's price sorting
- **Match currency to destination** — Prices in the native currency are cleaner (no FX rounding artifacts). Use `currency: "EUR"` for European hotels, `"JPY"` for Japan, etc.
- **Stack filters thoughtfully** — Combining stars, amenities, and property type can over-constrain a market. Start broad, then filter
- **First page is richest** — Page 1 returns the fullest property cards. If you need deep coverage, set `maxPages` higher, but expect lighter detail on subsequent pages — then pass `propertyToken` back in a second run for complete detail
- **Vacation rentals are separate** — Hotels and vacation rentals come from two different modes on Google. If you need both, run two jobs
- **Children require ages** — If `children > 0`, `childrenAges` must list exactly that many comma-separated integers (0–17), or Google rejects the request

### Pricing

**$0.02 per search page** — transparent, predictable, pay only for what you fetch.

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

Each search query fetches `maxPages` pages (default 1). Each page typically returns ~18–20 properties. Property-token detail lookups count as one page each. Platform fees (compute, proxy, storage) depend on your Apify plan and are additional.

### Integrations

Export data in JSON, CSV, Excel, XML, or RSS. Connect to 1,500+ apps via:

- **Zapier** / **Make** / **n8n** — Workflow automation
- **Google Sheets** — Direct spreadsheet export
- **Slack** / **Email** — Notifications on new results
- **Webhooks** — Custom API integrations
- **Apify API** — Full programmatic access to runs and datasets

### Legal & Ethical Use

This actor is designed for legitimate travel market research, competitive intelligence, rate tracking, and content enrichment. Users are responsible for complying with applicable laws and Google's Terms of Service. Do not use extracted data for spam, harassment, misrepresentation, or any illegal purpose. The actor collects only publicly visible property information — no personal user data.

# Actor input Schema

## `searchQueries` (type: `array`):

Location-based search queries such as 'hotels in Paris' or 'Bali resorts'. Each query produces its own set of results. Leave empty if using property tokens.

## `propertyTokens` (type: `array`):

Google Hotels property tokens for specific properties (obtained from earlier search results). Use these to fetch full property details.

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

Check-in date in YYYY-MM-DD format. Must be today or a future date.

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

Check-out date in YYYY-MM-DD format. Must be after check-in.

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

Number of adult guests.

## `children` (type: `integer`):

Number of child guests.

## `childrenAges` (type: `string`):

Comma-separated ages of children (e.g., '5,8,12'). Required when Children is greater than 0. Each age must be between 0 and 17.

## `stars` (type: `array`):

Only include hotels with these star ratings.

## `amenities` (type: `array`):

Only include properties that offer all of these amenities.

## `propertyTypes` (type: `array`):

Only include these hotel property types. Ignored when Vacation Rentals mode is enabled.

## `vacationRentals` (type: `boolean`):

Search vacation rentals (houses, villas, apartments) instead of hotels. Note: you cannot mix hotels and vacation rentals in one search — run two separate searches if needed.

## `rentalTypes` (type: `array`):

Only include these rental types. Applies when Vacation Rentals is enabled.

## `country` (type: `string`):

Country code (gl) for localizing results. Use ISO 3166-1 alpha-2 (e.g., 'us', 'uk', 'fr').

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

Language code (hl) for result text. Use ISO 639-1 (e.g., 'en', 'fr', 'de').

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

Currency code for prices (ISO 4217).

## `maxPages` (type: `integer`):

Maximum number of result pages to fetch per search query. Set to 0 for all available pages. Each page is charged separately.

## Actor input object example

```json
{
  "searchQueries": [
    "hotels in Paris"
  ],
  "propertyTokens": [],
  "adults": 2,
  "children": 0,
  "stars": [],
  "amenities": [],
  "propertyTypes": [],
  "vacationRentals": false,
  "rentalTypes": [],
  "country": "us",
  "language": "en",
  "currency": "USD",
  "maxPages": 1
}
```

# Actor output Schema

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

Table of properties with key fields like name, rating, price, and address.

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

Full per-property detail rows including amenities, images, and contact info.

# 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 = {
    "searchQueries": [
        "hotels in Paris"
    ],
    "propertyTokens": [],
    "checkInDate": "",
    "checkOutDate": "",
    "adults": 2,
    "children": 0,
    "stars": [],
    "amenities": [],
    "propertyTypes": [],
    "vacationRentals": false,
    "rentalTypes": [],
    "country": "us",
    "language": "en",
    "currency": "USD",
    "maxPages": 1
};

// Run the Actor and wait for it to finish
const run = await client.actor("solidcode/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 = {
    "searchQueries": ["hotels in Paris"],
    "propertyTokens": [],
    "checkInDate": "",
    "checkOutDate": "",
    "adults": 2,
    "children": 0,
    "stars": [],
    "amenities": [],
    "propertyTypes": [],
    "vacationRentals": False,
    "rentalTypes": [],
    "country": "us",
    "language": "en",
    "currency": "USD",
    "maxPages": 1,
}

# Run the Actor and wait for it to finish
run = client.actor("solidcode/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 '{
  "searchQueries": [
    "hotels in Paris"
  ],
  "propertyTokens": [],
  "checkInDate": "",
  "checkOutDate": "",
  "adults": 2,
  "children": 0,
  "stars": [],
  "amenities": [],
  "propertyTypes": [],
  "vacationRentals": false,
  "rentalTypes": [],
  "country": "us",
  "language": "en",
  "currency": "USD",
  "maxPages": 1
}' |
apify call solidcode/google-hotels-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Google Hotels Scraper",
        "description": "[💰 $1.0 / 1K] Extract hotel and vacation rental listings from Google Hotels — prices, ratings, amenities, images, GPS, and contact info. Filter by price, stars, amenities, property type, and guest rating across 190+ countries.",
        "version": "1.0",
        "x-build-id": "u9m0mfvmTlfM9UpRE"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/solidcode~google-hotels-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-solidcode-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/solidcode~google-hotels-scraper/runs": {
            "post": {
                "operationId": "runs-sync-solidcode-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/solidcode~google-hotels-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-solidcode-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",
                "properties": {
                    "searchQueries": {
                        "title": "Search Queries",
                        "type": "array",
                        "description": "Location-based search queries such as 'hotels in Paris' or 'Bali resorts'. Each query produces its own set of results. Leave empty if using property tokens.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "propertyTokens": {
                        "title": "Property Tokens",
                        "type": "array",
                        "description": "Google Hotels property tokens for specific properties (obtained from earlier search results). Use these to fetch full property details.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "checkInDate": {
                        "title": "Check-in Date",
                        "type": "string",
                        "description": "Check-in date in YYYY-MM-DD format. Must be today or a future date."
                    },
                    "checkOutDate": {
                        "title": "Check-out Date",
                        "type": "string",
                        "description": "Check-out date in YYYY-MM-DD format. Must be after check-in."
                    },
                    "adults": {
                        "title": "Adults",
                        "minimum": 1,
                        "maximum": 50,
                        "type": "integer",
                        "description": "Number of adult guests.",
                        "default": 2
                    },
                    "children": {
                        "title": "Children",
                        "minimum": 0,
                        "maximum": 50,
                        "type": "integer",
                        "description": "Number of child guests.",
                        "default": 0
                    },
                    "childrenAges": {
                        "title": "Children Ages",
                        "type": "string",
                        "description": "Comma-separated ages of children (e.g., '5,8,12'). Required when Children is greater than 0. Each age must be between 0 and 17."
                    },
                    "stars": {
                        "title": "Star Ratings",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Only include hotels with these star ratings.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "1",
                                "2",
                                "3",
                                "4",
                                "5"
                            ],
                            "enumTitles": [
                                "1 star",
                                "2 stars",
                                "3 stars",
                                "4 stars",
                                "5 stars"
                            ]
                        },
                        "default": []
                    },
                    "amenities": {
                        "title": "Required Amenities",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Only include properties that offer all of these amenities.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "free_parking",
                                "parking",
                                "indoor_pool",
                                "outdoor_pool",
                                "pool",
                                "fitness_center",
                                "restaurant",
                                "free_breakfast",
                                "spa",
                                "beach_access",
                                "child_friendly",
                                "bar",
                                "pet_friendly",
                                "room_service",
                                "free_wifi",
                                "air_conditioned",
                                "all_inclusive",
                                "wheelchair_accessible",
                                "ev_charger"
                            ],
                            "enumTitles": [
                                "Free parking",
                                "Parking",
                                "Indoor pool",
                                "Outdoor pool",
                                "Pool",
                                "Fitness center",
                                "Restaurant",
                                "Free breakfast",
                                "Spa",
                                "Beach access",
                                "Child-friendly",
                                "Bar",
                                "Pet-friendly",
                                "Room service",
                                "Free Wi-Fi",
                                "Air-conditioned",
                                "All-inclusive available",
                                "Wheelchair accessible",
                                "EV charger"
                            ]
                        },
                        "default": []
                    },
                    "propertyTypes": {
                        "title": "Hotel Property Types",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Only include these hotel property types. Ignored when Vacation Rentals mode is enabled.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "beach_hotels",
                                "boutique_hotels",
                                "hostels",
                                "inns",
                                "motels",
                                "resorts",
                                "spa_hotels",
                                "bed_and_breakfasts",
                                "apartment_hotels",
                                "minshuku",
                                "japanese_business_hotels",
                                "ryokan"
                            ],
                            "enumTitles": [
                                "Beach hotels",
                                "Boutique hotels",
                                "Hostels",
                                "Inns",
                                "Motels",
                                "Resorts",
                                "Spa hotels",
                                "Bed and breakfasts",
                                "Apartment hotels",
                                "Minshuku",
                                "Japanese-style business hotels",
                                "Ryokan"
                            ]
                        },
                        "default": []
                    },
                    "vacationRentals": {
                        "title": "Search Vacation Rentals",
                        "type": "boolean",
                        "description": "Search vacation rentals (houses, villas, apartments) instead of hotels. Note: you cannot mix hotels and vacation rentals in one search — run two separate searches if needed.",
                        "default": false
                    },
                    "rentalTypes": {
                        "title": "Rental Types",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Only include these rental types. Applies when Vacation Rentals is enabled.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "apartments",
                                "bungalows",
                                "cabins",
                                "chalets",
                                "cottages",
                                "gites",
                                "holiday_villages",
                                "houses",
                                "houseboats",
                                "villas",
                                "apartment_hotels"
                            ],
                            "enumTitles": [
                                "Apartments",
                                "Bungalows",
                                "Cabins",
                                "Chalets",
                                "Cottages",
                                "Gîtes",
                                "Holiday villages",
                                "Houses",
                                "Houseboats",
                                "Villas",
                                "Apartment hotels"
                            ]
                        },
                        "default": []
                    },
                    "country": {
                        "title": "Country",
                        "enum": [
                            "us",
                            "uk",
                            "ca",
                            "au",
                            "nz",
                            "ie",
                            "fr",
                            "de",
                            "es",
                            "it",
                            "nl",
                            "be",
                            "pt",
                            "ch",
                            "at",
                            "se",
                            "no",
                            "dk",
                            "fi",
                            "pl",
                            "jp",
                            "kr",
                            "cn",
                            "hk",
                            "tw",
                            "sg",
                            "my",
                            "th",
                            "id",
                            "ph",
                            "vn",
                            "in",
                            "br",
                            "mx",
                            "ar",
                            "cl",
                            "co",
                            "ae",
                            "sa",
                            "tr",
                            "il",
                            "za",
                            "eg"
                        ],
                        "type": "string",
                        "description": "Country code (gl) for localizing results. Use ISO 3166-1 alpha-2 (e.g., 'us', 'uk', 'fr').",
                        "default": "us"
                    },
                    "language": {
                        "title": "Language",
                        "enum": [
                            "en",
                            "fr",
                            "de",
                            "es",
                            "it",
                            "pt",
                            "nl",
                            "pl",
                            "tr",
                            "ru",
                            "ja",
                            "ko",
                            "zh-CN",
                            "zh-TW",
                            "ar",
                            "he",
                            "th",
                            "vi",
                            "id"
                        ],
                        "type": "string",
                        "description": "Language code (hl) for result text. Use ISO 639-1 (e.g., 'en', 'fr', 'de').",
                        "default": "en"
                    },
                    "currency": {
                        "title": "Currency",
                        "enum": [
                            "USD",
                            "EUR",
                            "GBP",
                            "CAD",
                            "AUD",
                            "NZD",
                            "JPY",
                            "CNY",
                            "HKD",
                            "SGD",
                            "INR",
                            "BRL",
                            "MXN",
                            "CHF",
                            "SEK",
                            "NOK",
                            "DKK",
                            "PLN",
                            "TRY",
                            "AED",
                            "ZAR"
                        ],
                        "type": "string",
                        "description": "Currency code for prices (ISO 4217).",
                        "default": "USD"
                    },
                    "maxPages": {
                        "title": "Maximum Pages per Query",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of result pages to fetch per search query. Set to 0 for all available pages. Each page is charged separately.",
                        "default": 1
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
