# Google Hotels Search Scraper (`automation-lab/google-hotels-search-scraper`) Actor

Extract Google Hotels listings by destination and stay dates: nightly prices, displayed currency, ratings, review counts, class, amenities, badges, sponsorship, and property IDs. Export JSON, CSV, or Excel; schedule recurring hotel rate monitoring.

- **URL**: https://apify.com/automation-lab/google-hotels-search-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Travel, E-commerce, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

Extract public Google Hotels listings into structured data for **hotel price monitoring, destination research, and travel market analysis**.

Google Hotels Search Scraper returns one row per property with the displayed nightly rate and currency, rating, review count, class, amenities, badges, sponsorship status, Google property identifier, and source URL.

No Google account or API key is required.

### What does Google Hotels Search Scraper do?

Google Hotels Search Scraper opens the public [Google Hotels](https://www.google.com/travel/hotels) experience in a real browser and converts destination search cards into clean dataset records.

Use it to:

- 🔎 search one or many destinations
- 📅 apply future check-in and check-out dates
- 👥 set adult and child traveler counts
- 💰 collect the nightly price exactly as Google displays it
- ⭐ extract ratings, review counts, and hotel class
- 🛎️ collect amenity and location or sustainability badges
- 📣 distinguish sponsored cards from organic hotel results
- 🔗 retain Google property identifiers and result URLs
- 🌍 request a language, country, and currency
- 📊 export results as JSON, CSV, Excel, XML, or RSS

The scraper preserves the **displayed currency** rather than silently relabeling a price when Google overrides the requested locale.

### Who is Google Hotels Search Scraper for?

**Hotel revenue and market analysts**

- Monitor nightly rates for destination compsets.
- Compare review strength and hotel-class positioning.
- Track whether properties appear in sponsored placements.

**Travel metasearch and deal teams**

- Build destination-level hotel feeds.
- Detect low-price properties for newsletters or alerts.
- Enrich internal hotel records with Google property IDs.

**OTAs, agencies, and destination marketers**

- Compare visible inventory signals across cities and dates.
- Research amenity coverage for campaign planning.
- Schedule recurring snapshots for client reports.

**Researchers and developers**

- Create reproducible public hotel-market datasets.
- Feed travel applications through the Apify API.
- Connect hotel search data to AI agents through MCP.

### Why use this Google hotel scraper?

- ✅ **Purpose-built output:** one normalized record per hotel, not an unstructured page dump.
- ✅ **No login:** it uses the anonymous public Google Hotels surface.
- ✅ **Date-aware:** stay dates can be selected through Google’s accessible date controls.
- ✅ **Locale-safe:** requested and displayed currencies are never silently mixed.
- ✅ **Sponsored labels:** ad placements remain identifiable.
- ✅ **Fail-closed filters:** records with unparseable values do not slip through numeric filters.
- ✅ **Bounded browser use:** one browser session is reused across sequential searches.
- ✅ **Apify-native:** schedule runs, call an API, add webhooks, and export datasets.

### What Google Hotels data can you extract?

| Category | Field | Description |
|---|---|---|
| Identity | `name` | Property name shown by Google |
| Identity | `propertyId` | Google entity identifier when exposed |
| Identity | `propertyUrl` | Google hotel entity link when exposed |
| Rate | `nightlyPrice` | Numeric displayed nightly price |
| Rate | `priceText` | Original price text, including symbol |
| Rate | `currency` | Currency inferred from displayed text |
| Reputation | `rating` | Google rating from 0 to 5 |
| Reputation | `reviewCount` | Expanded integer review count |
| Property | `hotelClass` | Google hotel class from 1 to 5 |
| Property | `amenities` | Flat list of displayed amenities |
| Signals | `badges` | Eco, location, deal, or ranking labels |
| Offers | `bookingProviders` | Providers when Google exposes external offer links |
| Placement | `isSponsored` | Whether the card is sponsored |
| Search | `position` | Position among accepted records |
| Search | `destination` | Normalized destination text |
| Search | `query` | Original query used for the search |
| Search | `displayedDates` | Dates Google displays for the prices |
| Search | `sourceUrl` | Final Google Hotels results URL |
| Time | `scrapedAt` | ISO timestamp for the snapshot |

Provider names are returned only when they are present on the result card. The Actor leaves the provider array empty rather than inventing an attribution hidden behind another Google panel.

### How much does it cost to scrape Google Hotels?

This Actor uses **pay-per-event** pricing.

A small one-time run fee covers browser startup, followed by a fee for each hotel saved.

| Apify plan | Current per-hotel price |
|---|---:|
| Free | $0.0021625 |
| Starter / Bronze | $0.0018804 |
| Scale / Silver | $0.0014667 |
| Business / Gold | $0.0011283 |
| Platinum | $0.00075217 |
| Diamond | $0.00052652 |

The one-time search setup fee is $0.005 per run.

Examples at the Free tier:

| Hotels | Estimated Actor charge |
|---:|---:|
| 10 | $0.026625 |
| 100 | $0.22125 |
| 1,000 | $2.1675 |

Actual platform limits and maximum-charge settings can stop a run earlier.

Prices will be synchronized with the live Apify pricing configuration before publication.

### How to scrape Google Hotels

1. Open Google Hotels Search Scraper on Apify.
2. Enter one destination, such as `London`.
3. Optionally add future check-in and check-out dates.
4. Choose the traveler count and locale.
5. Add price, rating, or hotel-class filters if needed.
6. Keep `maxItems` small for the first run.
7. Click **Start**.
8. Open the dataset and export JSON, CSV, Excel, or another format.

A minimal input is:

```json
{
  "queries": ["London"],
  "maxItems": 10
}
````

A filtered destination search is:

```json
{
  "queries": ["Miami Beach"],
  "minRating": 4,
  "hotelClasses": ["4", "5"],
  "maxPrice": 350,
  "maxItems": 30,
  "currency": "USD",
  "country": "US"
}
```

### Input parameters

| Parameter | Type | Default | Description |
|---|---|---:|---|
| `queries` | string\[] | `["London"]` | Destinations or hotel search phrases |
| `startUrls` | RequestListSource\[] | empty | Public Google Hotels search URLs |
| `checkInDate` | string | empty | Future date in YYYY-MM-DD |
| `checkOutDate` | string | empty | Date after check-in |
| `adults` | integer | 2 | Adult travelers, 1-20 |
| `children` | integer | 0 | Child travelers, 0-10 |
| `minPrice` | number | empty | Minimum displayed nightly price |
| `maxPrice` | number | empty | Maximum displayed nightly price |
| `minRating` | number | empty | Minimum Google rating |
| `hotelClasses` | string\[] | empty | One or more classes, `"1"` through `"5"` |
| `includeSponsored` | boolean | true | Include and label sponsored cards |
| `maxItems` | integer | 10 | Maximum accepted hotels, 1-500 |
| `currency` | string | `USD` | Requested ISO currency |
| `language` | string | `en` | Requested interface language |
| `country` | string | `US` | Requested two-letter country code |
| `proxyConfiguration` | object | direct | Optional Apify Proxy settings |

Provide both stay dates or neither.

Explicit URLs must belong to a Google Hotels search surface. Unrelated Google pages and third-party URLs fail before navigation.

### Output example

```json
{
  "destination": "London",
  "query": "London",
  "checkInDate": null,
  "checkOutDate": null,
  "adults": 2,
  "children": 0,
  "position": 1,
  "name": "The Tower Hotel, by Thistle",
  "propertyId": "ChYIrIK1s_Hf-arLARoJL20vMDkxZGNfEAE",
  "propertyUrl": "https://www.google.com/travel/hotels/entity/ChYIrIK1s_Hf-arLARoJL20vMDkxZGNfEAE",
  "nightlyPrice": 123,
  "priceText": "€123",
  "currency": "EUR",
  "rating": 4.1,
  "reviewCount": 12224,
  "hotelClass": 4,
  "amenities": ["Breakfast ($)", "Free Wi-Fi", "Parking ($)"],
  "badges": ["Excellent location", "Eco-certified"],
  "bookingProviders": [],
  "isSponsored": false,
  "displayedDates": "Aug 2 – 3",
  "sourceUrl": "https://www.google.com/travel/search?...",
  "scrapedAt": "2026-07-19T05:17:20.025Z"
}
```

Numbers are emitted as numbers.

Arrays remain flat for straightforward CSV and spreadsheet use.

### Tips for reliable hotel rate monitoring

- 🧪 Start with 5-10 hotels to validate your query.
- 📅 Always pair check-in and check-out dates.
- 🌍 Treat `currency` as a request; verify the returned `currency` field.
- 🧭 Use a country-specific proxy when geographic presentation matters.
- 🧹 Use filters to reduce the final dataset, not to reinterpret missing source values.
- ⏱️ Schedule snapshots at a consistent local time for cleaner comparisons.
- 🔑 Deduplicate longitudinal records with `propertyId` when available.
- 📣 Keep `isSponsored` in ranking analyses.
- 📉 Compare like-for-like stay dates and traveler counts.
- 🚦 Use conservative concurrency; Google Hotels is browser-rendered.

### Google Hotels scraper integrations

**Google Hotels → Google Sheets**

Schedule a destination search each morning and append rate snapshots to a sheet for a revenue-management dashboard.

**Google Hotels → Slack or Discord**

Send a webhook when a four-star property drops below a chosen nightly price.

**Google Hotels → Make or Zapier**

Trigger the Actor from a destination list, transform the dataset, and update CRM or campaign records.

**Google Hotels → data warehouse**

Use a dataset webhook to load hotel rates, placements, and review counts into BigQuery, Snowflake, or PostgreSQL.

**Google Hotels → AI analysis**

Expose the Actor through Apify MCP and ask an AI agent to summarize price bands or identify unusually strong review-to-price combinations.

### Use Google Hotels Search Scraper with the Apify API

**Node.js**

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/google-hotels-search-scraper').call({
    queries: ['London'],
    maxItems: 10,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

**Python**

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/google-hotels-search-scraper').call(
    run_input={'queries': ['London'], 'maxItems': 10}
)
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

**cURL**

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~google-hotels-search-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"queries":["London"],"maxItems":10}'
```

### Use Google Hotels data with AI agents via MCP

Connect Claude Code:

```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=automation-lab/google-hotels-search-scraper"
```

For Claude Desktop, Cursor, or VS Code, add:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/google-hotels-search-scraper"
    }
  }
}
```

Authenticate with Apify when your client opens the OAuth flow.

Example prompts to try:

- “Use `automation-lab/google-hotels-search-scraper` to find ten highly rated hotels in London and summarize their nightly prices.”
- “Compare four-star Google Hotels rates in Miami Beach and Los Angeles.”
- “Build a weekly monitoring input for sponsored hotel placements in New York.”

### Scheduling Google hotel price checks

1. Save a working Actor input.
2. Open **Schedules** in Apify Console.
3. Choose the desired daily or weekly cadence.
4. Use the same stay-date logic for comparable snapshots.
5. Attach a webhook or integration to process the finished dataset.

For rolling stay windows, generate future dates in an external workflow before calling the Actor.

Do not leave fixed dates in a permanent schedule after they pass.

### Handling locales and currencies

Google may use serving geography, consent state, or other public presentation rules when choosing a displayed currency.

This Actor therefore:

- sends the requested `currency`, `language`, and `country`
- reads the symbol shown on every card
- emits the inferred displayed ISO currency
- logs a warning when requested and displayed currencies differ
- never changes a numeric amount merely to match the requested code

If exact geography matters, enable Apify Proxy with an appropriate country.

### Error handling and empty results

The Actor fails with a non-zero run when:

- no query or URL is provided
- a URL is outside the Google Hotels scope
- only one stay date is provided
- check-out is not after check-in
- locale or limits are invalid
- Google Hotels loads but no hotel passes the requested filters

A zero-item successful run is not used to hide extraction failure.

If results are unexpectedly empty, remove filters and retry one small destination first.

### Is it legal to scrape Google Hotels?

Google Hotels Search Scraper extracts publicly available result-card data.

Scraping public data is generally lawful in many jurisdictions, but laws, contracts, and acceptable-use rules vary.

You are responsible for:

- using the data for a legitimate purpose
- following applicable laws and Google’s terms
- avoiding excessive request volume
- respecting personal-data and database rights
- applying an appropriate retention policy

This Actor does not bypass login controls or collect private account data.

### FAQ

**How fast is the Google Hotels scraper?**

A small destination search normally completes in under two minutes. Browser rendering, consent, dates, geography, and source throttling affect duration.

**Do I need a Google API key?**

No. The Actor uses the public anonymous Google Hotels interface.

**Why does the returned currency differ from my input?**

Google can override locale hints based on its serving region. The Actor reports the currency actually displayed instead of silently relabeling the price.

**Why is `bookingProviders` empty?**

Google often hides provider names behind a separate price panel. The Actor returns providers only when external offer links are exposed on the result card.

**Why did my filtered run fail with no records?**

Price, rating, and class filters fail closed. Remove filters to inspect source coverage, then add thresholds one at a time.

**Does it include sponsored hotels?**

Yes by default. Sponsored cards have `isSponsored: true`. Set `includeSponsored` to `false` to exclude them.

**Can I scrape multiple destinations?**

Yes. Add up to 20 queries or URLs. The browser session is reused and `maxItems` applies across the run.

**Can I export to CSV or Excel?**

Yes. Every Apify dataset supports JSON, CSV, Excel, XML, and other export formats.

### Other travel and hotel scrapers

- [Google Flights Scraper](https://apify.com/automation-lab/google-flights-scraper) for flight fares and itineraries
- [Booking Scraper](https://apify.com/automation-lab/booking-scraper) for Booking.com property listings
- [Trip.com Hotels Scraper](https://apify.com/automation-lab/trip-com-hotels-scraper) for Trip.com hotel inventory
- [Airbnb Listing Scraper](https://apify.com/automation-lab/airbnb-listing) for short-term rental listings
- [Hotels.com Reviews Scraper](https://apify.com/automation-lab/hotels-com-reviews-scraper) for guest review research
- [Booking Hotel Photos Scraper](https://apify.com/automation-lab/booking-hotel-photos-scraper) for property image datasets
- [Trip.com Hotel Reviews Scraper](https://apify.com/automation-lab/trip-com-hotel-reviews-scraper) for Trip.com reputation analysis

Combine them to compare Google’s visible hotel market with booking platforms, vacation rentals, reviews, flights, and property media.

# Actor input Schema

## `queries` (type: `array`):

Enter destinations such as `London` or specific Google Hotels searches such as `pet-friendly hotels near JFK`.

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

Add public `google.com/travel/search` or `google.com/travel/hotels` URLs. Other Google products and external sites are rejected.

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

Choose a future check-in date in YYYY-MM-DD format. Provide both stay dates or leave both empty to use Google's displayed dates.

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

Choose a check-out date after check-in in YYYY-MM-DD format.

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

Set the number of adult travelers used by Google Hotels.

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

Set the number of child travelers used by Google Hotels.

## `minPrice` (type: `number`):

Keep hotels at or above this displayed nightly price. Cards without a parseable price are excluded when this filter is set.

## `maxPrice` (type: `number`):

Keep hotels at or below this displayed nightly price. The amount uses each card's displayed currency.

## `minRating` (type: `number`):

Keep hotels whose Google rating meets this threshold. Unparseable ratings fail closed.

## `hotelClasses` (type: `array`):

Keep only selected Google hotel classes. Unparseable classes fail closed.

## `includeSponsored` (type: `boolean`):

Preserve sponsored Google Hotels cards and mark them with `isSponsored: true`.

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

Stop after this many accepted hotel records across all searches. Keep the first run small.

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

Request a three-letter ISO currency from Google, such as USD, EUR, or GBP. Output always reports the currency actually displayed.

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

Request a Google interface language code, such as en, de, or fr.

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

Request a two-letter country code, such as US, GB, or DE.

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

Use Apify Proxy for geography control or recovery when direct Google access is throttled. Start without a proxy unless your workflow needs one.

## Actor input object example

```json
{
  "queries": [
    "London"
  ],
  "adults": 2,
  "children": 0,
  "includeSponsored": true,
  "maxItems": 10,
  "currency": "USD",
  "language": "en",
  "country": "US",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

No description

# 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 = {
    "queries": [
        "London"
    ],
    "adults": 2,
    "children": 0,
    "includeSponsored": true,
    "maxItems": 10,
    "currency": "USD",
    "language": "en",
    "country": "US",
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/google-hotels-search-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 = {
    "queries": ["London"],
    "adults": 2,
    "children": 0,
    "includeSponsored": True,
    "maxItems": 10,
    "currency": "USD",
    "language": "en",
    "country": "US",
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/google-hotels-search-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 '{
  "queries": [
    "London"
  ],
  "adults": 2,
  "children": 0,
  "includeSponsored": true,
  "maxItems": 10,
  "currency": "USD",
  "language": "en",
  "country": "US",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call automation-lab/google-hotels-search-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Google Hotels Search Scraper",
        "description": "Extract Google Hotels listings by destination and stay dates: nightly prices, displayed currency, ratings, review counts, class, amenities, badges, sponsorship, and property IDs. Export JSON, CSV, or Excel; schedule recurring hotel rate monitoring.",
        "version": "0.1",
        "x-build-id": "42CB00ovC41NUiY0R"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~google-hotels-search-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-google-hotels-search-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/automation-lab~google-hotels-search-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-google-hotels-search-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/automation-lab~google-hotels-search-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-google-hotels-search-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": {
                    "queries": {
                        "title": "🔎 Destinations or hotel queries",
                        "maxItems": 20,
                        "type": "array",
                        "description": "Enter destinations such as `London` or specific Google Hotels searches such as `pet-friendly hotels near JFK`.",
                        "default": [
                            "London"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "startUrls": {
                        "title": "Google Hotels search URLs",
                        "maxItems": 20,
                        "type": "array",
                        "description": "Add public `google.com/travel/search` or `google.com/travel/hotels` URLs. Other Google products and external sites are rejected.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "checkInDate": {
                        "title": "📅 Check-in date",
                        "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
                        "type": "string",
                        "description": "Choose a future check-in date in YYYY-MM-DD format. Provide both stay dates or leave both empty to use Google's displayed dates."
                    },
                    "checkOutDate": {
                        "title": "Check-out date",
                        "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
                        "type": "string",
                        "description": "Choose a check-out date after check-in in YYYY-MM-DD format."
                    },
                    "adults": {
                        "title": "Adults",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "Set the number of adult travelers used by Google Hotels.",
                        "default": 2
                    },
                    "children": {
                        "title": "Children",
                        "minimum": 0,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Set the number of child travelers used by Google Hotels.",
                        "default": 0
                    },
                    "minPrice": {
                        "title": "💰 Minimum nightly price",
                        "minimum": 0,
                        "type": "number",
                        "description": "Keep hotels at or above this displayed nightly price. Cards without a parseable price are excluded when this filter is set."
                    },
                    "maxPrice": {
                        "title": "Maximum nightly price",
                        "minimum": 0,
                        "type": "number",
                        "description": "Keep hotels at or below this displayed nightly price. The amount uses each card's displayed currency."
                    },
                    "minRating": {
                        "title": "Minimum guest rating",
                        "minimum": 0,
                        "maximum": 5,
                        "type": "number",
                        "description": "Keep hotels whose Google rating meets this threshold. Unparseable ratings fail closed."
                    },
                    "hotelClasses": {
                        "title": "Hotel classes",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Keep only selected Google hotel classes. Unparseable classes fail closed.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "1",
                                "2",
                                "3",
                                "4",
                                "5"
                            ],
                            "enumTitles": [
                                "1-star",
                                "2-star",
                                "3-star",
                                "4-star",
                                "5-star"
                            ]
                        }
                    },
                    "includeSponsored": {
                        "title": "Include sponsored hotels",
                        "type": "boolean",
                        "description": "Preserve sponsored Google Hotels cards and mark them with `isSponsored: true`.",
                        "default": true
                    },
                    "maxItems": {
                        "title": "📊 Maximum hotels",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Stop after this many accepted hotel records across all searches. Keep the first run small.",
                        "default": 10
                    },
                    "currency": {
                        "title": "🌍 Requested currency",
                        "pattern": "^[A-Za-z]{3}$",
                        "type": "string",
                        "description": "Request a three-letter ISO currency from Google, such as USD, EUR, or GBP. Output always reports the currency actually displayed.",
                        "default": "USD"
                    },
                    "language": {
                        "title": "Language",
                        "pattern": "^[A-Za-z]{2,5}$",
                        "type": "string",
                        "description": "Request a Google interface language code, such as en, de, or fr.",
                        "default": "en"
                    },
                    "country": {
                        "title": "Country",
                        "pattern": "^[A-Za-z]{2}$",
                        "type": "string",
                        "description": "Request a two-letter country code, such as US, GB, or DE.",
                        "default": "US"
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Use Apify Proxy for geography control or recovery when direct Google access is throttled. Start without a proxy unless your workflow needs one.",
                        "default": {
                            "useApifyProxy": false
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```