# Google Hotels Scraper - Prices, Booking Sites & Ratings (`topapi/google-hotels-scraper`) Actor

Scrape Google Hotels for any city and dates at $0.095 per 1,000 hotels: nightly and total price, star class, rating histogram, amenities, coordinates, check-in times and nearby transit. Optional booking-site prices with deep links, a 60-date price grid and monitor mode. No login.

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

## Pricing

from $0.10 / 1,000 hotels

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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

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

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

### What does Google Hotels Scraper do?

**Google Hotels Scraper** extracts Google Hotels results from [google.com/travel/hotels](https://www.google.com/travel/hotels) for any destination and stay. You type a city, area or landmark, set the dates, guests and currency, and every hotel or vacation rental comes back as one row: the price for your stay, star class, Google rating, amenities, coordinates and location scores. Built for revenue managers, travel startups and analysts who track hotel prices without copying them by hand.

Also known as: Google Hotels API · Google Travel hotels scraper · Google hotel prices scraper · hotel rate shopping tool.

<a href="https://console.apify.com/actors/0iuheQ0p3B2QcYGNi"><img src="https://api.apify.com/v2/key-value-stores/qNQ9zP0xaj2yxGeMY/records/google-hotels-scraper-source.png" alt="Google Hotels search results page that Google Hotels Scraper turns into rows" style="width:70%"></a>

- **Priced for your stay:** nightly price before and after taxes, the stay total, taxes and fees, and Google's price note ("21% less than usual") for the dates, guests and currency you set
- **Whole result lists:** a city search pages through everything Google lists (574 hotels for "hotels in Paris" in one run)
- **Every booking site per hotel:** turn on booking-site prices to add each site's nightly and total price with its own deep link, the official-site flag and free cancellation
- **Price offers mode:** one hotel across up to 60 check-in dates, one row per booking site and date
- **All of Google's filters:** price range, star class, guest rating, 19 amenities, property type, free cancellation, special offers, eco-certified, sort order, vacation rentals
- **No login, cookies or Google API key:** you pass destinations or hotel URLs and nothing else
- **Monitor mode:** on a schedule, get only new hotels and price drops since the last run
- **Export anywhere:** JSON, CSV, Excel, XML; schedules, webhooks, Make, Zapier, n8n, Google Sheets, Slack, the Apify API and MCP

### What data can you get from Google Hotels?

<table>
<tr>
<td>🏨 Hotel name and type (`type`)</td>
<td>⭐ Star class (`hotelClass`)</td>
<td>👍 Google rating and review count</td>
</tr>
<tr>
<td>📊 Rating histogram 5 to 1 stars</td>
<td>🗣️ What guests mention (`reviewAspects`)</td>
<td>📍 Latitude and longitude</td>
</tr>
<tr>
<td>🗺️ Location scores (`locationScores`)</td>
<td>🚇 Nearby transit, sights and airport minutes</td>
<td>🛎️ Amenities</td>
</tr>
<tr>
<td>💲 Nightly price, with and without taxes</td>
<td>🧾 Stay total, taxes and fees</td>
<td>🏷️ Price note (`priceInsight`)</td>
</tr>
<tr>
<td>🕒 Check-in and check-out times</td>
<td>🖼️ Photos and thumbnail</td>
<td>🌐 Website (only with booking-site prices)</td>
</tr>
<tr>
<td>🔗 Booking sites with deep links (`offers`)</td>
<td>📍 Address and phone (only with booking-site prices)</td>
<td>🧭 Google Maps ids: `cid`, `fid` (`placeId` with booking-site prices)</td>
</tr>
<tr>
<td>🛏️ Rentals: sleeps, bedrooms, bathrooms, beds</td>
<td>📅 Check-in, check-out, nights, guests</td>
<td>💱 Currency of every price</td>
</tr>
</table>

On a 100-hotel run for "hotels in Lisbon" every row had a name, coordinates, a nightly price and a Google Hotels link; 99% had a rating and amenities, 98% location scores and 77% a star class (Google mixes vacation rentals into city searches; those rows carry sleeps, bedrooms and bathrooms instead).

### How to scrape Google Hotels with Google Hotels Scraper

1. [Create a free Apify account](https://console.apify.com/sign-up): $5 of monthly credit, no card needed.
2. Open [Google Hotels Scraper](https://apify.com/topapi/google-hotels-scraper) and click **Try for free**.
3. Type a destination into **Destinations / searches**, e.g. `hotels in Lisbon`, and set the **Check-in date** and **Nights**.
4. Add filters if you need them, and set **Max hotels per search**.
5. Click **Start**. Rows appear in the dataset as Google answers.
6. Open the **Storage** tab and **Export** as JSON, CSV or Excel, or let a schedule run it for you.

### ⬇️ Input

| Parameter | Type | Description |
|---|---|---|
| **🔍 What to scrape** | | |
| `queries` | List | Destinations as you would type them into Google Hotels: `hotels in Lisbon`, `Paris`, `hotels near Times Square`. Prefilled with `hotels in Lisbon`. |
| `hotelUrls` | List | Specific hotels: a Google Hotels URL, the bare entity token (`ChgI…`), or the hotel name with its city. |
| `mode` | Select | `search` (one row per hotel, default) or `offers` (one row per booking site x check-in date). |
| `propertyKind` | Select | `hotels` (default) or `vacation_rentals`. |
| **🗓️ Stay** | | |
| `checkIn` | Date | `2026-11-12` or days from today (`30 days`). Default: 30 days from today. |
| `checkOut` / `nights` | Date / Integer | A check-out date, or the number of nights (1-30, default 1). |
| `adults`, `childrenAges` | Integer / List | Guests: adults 1-12 (default 2), one age per child (0-17). |
| `currency`, `language`, `country` | Select / Text | Price currency (56 to choose from, default USD), Google language `hl` (default `en`: names, descriptions and class labels follow it; `amenities` on hotel rows stay in English) and market `gl` (default `us`). |
| `device` | Select | `desktop` (default) or `mobile`, which adds booking sites' mobile-only rates to booking-site prices and price offers. |
| **🎯 Filters** (applied by Google Hotels) | | |
| `sortBy` | Select | Relevance (default), lowest price, highest rating, most reviewed. |
| `minPrice`, `maxPrice` | Integer | Nightly price range in your currency. |
| `hotelClass`, `minRating` | Multi-select / Select | Star classes 2-5; guest rating 3.5+, 4.0+, 4.5+. |
| `amenities`, `propertyTypes` | Multi-select | 19 amenities (pool, free breakfast, pet-friendly, EV charger…) and 9 property types (hostels, boutique hotels, apartment hotels…). |
| `freeCancellation`, `specialOffers`, `ecoCertified` | Boolean | Google's toggles of the same names. Default: off. |
| **✂️ Refine results** | | |
| `withPriceOnly`, `minReviews`, `excludeKeywords` | Boolean / Integer / Text | Skip hotels without a price for your dates, with too few reviews, or whose name contains a word. |
| `minBedrooms`, `minBathrooms` | Integer | Vacation rentals only: keep rentals with at least this many bedrooms / bathrooms (rentals that list no count are skipped when set). Hotel rows are not affected. |
| **➕ Extra data** | | |
| `includeDetails` | Boolean | Each hotel's booking-site prices and details, charged as **hotel-details** at $0.001 per hotel that gets them. Default: off. |
| `maxOffersPerHotel` | Integer | Keep the first N booking sites per hotel. `0` = all. |
| `sweepDays` | Integer | Offers mode: price the stay for this many consecutive check-in dates (1-60). |
| **🔁 Monitoring** | | |
| `monitorMode`, `monitorStoreName`, `priceDropPercent` | Boolean / Text / Integer | Return only hotels not delivered before, plus hotels whose nightly price fell by at least `priceDropPercent` (default 5). |
| **📦 Output** | | |
| `maxResults` | Integer | Hotels per search. Default `100` (prefill 20); `0` = everything Google lists (its list for a big city ends after about 550-650 hotels). In price offers mode: hotels taken per destination (`0` = the first 20). |
| `maxItems`, `maxPhotosPerHotel`, `compact` | Integer / Boolean | Total row cap; photos per hotel (default 10); core fields only for AI agents and MCP (price offers rows keep the booking site, its prices and link). |
| **⚙️ Advanced** | | |
| `proxyConfiguration`, `maxConcurrency` | Proxy / Integer | Defaults work for most runs: a direct connection first, the Apify proxy if Google blocks it. Pick RESIDENTIAL with a country to see that country's point of sale. |

<a href="https://console.apify.com/actors/0iuheQ0p3B2QcYGNi"><img src="https://api.apify.com/v2/key-value-stores/qNQ9zP0xaj2yxGeMY/records/google-hotels-scraper-output.png" alt="Google Hotels Scraper output table with prices and booking sites" style="width:70%"></a>

#### Input JSON

```json
{
  "queries": ["hotels in Rome"],
  "checkIn": "45 days",
  "nights": 3,
  "adults": 2,
  "currency": "EUR",
  "hotelClass": ["4", "5"],
  "maxResults": 50,
  "includeDetails": true
}
```

#### Type the destination the way you would on Google Hotels

`queries` is Google's own search box. `hotels in Lisbon`, `Lisbon`, `boutique hotels in Alfama` and `hotels near Times Square` all work. Google always answers with hotels: a misspelt or unknown place is matched to the nearest thing it recognises, so check the first rows of a new search.

#### Use relative dates for scheduled runs

`"checkIn": "30 days"` with `"nights": 2` always prices a stay 30 days ahead, so a daily schedule builds a price history for the same lead time. Absolute dates (`2026-11-12`) price one fixed stay.

#### Look up hotels by URL or token, not by Maps place id

`hotelUrls` takes a Google Hotels URL (`https://www.google.com/travel/hotels/entity/ChgI…`), the token alone, or a hotel name with its city. A hotel name resolves to Google's first match for it. A Google Maps place id (`ChIJ…`) cannot be opened on Google Hotels.

### ⬆️ Output

Every hotel becomes one dataset item. A hotel row from a run for "hotels in Rome" with booking-site prices on (shortened):

```json
{
  "type": "hotel",
  "name": "Stendhal Luxury Suites",
  "entityToken": "ChkI7PTB7839_oJ_Gg0vZy8xMXJuY3d3bDY3EAE",
  "hotelClass": 4,
  "rating": 4.6,
  "reviewCount": 119,
  "locationScores": { "overall": 4.5, "thingsToDo": 4.9, "restaurants": 4.7, "airportAccess": 3.3 },
  "latitude": 41.9036189,
  "longitude": 12.4876103,
  "address": "Via Sistina, 4, 00187 Roma RM, Italy",
  "amenities": ["Free breakfast", "Free Wi-Fi", "Parking", "Air conditioning"],
  "pricePerNight": 185.46,
  "pricePerNightWithTaxes": 220.8,
  "totalPriceWithTaxes": 662.41,
  "currency": "USD",
  "priceInsight": "21% less than usual",
  "checkIn": "2026-11-22",
  "checkOut": "2026-11-25",
  "cid": "9596812607083390924",
  "vendorCount": 15,
  "cheapestSource": "Hotels.com",
  "officialSitePrice": 205.78,
  "offers": [{ "source": "Stendhal Luxury Suites", "official": true, "nightly": 205.78, "nightlyWithTaxes": 224.69, "partnerUrl": "https://www.reserve-online.net/?property=STENDSUI&checkin=2026-11-22…" }]
}
```

And one row of price offers mode (one booking site, one check-in date):

```json
{
  "name": "Altis Grand Hotel",
  "source": "Booking.com",
  "official": false,
  "rank": 9,
  "checkIn": "2026-11-08",
  "checkOut": "2026-11-10",
  "currency": "USD",
  "price": 280.98,
  "priceWithTaxes": 306.8,
  "totalWithTaxes": 613.61,
  "freeCancellation": false,
  "partnerUrl": "https://www.booking.com/searchresults.en.html?dest_id=38507&highlighted_hotels=38507…",
  "device": "desktop"
}
```

#### Google Hotels fields

Fill is measured on Apify runs: hotel fields on 100 hotels in Lisbon (run KPeZSQPPPbJYoWXZA), booking-site fields on 20 hotels in Rome (Q4A0z5CTzhw3Zu3j0), offer fields on 678 offers (Lv0LXyJGweVKpwBMw).

| Field | Type | What it is | Fill |
|---|---|---|---|
| `name`, `entityToken`, `url` | string | Property name, Google Hotels id and page | 100% |
| `type`, `propertyType` | string | hotel or vacation_rental; Google's category or the rental type | 100% / 99% |
| `hotelClass`, `classLabel` | number, string | Star class 1-5 (hotels) | 77% |
| `rating`, `reviewCount` | number | Google rating and number of Google reviews | 99% |
| `ratingHistogram`, `reviewAspects` | object, array | Reviews per star; what reviews mention (aspect, mentions, positive, negative) | 85% / 84% |
| `locationScores` | object | Google's location score: overall, things to do, restaurants, transit, airport access | 98% |
| `latitude`, `longitude`, `countryCode` | number, string | Position | 100% |
| `nearby` | array | Nearby sights, transit stops and airports with walking, transit or driving minutes | 98% |
| `amenities`, `amenityCodes` | array | Amenities on the hotel card | 99% |
| `pricePerNight`, `pricePerNightWithTaxes` | number | Lead nightly price before / after taxes and fees | 100% |
| `totalPrice`, `totalPriceWithTaxes`, `taxesAndFees` | number | Stay totals | 100% |
| `priceInsight` | string | Google's price note, when Google shows one | 15% |
| `checkInTime`, `checkOutTime`, `description` | string | Hotel facts Google lists | 70% / 66% |
| `cid`, `fid`, `mapsUrl` | string | Google Maps ids and link | 100% / 85% / 100% |
| `sleeps`, `bedrooms`, `bathrooms`, `beds`, `listingSource` | number, string | Vacation rentals (15% of rows in that city search) | 15% |
| `offers`, `vendorCount`, `cheapestSource`, `cheapestNightly` | array, number, string | Booking-site prices (`includeDetails`) | 100% |
| `address`, `phone`, `placeId`, `website` | string | Street address, phone, Google place id and the hotel's own website; only on rows with booking-site prices (`includeDetails`), empty on plain hotel rows | 75% / 70% / 75% / 90% |
| `officialSitePrice`, `priceBreakdown`, `externalRatings` | number, object, array | Hotel's own site, stay base/taxes/fees, other sites' ratings | 55% / 100% / 100% |
| `price`, `priceWithTaxes`, `total`, `totalWithTaxes` | number | Offers mode: one booking site's price | 100% / 95% |
| `freeCancellation`, `deal`, `originalNightly` | boolean, string, number | Offers mode: cancellation flag and discounted rates | 23% / 4% |

### How can I use Google Hotels data?

- 🏨 **Hotel revenue managers:** rate shopping and rate parity, comparing your official-site price with every booking site for the same dates
- 📈 **Travel analysts:** price curves by city, star class and lead time, built from a daily schedule with relative dates
- 🧳 **Travel startups and agencies:** a hotel inventory for a destination with coordinates, ratings, amenities and live prices
- 🗺️ **Real-estate and tourism researchers:** where hotels and vacation rentals sit, what they charge and how Google scores their location
- 🔔 **Deal hunters:** monitor mode returns only new hotels and price drops for a watch list
- 🤖 **AI and data teams:** compact rows for LLM agents through the Apify API or MCP

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

Google Hotels Scraper is pay-per-event, with no start fee:

| Event | Price |
|---|---|
| **hotel**: one hotel or rental row | $0.000095 ($0.095 per 1,000 hotels) |
| **hotel-details**: booking-site prices and details for one hotel (only when `includeDetails` is on) | $0.001 |
| **offer**: one booking-site row in price offers mode | $0.0008 ($0.80 per 1,000 offers) |

| Run | Rows | Cost |
|---|---:|---:|
| 20 hotels (one results page) | 20 | $0.0019 |
| 100 hotels | 100 | $0.0095 |
| 1,000 hotels | 1,000 | $0.095 |
| 100 hotels with booking-site prices | 100 | $0.1095 |
| 1 hotel x 30 check-in dates, offers mode (678 offers measured) | 678 | $0.54 |

There is nothing else to pay: Apify platform usage is included in these prices.

### Integrations, API, scheduling & MCP

- **Schedules:** run Google Hotels Scraper daily from the **Schedules** tab; with a relative check-in date and monitor mode each run returns only new hotels and price drops.
- **Webhooks:** fire a URL when a run finishes and push rows to a sheet, a database or Slack.
- **No-code:** Make, Zapier, n8n, Google Sheets, Airtable and Slack through [Apify integrations](https://docs.apify.com/integrations).
- **API:** call it from Node.js or Python with `apify-client`: code on the [API tab](https://apify.com/topapi/google-hotels-scraper/api/python) and in the [Apify API reference](https://docs.apify.com/api/v2).
- **MCP / AI agents:** connect Claude, Cursor or any MCP client through the [MCP tab](https://apify.com/topapi/google-hotels-scraper/api/mcp) and ask for hotel prices in plain language; turn on `compact` for shorter rows.

### More travel and maps scrapers by TopApi

<table>
<tr>
<td>🛏️ <a href="https://apify.com/topapi/booking-hotels-scraper">Booking.com Hotels Scraper</a>: Booking.com prices, rooms and availability</td>
<td>💬 <a href="https://apify.com/topapi/google-maps-reviews-scraper">Google Maps Reviews Scraper</a>: the review text behind each hotel's rating (pass its `cid` or `placeId`)</td>
<td>📍 <a href="https://apify.com/topapi/google-geocoding-scraper">Google Geocoding Scraper</a>: addresses to coordinates and back</td>
</tr>
<tr>
<td>🍎 <a href="https://apify.com/topapi/apple-maps-scraper">Apple Maps Scraper</a>: places, ratings and coordinates</td>
<td>⭐ <a href="https://apify.com/topapi/yelp-reviews-scraper">Yelp Reviews Scraper</a>: Yelp ratings and reviews of restaurants and venues</td>
<td>🌐 <a href="https://apify.com/topapi/website-content-crawler">Website Content Crawler</a>: the text of hotel websites as Markdown</td>
</tr>
<tr>
<td>📊 <a href="https://apify.com/topapi/similarweb-scraper">SimilarWeb Scraper</a>: traffic and rank of booking sites and hotel websites</td>
<td>🏠 <a href="https://apify.com/topapi/zillow-scraper">Zillow Scraper</a>: property listings and price history</td>
<td>🧭 <a href="https://apify.com/topapi">All TopApi actors</a></td>
</tr>
</table>

### Limits & empty runs

- **How deep a search goes:** Google lists 18-20 hotels per page and stops when its list ends: 574 to 624 hotels for "hotels in Paris" in two runs on the same day. Split a city into neighbourhoods or filters to go further.
- **Prices are Google's answer for your market:** currency, dates, guests and `country` change the prices; the number of booking sites differs by hotel and by check-in date (0 to 32 across the first 20 hotels of "hotels in Rome" over 2 runs; 20 to 28 for one Lisbon hotel over 3 check-in dates). With the default connection prices are those Google shows to a US visitor in your currency; choose RESIDENTIAL with a country for a local point of sale.
- **Hotels without a price** for your dates come back with `priceStatus: "no_price"` (8% of rows in the 574-hotel Paris run); turn on `withPriceOnly` to skip them.
- **Empty dataset:** Google listed nothing for the destination with your filters, every hotel was removed by your Refine filters, or monitor mode found nothing new. The run's status message says which.
- **Not available:** room types for every booking site (Google shows rooms only for a few featured offers; they come in `rooms`), and review text (use Google Maps Reviews Scraper).

### FAQ

#### How many hotels can Google Hotels Scraper return from one search?

As many as Google lists for it: 574-624 for "hotels in Paris", about 20 per page. Set `maxResults` to `0` for everything, and add more searches (districts, star classes, price bands) for wider coverage.

#### Can Google Hotels Scraper get prices from every booking site?

Yes. Turn on `includeDetails` and each hotel gets an `offers` list: every booking site Google shows with its nightly and total price, taxes, free cancellation, the official-site flag and the booking site's own deep link.

#### Can I get Google Hotels prices for many dates in one run?

Yes. Set `mode` to `offers`, add the hotels and set `sweepDays` (up to 60). Each check-in date returns one row per booking site.

#### Can I run Google Hotels Scraper on a schedule to track price changes?

Yes. Save your input as a task, add a schedule and use a relative check-in date such as `30 days`. With `monitorMode` on, each run returns only hotels not delivered before and those whose price dropped by `priceDropPercent` or more.

#### Does Google Hotels Scraper cover vacation rentals?

Yes. Set `propertyKind` to `vacation_rentals`. Rental rows add `sleeps`, `bedrooms`, `bathrooms`, `beds`, floor area when listed, and the listing source.

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

Yes: Make, Zapier, n8n, Google Sheets, Slack and more via [Apify integrations](https://docs.apify.com/integrations), or [webhooks](https://docs.apify.com/integrations/webhooks) when a run finishes.

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

Yes. Start runs and read datasets with `apify-client` for [Node.js](https://apify.com/topapi/google-hotels-scraper/api/javascript) or [Python](https://apify.com/topapi/google-hotels-scraper/api/python); the API tab has ready-to-paste code.

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

Yes. Open the [MCP tab](https://apify.com/topapi/google-hotels-scraper/api/mcp), connect Claude Desktop, Cursor or another MCP client, and ask for hotels and prices in plain language. `compact` keeps the rows short.

#### Do I need a Google account, cookies or a Google Hotels API key?

No. There is no public Google Hotels API for reading prices; Google Hotels Scraper reads the public Google Hotels pages any visitor sees, with no login, cookies or API key.

#### Why did my Google Hotels Scraper run return no hotels?

Most often the filters left nothing (a price range below what the city charges, or several amenities at once), the dates were sold out with `withPriceOnly` on, or monitor mode found no new hotels and no price drops. The status message and the `RUN_SUMMARY` record give the counts.

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

Google Hotels Scraper reads publicly displayed hotel data and prices, the same figures any visitor sees without logging in, and the rows describe hotels and rates, not people. Terms of service and local law differ, so check that your use complies. See Apify's overview: [is web scraping legal?](https://blog.apify.com/is-web-scraping-legal/)

#### Your feedback

We keep improving Google Hotels Scraper. Found a bug or missing a field? Open an issue on the [Issues tab](https://apify.com/topapi/google-hotels-scraper/issues/open).

# Actor input Schema

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

What you would type into Google Hotels: a city, area, landmark or phrase, e.g. "hotels in Lisbon", "Paris", "hotels near Times Square". One search per line.

## `hotelUrls` (type: `array`):

Specific hotels: a Google Hotels URL (…/travel/hotels/entity/ChgI…), the bare entity token, or the hotel name with its city (e.g. "Altis Grand Hotel Lisbon").

## `mode` (type: `string`):

"Price offers" opens each hotel's own Google Hotels page and returns every booking site's price for each check-in date (set the number of dates under Extra data).

## `propertyKind` (type: `string`):

Google Hotels' two tabs. Vacation rentals add sleeps, bedrooms, bathrooms and beds to each row.

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

Absolute (2026-11-12) or days from today ("30 days"). Relative dates keep a scheduled run pointed at the same distance ahead. Default: 30 days from today.

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

Absolute (2026-11-14) or days from today. Leave empty to use 'Nights' instead.

## `nights` (type: `integer`):

Length of the stay when no check-out date is given, 1-30.

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

Number of adult guests, 1-12.

## `childrenAges` (type: `array`):

One age (0-17) per child, e.g. 7 and 10 for two children. Leave empty for no children.

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

Currency Google prices every hotel and offer in.

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

Google interface language (hl) for names, descriptions and class labels, e.g. en, de, fr, es, pt-PT. `amenities` on hotel rows always use English labels (Google sends them as codes); vacation-rental rows and `amenitiesFull` (booking-site prices) list amenities in this language.

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

Google market (gl), two letters, e.g. us, gb, de. Prices are what Google shows to that market from the connection's location (a US server by default).

## `device` (type: `string`):

Google shows some booking sites' mobile-only rates on phones; "Mobile" asks as a phone browser.

## `sortBy` (type: `string`):

The order Google Hotels lists results in.

## `minPrice` (type: `integer`):

Lowest nightly price, in the chosen currency. 0 or empty = no minimum.

## `maxPrice` (type: `integer`):

Highest nightly price, in the chosen currency, e.g. 150. 0 or empty = no maximum.

## `hotelClass` (type: `array`):

Keep only these star classes, e.g. 4 and 5. Empty = any class.

## `minRating` (type: `string`):

Minimum Google guest rating.

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

Keep only properties with all of these amenities, e.g. Pool and Free breakfast.

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

Hotels tab only: keep these property types, e.g. Boutique hotels or Hostels.

## `freeCancellation` (type: `boolean`):

Only properties with a free-cancellation rate for the stay.

## `specialOffers` (type: `boolean`):

Only properties Google marks with a deal or special offer.

## `ecoCertified` (type: `boolean`):

Only properties with an eco certification Google recognises.

## `withPriceOnly` (type: `boolean`):

Skip properties that show no price for these dates (sold out or not bookable).

## `minReviews` (type: `integer`):

Skip properties with fewer Google reviews, e.g. 100. 0 or empty = no minimum.

## `minBedrooms` (type: `integer`):

Vacation rentals only: keep rentals with at least this many bedrooms. Rentals that do not list a count are skipped when set. Hotel rows are not affected.

## `minBathrooms` (type: `integer`):

Vacation rentals only: keep rentals with at least this many bathrooms. Rentals that do not list a count are skipped when set. Hotel rows are not affected.

## `excludeKeywords` (type: `string`):

Comma-separated words; a property whose name contains one is skipped, e.g. "hostel, apartment".

## `includeDetails` (type: `boolean`):

Adds every booking site's nightly and total price with its deep link, official-site flag, free cancellation, address, phone, website, all amenities and other sites' ratings. Charged per hotel (hotel-details).

## `maxOffersPerHotel` (type: `integer`):

Keep only the first N booking sites Google lists per hotel (and per date in Price offers mode). 0 or empty = all.

## `sweepDays` (type: `integer`):

Price offers mode: price the same stay for this many consecutive check-in dates, starting at the check-in date, e.g. 30 for a month of rates.

## `monitorMode` (type: `boolean`):

Return only hotels not delivered by a previous run, plus hotels whose nightly price fell by at least the drop below. Pairs with a daily schedule.

## `monitorStoreName` (type: `string`):

Named key-value store that remembers delivered hotels and prices between runs. Use a different name per watch list.

## `priceDropPercent` (type: `integer`):

Monitor mode: a known hotel is delivered again when its nightly price is at least this many percent below the price last delivered.

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

Hotels per destination. Google's list for a big city ends after about 550-650 hotels (about 20 per page). 0 = everything Google lists. In Price offers mode: hotels taken per destination (0 = the first 20).

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

Stop after this many rows across all searches. 0 or empty = no overall limit.

## `maxPhotosPerHotel` (type: `integer`):

Photo URLs kept per hotel, 0-50.

## `compact` (type: `boolean`):

Core fields only, sized for AI agents and MCP. Hotel rows: name, class, rating, coordinates, price, currency, dates, booking sites. Price offers rows: the hotel, booking site, its prices, free cancellation, dates and link.

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

Default: a direct connection first, switching to the Apify proxy if Google blocks it. Choose RESIDENTIAL with a country to see prices from that country's point of sale.

## `maxConcurrency` (type: `integer`):

Pages fetched at the same time, 1-8. Each page is ~3 MB; keep 4 at the default 256 MB memory.

## Actor input object example

```json
{
  "queries": [
    "hotels in Lisbon"
  ],
  "mode": "search",
  "propertyKind": "hotels",
  "checkIn": "30 days",
  "nights": 2,
  "adults": 2,
  "currency": "USD",
  "language": "en",
  "country": "us",
  "device": "desktop",
  "sortBy": "relevance",
  "minRating": "",
  "freeCancellation": false,
  "specialOffers": false,
  "ecoCertified": false,
  "withPriceOnly": false,
  "includeDetails": false,
  "sweepDays": 1,
  "monitorMode": false,
  "monitorStoreName": "google-hotels-monitor",
  "priceDropPercent": 5,
  "maxResults": 20,
  "maxPhotosPerHotel": 10,
  "compact": false,
  "proxyConfiguration": {
    "useApifyProxy": true
  },
  "maxConcurrency": 4
}
```

# Actor output Schema

## `hotels` (type: `string`):

The dataset: one item per hotel (hotel list) or per booking site and check-in date (price offers mode).

## `summary` (type: `string`):

Per-search counts (read, filtered, unchanged, delivered), Google's total per search, requests made, sessions used and bytes received.

# 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": [
        "hotels in Lisbon"
    ],
    "checkIn": "30 days",
    "nights": 2,
    "maxResults": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("topapi/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 = {
    "queries": ["hotels in Lisbon"],
    "checkIn": "30 days",
    "nights": 2,
    "maxResults": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("topapi/google-hotels-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).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": [
    "hotels in Lisbon"
  ],
  "checkIn": "30 days",
  "nights": 2,
  "maxResults": 20
}' |
apify call topapi/google-hotels-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,topapi/google-hotels-scraper"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/0iuheQ0p3B2QcYGNi/builds/VbQSjqejbPmN5NZHD/openapi.json
