# Google Hotels Scraper & Price Tracker (`myth84/google-hotels-scraper`) Actor

Google Hotels scraper and hotel price tracker: Google Hotels prices for any destination and dates — lowest price per night and for the stay with taxes, every booking site's rate with direct links (rate parity), class, rating, reviews, amenities, location. One flat row per hotel, no personal data.

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

## Pricing

from $1.69 / 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.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

### Google Hotels Scraper & Price Tracker – hotel prices by booking site, no personal data

Google Hotels scraper and hotel price tracker: get Google Hotels prices for any destination and dates — the lowest price per night and for the whole stay with taxes and fees, the hotel class, guest rating, reviews, amenities and location — and, on request, every booking site's rate with its direct link, for hotel price comparison and hotel rate parity checks, as a clean table or through an API. Schedule the same search to track prices and get the price drops since your previous run.

**No login, no cookies, no personal data:** nothing to sign in to, no cookies to paste, nothing about guests or reviewers in the output.

- **What you get:** one flat row per hotel of the Google Hotels results for your stay: lowest price per night (before and with taxes) and for the stay, taxes and fees, class, guest rating on 5 with its breakdown, review count, amenities, coordinates, photos, description, check-in times, website and Google ids; with `includeOffers`, the rate of each booking site (Booking.com, Expedia, Agoda, the hotel's own site…) with direct links, the cheapest site, the official site's price and the free-cancellation deadline. No personal data.
- **For whom:** hoteliers and revenue managers (rate shopping and rate parity), travel agencies and metasearch builders, travel data and BI teams, deal finders and price-alert tools, AI agents through MCP.
- **How much:** a fixed price per hotel saved and nothing else (compute and proxy traffic included, see the Pricing tab); every booking site's rate comes at no extra charge; `maxResults` caps every search.

**Sample output**: one real row from a Lisbon search with the booking-site rates, key columns only (the full row is under *Output example*):

```json
{
  "title": "Brown's | Avenue Hotel",
  "city": "Lisbon",
  "checkIn": "2026-11-20",
  "checkOut": "2026-11-23",
  "currency": "USD",
  "pricePerNight": 169.26,
  "priceTotal": 564.25,
  "priceTotalAllIn": 564.25,
  "rating": 4.6,
  "reviewCount": 283,
  "cheapestOfferSite": "Vio.com",
  "officialSitePriceTotal": 565.73
}
```

Search Google Hotels like a visitor — "hotels in Lisbon", "hotels near Times Square" — for any dates, travellers and currency, and get **one flat row per hotel**: the lowest price Google shows for the stay, per night and in total, with the taxes and fees, the class, the Google guest rating and its 5-to-1 breakdown, the number of reviews, the amenities, the coordinates, photos, the hotel's description, check-in and check-out times, website and its Google Maps and Place ids. Add `includeOffers` and each row lists **every booking site's rate for the stay** with a direct link to the site, sorted from the cheapest, plus the cheapest site and the price on the hotel's own website: the rate parity check of hoteliers, in one column. Give precise hotels in `hotelUrls` to follow their rates on every site. Run several searches at once, paste Google Hotels search URLs, choose among Google's currencies and languages, and schedule the run with price monitoring to get only the price changes.

**No personal data, by design.** Nothing about guests or reviewers is collected: no names, no review texts, no profile photos, no phone numbers. The output only contains hotel-level facts (business names), the average rating, the number of reviews and their distribution by stars. The dataset is safe to store, share and feed to AI agents.

### What can you do with Google Hotels data?

- **Compare hotel prices** for a destination and dates: the lowest price of each hotel with taxes and fees, per night and for the stay, in the currency you choose.
- **Check rate parity**: compare the hotel's own website with Booking.com, Expedia, Agoda and the other sites Google lists (`officialSitePriceTotal` against `cheapestOfferPriceTotal`), for your hotel or your competitors.
- **Track hotel prices over time**: schedule the same search with relative dates and price monitoring, and get the new hotels and price changes since the previous run.
- **Compare platforms**: the same stay on Google Hotels, Booking.com, Expedia, Agoda and Airbnb with the same first columns (this travel studio shares one output schema).
- **Feed AI agents, spreadsheets and BI tools** with a stable, documented schema: every row has every column, prices are numbers, links open the hotel with your dates.

### What data does Google Hotels Scraper extract?

Every row has every column: a value Google Hotels does not show is `null` (or `[]` for lists), so CSV and Excel exports keep the same columns from run to run.

| Group | Columns |
|---|---|
| Identity | `schemaVersion`, `platform`, `platformListingId`, `url`, `title`, `propertyType`, `roomType` |
| Location | `city`, `region`, `country`, `countryCode`, `latitude`, `longitude` |
| Stay | `checkIn`, `checkOut`, `nights`, `guests`, `isAvailable` |
| Prices | `currency`, `pricePerNight`, `pricePerNightWithTaxes`, `priceTotal`, `priceTotalBeforeTaxes`, `taxesAndFees`, `taxesIncluded`, `priceTotalAllIn`, `priceBeforeDiscount`, `cleaningFee`, `serviceFee` |
| Quality | `rating`, `ratingMax`, `reviewCount`, `ratingBreakdown`, `starRating`, `badges`, `isSuperhost`, `isNew`, `listedBy`, `cancellationPolicy`, `instantBook` |
| Hotel | `description`, `checkInTime`, `checkOutTime`, `website`, `amenities`, `bedrooms`, `beds`, `bathrooms`, `maxGuests` |
| Photos | `imageUrls`, `imageCount` |
| Google ids | `googleHotelId`, `googleMapsCid`, `googlePlaceId` |
| Booking sites (`includeOffers` or `hotelUrls`) | `offersIncluded`, `offers`, `offerCount`, `cheapestOfferSite`, `cheapestOfferPriceTotal`, `officialSitePriceTotal` |
| Search context | `searchLocation`, `searchRank`, `searchPage`, `viewCountryCode`, `scrapedAt` |
| Price monitoring (`monitorPrices` runs only, otherwise `null`) | `changeType`, `previousPrice`, `priceDelta`, `priceDeltaPercent` |

- **`priceTotal`** is the lowest price of the whole stay, **taxes and fees included** (the total of Google's base, taxes and fees), so `taxesIncluded` is `true` and `priceTotalAllIn` repeats it: `priceTotalAllIn` is the column to compare across hotels, dates and platforms, filled with the same rule by every travel scraper of the studio. `priceTotalBeforeTaxes` is the same stay before taxes and `taxesAndFees` the difference.
- **`pricePerNight`** is Google's nightly price **before taxes** (fees included), and `pricePerNightWithTaxes` the stay with taxes divided by the nights: $169.26 and $188.08 for the example below.
- **`rating`** is the Google guest rating on 5 (`ratingMax` is `5`) and `ratingBreakdown` the share and number of reviews for each number of stars. `starRating` is the official class (1 to 5).
- **`propertyType`** is the class label Google shows ("5-star hotel", "Hôtel 3 étoiles" in French), else the type (Hotel, Hostel, Guest house…); vacation rentals are "Vacation rental" with `roomType` `entire_place` and their capacity in `maxGuests`, `bedrooms` and `bathrooms`.
- **`amenities`** are English labels for hotels (Free Wi-Fi, Pool, Parking ($), Breakfast…) whatever the language, and the rental's own list for vacation rentals.
- **`cancellationPolicy`** says whether the hotel can be booked with free cancellation, read with the booking-site rates (`includeOffers`, `hotelUrls` or `freeCancellationOnly`): `free_cancellation_until:2026-11-17` when a booking site shown by Google sells a rate that can be cancelled for free, with the earliest deadline of those rates (every free-cancellation rate shown can be cancelled at least until that day); `free_cancellation` when Google gives no readable deadline (labels in a language other than English); `null` when no rate shown is free to cancel, or without the booking-site rates. The lowest price of the row is not necessarily a refundable rate.
- Columns that Google Hotels never shows stay empty for this Actor: `region`, `priceBeforeDiscount` (Google shows a deal note in `badges` instead, e.g. "20% less than usual"), `cleaningFee` and `serviceFee` (counted in `taxesAndFees`), `beds`, `instantBook`, `isNew`, `isSuperhost`, `listedBy`.

### How to scrape Google Hotels

1. **Type your searches** in `searchQueries`, as you would on Google Hotels: "hotels in Lisbon", "hotels in Paris 8th arrondissement", "hotels near Times Square". Each line is its own search. Or **paste Google Hotels search URLs** into `startUrls`, or **list precise hotels** in `hotelUrls` (see *Search from Google Hotels URLs*).
2. **Choose the stay**: fixed dates (`checkIn` / `checkOut`) for a precise quote, or relative dates (check-in in *N* days for *M* nights, the default) for schedules that never expire. Set the adults and the children's ages: prices depend on them.
3. **Pick the currency, language and market**, the maximum number of hotels per search, and tick `includeOffers` for every booking site's rate.
4. **Run** and open the **Output** tab: the *Overview*, *Prices*, *Booking sites*, *Location* and *Changes* views show the main columns; export everything as JSON, CSV, Excel or through the API. To track prices, tick `monitorPrices` and schedule the run (see *Price monitoring* below).

### Input

Field names and defaults are those of the input form. Give at least one search in `searchQueries`, one search URL in `startUrls` or one hotel in `hotelUrls`; `checkIn` and `checkOut` go together, otherwise `checkInDaysFromNow` and `nights` apply.

The input of our validation run: 60 hotels in Lisbon for a 3-night stay starting in 30 days, 2 adults, prices in USD, with every booking site's rate (every other field keeps its default):

```json
{
  "searchQueries": ["hotels in Lisbon"],
  "checkInDaysFromNow": 30,
  "nights": 3,
  "adults": 2,
  "currency": "USD",
  "maxResults": 60,
  "includeOffers": true
}
```

Every field, with its type and default:

| Field | Type | Default | Description |
|---|---|---|---|
| `searchQueries` | string\[] | — | Searches typed as on Google Hotels, one per line (up to 50): "hotels in Paris". `maxResults` applies to each. Prefilled with `["hotels in Lisbon"]` in the form; with no search, no URL and no hotel at all, the Actor searches hotels in Lisbon. |
| `startUrls` | string\[] | `[]` | Google Hotels search URLs copied from your browser (`https://www.google.com/travel/search?q=…&ts=…`), one search each, read without being opened (see below). |
| `hotelUrls` | string\[] | `[]` | Precise hotels: Google Hotels hotel URLs with `/entity/<id>`, or the entity ids (`ChkI…`), up to 500; each comes with every booking site's rate. |
| `checkIn` | string | — | Check-in date, YYYY-MM-DD. Leave both dates empty to use relative dates. |
| `checkOut` | string | — | Check-out date, YYYY-MM-DD, after check-in, 30 nights at most. Required when `checkIn` is set. |
| `checkInDaysFromNow` | integer | `30` | Without fixed dates: check-in this many days from today (UTC). |
| `nights` | integer | `3` | Without fixed dates: length of the stay (1 to 30). |
| `adults` | integer | `2` | Number of adults (1 to 6). |
| `childAges` | integer\[] | `[]` | Age of each child (0 to 17), e.g. `[8]`; up to 6 children. |
| `currency` | string | `"USD"` | ISO 4217 code of every price: `USD` and `EUR` validated, any other code Google Hotels lists accepted (GBP, JPY, CAD…). |
| `language` | string | `"en"` | Google language (`hl`) of the class labels, deal notes and rental amenities: `en`, `fr`, `de` validated. Type the searches in that language. |
| `country` | string | `"us"` | Google market (`gl`): `us`, `fr`, `de` validated. |
| `maxResults` | integer | `60` | Stop each search after this many unique hotels (300 at most); with `monitorPrices`, the number of hotels compared. You are never charged for more. Prefilled with `20` in the form (a quick first run). |
| `includeVacationRentals` | boolean | `false` | Also keep the vacation rentals Google mixes into the results (about one in ten). |
| `includeOffers` | boolean | `false` | Add every booking site's rate to each hotel row: one more request per hotel, no extra charge. Always on for `hotelUrls`. |
| `maxOffersPerHotel` | integer | `0` | Keep the N cheapest booking sites in `offers` (0 = all); `offerCount` and the parity columns count them all. |
| `freeCancellationOnly` | boolean | `false` | Keep only the hotels that a booking site sells with free cancellation (`cancellationPolicy` filled). Applied by the Actor on the booking-site rates, so it turns `includeOffers` on; the hotels left out are never charged and the next hotels of the search take their place. |
| `monitorPrices` | boolean | `false` | Price monitoring: compare every hotel with your previous run of the same search and fill `changeType`, `previousPrice`, `priceDelta` and `priceDeltaPercent` (see *Price monitoring*). |
| `monitorStoreName` | string | `"google-hotels-price-monitor"` | Key-value store of your account that keeps the previous prices, one record per search. Letters, digits and dashes. |
| `onlyChanges` | boolean | `false` | With `monitorPrices`: save and charge only the new hotels and the price changes; a run without any change succeeds with an empty dataset. |
| `proxyConfiguration` | object | `{"useApifyProxy":true}` | Apify datacenter proxies, the configuration validated for Google Hotels, included in the price: keep it. Your own proxy URLs are accepted. |
| `maxRequests` | integer | `500` | Safety cap on requests per run, retries included. |
| `concurrency` | integer | `3` | Requests in flight at the same time for the booking-site rates and `hotelUrls` (1 to 5). |
| `delayMs` | integer | `300` | Pause after each request, in milliseconds. |
| `debugStoreResponses` | boolean | `false` | Debugging only: store every raw response in the key-value store. |

### Booking sites and direct links

Google Hotels compares the price of each hotel on many booking sites — Booking.com, Expedia, Hotels.com, Agoda, Trip.com, Priceline, the hotel's own website and more, usually 15 to 25 per hotel. Tick `includeOffers` and each hotel row gets them all in `offers`, **cheapest first** (price of the stay with taxes), with for each site:

- `site`, `siteId` and `isOfficialSite` (the hotel's own website);
- `pricePerNight` and `pricePerNightWithTaxes`, `priceTotal` and `priceTotalWithTaxes` for the stay, in the row's `currency`;
- `bookingUrl`: the **direct link** to the booking site's page for the stay, decoded from Google's redirect, never a Google tracking link.

Three summary columns make the rate parity check a single filter: `cheapestOfferSite` and `cheapestOfferPriceTotal` (the lowest price with taxes), and `officialSitePriceTotal` (the price on the hotel's own website, `null` when the hotel sells none through Google). `offerCount` counts the sites; `maxOffersPerHotel` keeps only the N cheapest in `offers` when you need a lighter dataset.

**Free cancellation.** Google shows the cancellation terms of the rooms that booking sites such as Expedia, Hotels.com or Priceline advertise for the hotel: `cancellationPolicy` gives the deadline (`free_cancellation_until:2026-11-17` in the output example), and `freeCancellationOnly` keeps only the hotels with such a rate. The filter is applied by the Actor, not by Google: the hotels left out cost you nothing, the next hotels of the search take their place, and the `SUMMARY` record counts them.

```json
{
  "searchQueries": ["hotels in Lisbon"],
  "checkIn": "2026-11-20",
  "checkOut": "2026-11-23",
  "adults": 2,
  "currency": "USD",
  "maxResults": 20,
  "includeOffers": true,
  "maxOffersPerHotel": 10
}
```

Each hotel then takes one more request (about a second, three in parallel): the rates are part of the hotel row and **cost nothing extra**. Rates are those Google shows to a visitor without an account in the chosen market; a site may show another price after you click (member prices, rooms, availability), and the occupancy of these rates is verified for 2 adults (other occupancies are passed to Google as they are).

### Search from Google Hotels URLs

Run a search on Google Hotels in your browser, copy the address of the results page and paste it into `startUrls`; add hotel pages or entity ids to `hotelUrls`. **The URLs are read locally and never opened**: the Actor takes what they say and asks Google for the same data.

```json
{
  "startUrls": [
    "https://www.google.com/travel/search?q=hotels%20in%20Lisbon&ts=CAESCgoCCAMKAggDEAAaIAoCGgASGhIUCgcI6g8QCxgUEgcI6g8QCxgXGAMyAhAAKgkKBToDVVNEGgA&hl=en&gl=us"
  ],
  "hotelUrls": [
    "https://www.google.com/travel/hotels/entity/ChkIhLCQwvjO2IYWGg0vZy8xMXE0bTZieDkyEAE",
    "ChkIg-b2ismUj7M1Gg0vZy8xMWg3MThreGg1EAE"
  ],
  "maxResults": 40
}
```

- **Read from a search URL**: the search text (`q`), the dates, travellers and currency (the `ts` parameter: here 20–23 November 2026, 2 adults, USD), the language (`hl`) and the market (`gl`). What the URL leaves out comes from the form.
- **Not supported**: the filters and sort of the page (stars, price range, amenities, map area), which are ignored and listed in the run log. A URL without a `q` text (a map or a place page) makes the run fail at once with the URL number and the reason: open a search by typing a destination, then copy the address.
- **Hotels of `hotelUrls`** use the stay, travellers, currency and market of the form, and always come with every booking site's rate. A hotel found by a search and listed in `hotelUrls` for the same stay is saved once.

### Price monitoring

Use the Actor as a **Google Hotels price tracker**: tick `monitorPrices`, then **schedule the run** (daily is typical). The scraper keeps the last price of every hotel it compared in a key-value store of your account named `monitorStoreName` (`google-hotels-price-monitor` by default), with one record per search (same text or URL, stay, travellers, currency, language and market). The first run of a search is the reference: every hotel comes back with `changeType` = `"new"` (and `RUN_STATS.monitorBaseline` is true). From the second run on, every hotel is compared with the recorded one: `price_changed` rows carry `previousPrice`, `priceDelta` and `priceDeltaPercent`, the others are `unchanged`. With `onlyChanges` the dataset holds **only the new hotels and the price changes**, and **only those rows are charged**; a run where nothing changed succeeds with an empty dataset. **The compared price is `priceTotal`**, the lowest price of the stay with taxes and fees.

A scheduled input that watches 100 hotels in Paris for a 2-night stay two weeks ahead:

```json
{
  "searchQueries": ["hotels in Paris"],
  "checkInDaysFromNow": 14,
  "nights": 2,
  "adults": 2,
  "currency": "USD",
  "maxResults": 100,
  "monitorPrices": true,
  "onlyChanges": true
}
```

A `price_changed` row, as the Actor produces it from the row of the output example when the previous run had recorded a total of $600 (the other columns are the same as below):

```json
{
  "platformListingId": "ChkIhLCQwvjO2IYWGg0vZy8xMXE0bTZieDkyEAE",
  "title": "Brown's | Avenue Hotel",
  "checkIn": "2026-11-20",
  "checkOut": "2026-11-23",
  "currency": "USD",
  "priceTotal": 564.25,
  "changeType": "price_changed",
  "previousPrice": 600,
  "priceDelta": -35.75,
  "priceDeltaPercent": -6
}
```

- **Fixed dates compare one stay; relative dates compare a lead time.** With `checkIn` / `checkOut` the record follows the price of that stay; with relative dates (the default) it follows the price of the stay *N days ahead for M nights*, so a change mixes the hotel's pricing and the calendar.
- **The record is written only after a clean run.** A refused or failed search, a charge limit reached in the middle of a run or an interrupted run never overwrites the reference.
- **Rankings move.** Google's order varies between runs, so the set of compared hotels (the first `maxResults`) drifts a little; a hotel that drops out of the results and comes back is not reported as new (its last price is kept for 90 days). Use `hotelUrls` to follow a fixed list of hotels.

### Output example

One real row, produced by the Actor from a Lisbon search (USD, 20–23 November 2026, 2 adults) with `includeOffers` and `maxOffersPerHotel` set to 3 to keep the example short (the hotel had 22 booking sites, counted in `offerCount`). All columns are present, in this order, for every hotel:

```json
{
  "schemaVersion": "travel-listing/1.7",
  "platform": "google_hotels",
  "platformListingId": "ChkIhLCQwvjO2IYWGg0vZy8xMXE0bTZieDkyEAE",
  "url": "https://www.google.com/travel/hotels/entity/ChkIhLCQwvjO2IYWGg0vZy8xMXE0bTZieDkyEAE?q=hotels%20in%20Lisbon&ts=CAESCgoCCAMKAggDEAAaIAoCGgASGhIUCgcI6g8QCxgUEgcI6g8QCxgXGAMyAhAAKgkKBToDVVNEGgA&hl=en&gl=us",
  "title": "Brown's | Avenue Hotel",
  "propertyType": "5-star hotel",
  "roomType": "hotel_room",
  "city": "Lisbon",
  "region": null,
  "country": "Portugal",
  "countryCode": "PT",
  "latitude": 38.7220236,
  "longitude": -9.1456424,
  "checkIn": "2026-11-20",
  "checkOut": "2026-11-23",
  "nights": 3,
  "guests": 2,
  "currency": "USD",
  "pricePerNight": 169.26,
  "priceTotal": 564.25,
  "priceBeforeDiscount": null,
  "cleaningFee": null,
  "serviceFee": null,
  "taxesAndFees": 56.48,
  "taxesIncluded": true,
  "priceTotalAllIn": 564.25,
  "rating": 4.6,
  "ratingMax": 5,
  "reviewCount": 283,
  "starRating": 5,
  "bedrooms": null,
  "beds": null,
  "bathrooms": null,
  "maxGuests": null,
  "amenities": [
    "Breakfast",
    "Free Wi-Fi",
    "Parking ($)",
    "Outdoor pool",
    "Air conditioning",
    "Restaurant",
    "Airport shuttle",
    "Full-service laundry"
  ],
  "badges": [
    "20% less than usual"
  ],
  "isSuperhost": null,
  "listedBy": null,
  "instantBook": null,
  "isNew": null,
  "isAvailable": true,
  "cancellationPolicy": "free_cancellation_until:2026-11-17",
  "imageUrls": [
    "https://lh3.googleusercontent.com/grass-cs/AABkmLdujg01vZaFk7NCx76fXiCl8-YyLLBABMeFGEYiTmy2EIFv4gxnfT4Oadb7cK7v1yTZqjNju8jymLbuEZTLCkWkju_7Gav6tzkFj6EAPQNfI43oBw9fplVFSYMrRsRZxvbZ7DFf=s287-w287-h192-n-k-no-v1",
    "https://lh3.googleusercontent.com/grass-cs/AABkmLf-yYJz_jODrxFP62Fzkz1HZdxMN3_clZulfEBpqYAFLEXmBDeLm2Ng98hLqSwzPt870hMxROxs8i5ynIhzcfFfE-QOXHqBdBhdVAifainVw0yrnK9zzrRXxaAPbS0iJTrxBYfzUw=s287-w287-h192-n-k-no-v1"
  ],
  "imageCount": 2,
  "searchLocation": "hotels in Lisbon",
  "searchRank": 1,
  "searchPage": 1,
  "viewCountryCode": "US",
  "scrapedAt": "2026-10-22T08:00:00.000Z",
  "changeType": null,
  "previousPrice": null,
  "priceDelta": null,
  "priceDeltaPercent": null,
  "pricePerNightWithTaxes": 188.08,
  "priceTotalBeforeTaxes": 507.77,
  "description": "Polished adults-only hotel offering a lounge & a restaurant, plus a rooftop pool with city views.",
  "checkInTime": null,
  "checkOutTime": null,
  "website": "https://www.brownshotelgroup.com/browns-avenue/",
  "ratingBreakdown": [
    {
      "stars": 5,
      "percent": 82,
      "count": 224
    },
    {
      "stars": 4,
      "percent": 10,
      "count": 30
    },
    {
      "stars": 3,
      "percent": 4,
      "count": 14
    },
    {
      "stars": 2,
      "percent": 2,
      "count": 7
    },
    {
      "stars": 1,
      "percent": 2,
      "count": 8
    }
  ],
  "googleHotelId": "4896003618326261334",
  "googleMapsCid": "0xd193339fd7c9273:0x160d627788441804",
  "googlePlaceId": "ChIJc5J8_TkzGQ0RBBhEiHdiDRY",
  "offersIncluded": true,
  "offers": [
    {
      "site": "Vio.com",
      "siteId": "1587851245",
      "isOfficialSite": false,
      "currency": "USD",
      "pricePerNight": 169.26,
      "pricePerNightWithTaxes": 188.08,
      "priceTotal": 507.77,
      "priceTotalWithTaxes": 564.25,
      "bookingUrl": "https://deals.vio.com/?sig=73aca13c7f952d2641c156f3e69125e1eb497c325f122828ee5aa8797168b9a12d32303331333438363233&turl=https%3A%2F%2Fwww.vio.com%2FHotel%2FSearch%3FcheckIn%3D2026-11-20%26checkOut%3D2026-11-23%26currency%3DUSD%26forceCurrencyChange%3D1%26lang%3Den%26forceLanguageChange%3D1%26rooms%3D2%3A%26utm_source%3Dgha%26utm_medium%3Dcpc%26hotelId%3D22249821%26userCountry%3DUS%26profile%3Dr2d2m73kn8%26preferredRate%3D564.25%26deviceType%3Ddesktop%26label%3Dsrc%253Dgha%2526cltype%253Dhotel%2526datype%253Ddefault%2526gsite%253Dlocaluniversal%2526vf%253D0%2526ucountry%253DUS%2526udevice%253Ddesktop%2526hotel%253D22249821%2526day%253D20%2526month%253D11%2526year%253D2026%2526los%253D3%2526price%253D564.25%2526currency%253DUSD%2526cid%253D%2526listid%253D%2526rateid%253DUS_D%2526closerateid%253D%2526promo%253D0%2526isPrivateRate%253D0%2526isAudienceUser%253D0%2526isPaidClick%253D0%2526%26cp%3DiiEEQLM_XUnurHdAChoI2owDGJIsIgNVU0Q6AgIBQgXZugKTflIBMhIaFaSogEQaC0JyUDAtSndIcy1VKAIwy8Pm1gY"
    },
    {
      "site": "Brown's Avenue",
      "siteId": "101190818",
      "isOfficialSite": true,
      "currency": "USD",
      "pricePerNight": 169.42,
      "pricePerNightWithTaxes": 188.58,
      "priceTotal": 508.27,
      "priceTotalWithTaxes": 565.73,
      "bookingUrl": "https://reservation.mirai.com/Forwarder/googleFrontDispatcher.htm?idtokenprovider=100377808&checkin=20/11/2026&nights=3&lang=en&hsri=02040&adults=2&children=0&ages=&babies=0&googlecrawler=false&utm_source=hotelfinder&utm_medium=organic&utm_campaign=organic&currency=USD&rates=MjU2OTV8NDU2OTZ8MjU3NzQ4YjB8MjE3MDB8NTY3MzA1&tracking=&utm_content=US&UserDevice=desktop&clickorigin=NOT-RBM&date_type=default&campaign_id=organic&googlesite=localuniversal&tt_meta=gha&PPA1=FALSE&user_list_id=&clk_src=&prid=mirai_desktop_club&totalPrice=565.73&taxes=57.46&otherFees=0.00"
    },
    {
      "site": "Super.com",
      "siteId": "311056061",
      "isOfficialSite": false,
      "currency": "USD",
      "pricePerNight": 187.1,
      "pricePerNightWithTaxes": 191.88,
      "priceTotal": 561.29,
      "priceTotalWithTaxes": 575.64,
      "bookingUrl": "https://www.super.com/travel/transition/?data=price=475.1%26total_price=487.87%26retail_price=574.71%26retail_total_price=590.16%26surcharge=24.14%26request_id=12570298763110672384%26ps=1666741866%26pb=0-slAkZlDjP06IhVxwa_7LufMI_R4dfzcrGLYgnWYtL5Evv1up5LurPpdrv7XHBt5DN-7dDSpThoELjTuRiy_7vwTaHsfHQ0dx3C_cU6JoqhgqdJT08LCNWGYAmtaCnqtFkUx9YPzaG4lD6aBfZjjg%253D%253D%26gha_pull_request=True%26alwd_rand=false%26gt=1792639542%26sg=68XS_%26sid=GHA_MD4%26cmab_id=33%26ib=false%26all_inclusive=false&utm_source=gha&utm_content=localuniversal&currency=EUR&user_country=US&verification=false&rate_rule_ids=&date_type=default&rate_rule_id=signedout_desktop&display_currency=USD&display_all_inclusive_price=575.64&checkin_at=2026-11-20&checkout_at=2026-11-23&provider_hotel_id=10016849226&provider=htl&num_adults=2&children=[]&hotel_campaign=&utm_campaign=&user_locale=en-US&user_list_id=&utm_medium=organic&utm_id=gha_organic"
    }
  ],
  "offerCount": 22,
  "cheapestOfferSite": "Vio.com",
  "cheapestOfferPriceTotal": 564.25,
  "officialSitePriceTotal": 565.73
}
```

A hotel without a price for the stay has `isAvailable` `false` and its prices `null`; a vacation rental (with `includeVacationRentals`) has `propertyType` `Vacation rental`, `roomType` `entire_place`, its capacity and its own amenity list; in French (`language` `fr`, `country` `fr`) the class reads `Hôtel 5 étoiles` and the check-in times `14:00`.

The **Output** tab offers five views of the same rows: **Overview** (name, type, class, dates, prices, rating, reviews, link, photos), **Prices** (per night before and with taxes, taxes and fees, totals, deal note, cheapest site, official site), **Booking sites** (cheapest site and price, official site price, free cancellation, number of sites, offers), **Location** (city, country, coordinates, search, rank, Google Maps id) and **Changes** (for price-monitoring runs: change, total, previous total, difference in amount and percent).

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

This Actor uses **pay-per-event pricing: you pay a fixed price per hotel** saved to your dataset, and nothing else. The price of every plan tier is on the **Pricing tab** of this page; paid plans pay less per hotel.

| What you pay for | How it is counted | Price |
|---|---|---|
| `result` event: one hotel saved to your dataset | once per unique hotel of the run, capped by `maxResults` for each search; with `onlyChanges`, only the new hotels and the price changes; with `freeCancellationOnly`, only the hotels kept | Pricing tab, per plan tier |
| Every booking site's rate (`includeOffers`, `hotelUrls`) | part of the hotel row | included |
| Compute, proxies, storage and data transfer | included: no platform usage is passed on to you | — |

The cost of a run is known before you start: 1,000 hotels cost 1,000 times the `result` price of your tier, with or without the booking-site rates. One request returns 20 hotels in two to three seconds; with `includeOffers`, each hotel takes one more request of about a second, three at a time.

### Limits and behaviour worth knowing

- **One stay per search.** Every row of a search shares the same `checkIn`, `checkOut`, `guests` and `currency`, which is what makes prices comparable. A run holds one search per line of `searchQueries` and per URL of `startUrls`, plus the hotels of `hotelUrls`.
- **Google's order varies.** The default ranking of Google Hotels is not the same from one request to the next: the scraper removes the hotels seen twice and stops at `maxResults`, when Google has no next page, after two pages without a new hotel, or after a number of pages proportional to `maxResults`. Expect about 16 new hotels per page of 20.
- **Fewer hotels than `maxResults`? Each search says why**, in the status message of the run and in the `SUMMARY` record of its key-value store (also in `RUN_STATS.searches`): the hotels Google announced and served, the hotels returned, how many were left out and why (beyond `maxResults`, vacation rentals, found by an earlier search, without free cancellation, unchanged, errors), and why the search stopped (`maxResults`, last page, page cap, `maxRequests`…).
- **Prices are those of a visitor without an account** in the chosen market and currency: no member prices, no login. Sites may show another price after a click.
- **Occupancy of the booking-site rates**: verified with 2 adults; other occupancies are passed to Google as they are.
- **Currencies and languages**: `USD` and `EUR` are validated, other currencies Google lists are accepted; the class labels, deal notes and rental amenities follow `language`, hotel amenities stay in English.
- **Blocking and retries.** Every request uses a new proxy session; an unusable answer, a request Google refuses included, is retried three times with a growing pause (1, 2, 4 seconds), then the page or hotel is abandoned and reported, and the hotels already found are kept. If Google refuses every request and no hotel is found (its request format changed), the run fails with an explicit message.
- **No empty successes.** A run that finds no hotel ends as failed with an explicit message (search not recognised, dates in the past, every request refused), so that your schedules and integrations notice. The one exception is a price-monitoring run with `onlyChanges` that compared hotels and found no change: it succeeds with an empty dataset.

### What is not included

- **Sort and filters** of Google Hotels (price, rating, class, amenities): the results come in Google's default order; filter the dataset instead. Free cancellation is the one filter of the Actor (`freeCancellationOnly`).
- **Room-level rates**: one rate per booking site for the stay, not each room type (the room rates are read only for their free cancellation).
- **Reviews**: the average rating, the review count and the breakdown by stars only, never review texts or authors.
- **Hotel search by name**: give the hotel's URL or entity id in `hotelUrls`.
- **Phone numbers** and other contact details of the hotels.
- Price calendars of one hotel over many dates (one stay per run).

### Integrations and API

Start the Actor from Apify Console, schedule it, or call it from the [Apify API](https://docs.apify.com/api/v2) with any language (the **API** tab shows ready-made code for Node.js, Python and curl). Webhooks notify your systems when a run finishes; the dataset can be pulled as JSON, CSV, Excel, XML or RSS, or pushed to Google Sheets, Make, Zapier, n8n, Slack, Airtable, Google Drive and more through the Apify integrations.

For bugs or questions, open an issue in the **Issues** tab of this Actor with your run id and input. Bugs and format changes are fixed as a priority; feature requests (filters, room rates, price calendars) are welcome.

### Use it from your AI assistant

Add this Actor as a tool to Claude, ChatGPT, Cursor, VS Code or any MCP client with the Apify MCP server URL below (sign in with your Apify account when asked):

`https://mcp.apify.com?tools=myth84/google-hotels-scraper`

Then ask in plain words. Copy this prompt and change the details:

```text
Use myth84/google-hotels-scraper to compare 20 hotels in Rome on Google Hotels for 2 adults, 3 nights starting 30 days from today, prices in USD, with every booking site's rate. Input: {"searchQueries": ["hotels in Rome"], "checkInDaysFromNow": 30, "nights": 3, "adults": 2, "currency": "USD", "maxResults": 20, "includeOffers": true}. Show the name, class, rating, total price with taxes, the cheapest booking site and the hotel's own website price for each hotel.
```

### For AI agents (MCP)

Through the [Apify MCP server](https://docs.apify.com/mcp) this Actor is a tool that answers questions such as *"what do hotels in Lisbon cost for two adults from 20 to 23 November?"*, *"which booking site is cheapest for this hotel?"* or *"is this hotel cheaper on its own website than on Booking.com?"*.

**Minimal input** (one or more searches in `searchQueries`, `maxResults` per search; add `"includeOffers": true` for every booking site's rate; every other field keeps its default):

```json
{
  "searchQueries": ["hotels in Rome", "hotels in Florence"],
  "checkInDaysFromNow": 30,
  "nights": 3,
  "adults": 2,
  "currency": "USD",
  "maxResults": 20
}
```

- **Key output fields**: `platformListingId` (entity id), `title`, `url`, `priceTotal` (stay, taxes and fees included), `pricePerNight` (before taxes), `pricePerNightWithTaxes`, `taxesAndFees`, `currency`, `rating` (on 5), `reviewCount`, `starRating`, `amenities`, `latitude` / `longitude`, and with `includeOffers`: `offers` (site, prices, `bookingUrl`), `cheapestOfferSite`, `cheapestOfferPriceTotal`, `officialSitePriceTotal`, `cancellationPolicy` (free-cancellation deadline). Every column is always present, in a fixed order; `null` means Google did not show the value.
- **Use it when** you need current Google Hotels prices for a destination or for given hotels and a stay: lowest prices with taxes, the rate of each booking site, ratings, classes, amenities, locations. Pass `searchQueries` ("hotels in <place>"), the dates (`checkIn` / `checkOut`, or `checkInDaysFromNow` + `nights`), `adults`, `childAges`, `currency`, and a small `maxResults` (10–50 is enough for an answer). For precise hotels, pass their Google Hotels URLs or entity ids in `hotelUrls`.
- **Track prices** by scheduling the same input with `monitorPrices: true` (and `onlyChanges: true` for changes only).
- **Do not use it for** reviews, room-by-room availability, booking, phone numbers or anything behind a login: it collects no personal data and reads only what Google Hotels shows to a visitor.
- **Cost per 1,000 results**: 1,000 `result` events at the price of your plan tier (Pricing tab); the booking-site rates are included; nothing else is charged.
- **Typical time**: two to three seconds per page of 20 hotels; with `includeOffers`, about a second per hotel, three at a time: 20 hotels with every booking site in about 15 seconds.

### Alternatives and switching

- **Official API.** Google offers no public API for Google Hotels search results; its Hotel Center and Hotel Prices APIs are for hotels and partners who send their own rates. This Actor reads what any visitor sees on Google Hotels, with no account and no key.
- **Your own scraper.** Nothing to build or maintain: pagination, deduplication of Google's moving order, booking-site links, retries and format changes are handled for you. The columns stay the same from run to run, a run that finds nothing fails with an explicit message instead of succeeding empty, and a scheduled test run catches Google changes early.
- **Another scraper from the Store.** What you can count on here: `maxResults` is a hard cap for each search, the run stops at that number of hotels and you are never charged for more; with `monitorPrices` and `onlyChanges`, a scheduled run returns and charges only the new hotels and the price changes; `priceTotalAllIn` gives one total, taxes included, to compare with the other platforms. The input names differ from one Actor to the next; the usual ones map to this Actor as follows:

| Usual input | Here | Note |
|---|---|---|
| `query`, `search`, `location` | `searchQueries` | One search per line, as typed on Google Hotels |
| `startUrls`, `searchUrl` | `startUrls` | Google Hotels search URLs, read without being opened |
| `hotelUrl`, `entityId`, `propertyToken` | `hotelUrls` | Hotel URLs with `/entity/<id>` or the ids |
| `maxItems`, `limit` | `maxResults` | Unique hotels per search, never charged beyond |
| `checkin`, `checkout` | `checkIn`, `checkOut` | YYYY-MM-DD; or `checkInDaysFromNow` + `nights` for schedules |
| `adults`, `children` | `adults`, `childAges` | Children as a list of ages |
| `currency`, `hl`, `gl` | `currency`, `language`, `country` | Any currency Google lists |
| `prices`, `includePrices` | `includeOffers` | Every booking site's rate, no extra charge |
| `freeCancellation`, `refundableOnly` | `freeCancellationOnly` | Hotels with a free-cancellation rate only; the others are never charged |
| `monitor`, `trackPrices` | `monitorPrices`, `onlyChanges` | Compares with your previous run of the same search |

### FAQ

#### Is there a Google Hotels API?

Not for search results. Google's Hotel Center and Hotel Prices APIs are made for hotels and travel partners to send their own rates to Google, not to read the results. This Actor gives you the Google Hotels results as data — the lowest price of each hotel, every booking site's rate with direct links, ratings, classes and amenities — through Apify's API, with no account or key on Google's side.

#### Why is the order different between runs?

Google's default ranking of hotels is not deterministic: two identical requests return pages that overlap only partly, in a different order. The scraper removes the hotels seen twice and goes on until it has `maxResults` unique hotels, so the set is complete for the first pages but may differ a little from run to run, and `searchRank` is Google's rank at the time of the request. To follow the same hotels every day, list them in `hotelUrls`.

#### Which currencies?

Any currency Google Hotels lists (about 70), with `currency` set to its ISO code: `USD` and `EUR` are validated, `GBP`, `JPY`, `CAD`, `AUD`, `CHF`, `INR` and the others are accepted and passed to Google as they are. The currency does not depend on the proxy country, and every price of a row — the offers included — is in the row's `currency`.

#### Does it use residential proxies?

No. Google Hotels answers from Apify's datacenter proxies, the default `proxyConfiguration`, whose cost is included in the price per hotel: keep it. Each request uses a new proxy session, and refused requests are retried on another one.

#### Does Google Hotels Scraper collect personal data?

No. The scraper keeps nothing about guests, reviewers or hotel staff: no names, photos, profile links, review texts or phone numbers. It outputs hotel facts (business names, map coordinates, amenities), the average guest rating, the number of reviews and their distribution by stars. Every row goes through a privacy filter before it is saved.

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

The Actor only reads hotel results that Google serves to any visitor without an account, through the data endpoint of the Google Travel web app, and it stores no personal data. Scraping public data is generally lawful, but you are responsible for how you use the results and for complying with Google's terms and the laws that apply to you (including copyright on texts and photos). Use the data for analysis, not to republish listings.

#### Do the prices include taxes and fees?

`priceTotal` does: it is the lowest price of the whole stay with taxes and fees (`taxesIncluded` is `true`), and `priceTotalAllIn`, equal to it, is the column to compare with the other platforms of the studio. `pricePerNight` is Google's nightly price before taxes; `pricePerNightWithTaxes`, `priceTotalBeforeTaxes` and `taxesAndFees` give the other views. Each booking site of `offers` has its own prices before and with taxes.

#### How do I check rate parity?

Tick `includeOffers` (or list the hotels in `hotelUrls`) and compare `officialSitePriceTotal`, the price on the hotel's own website, with `cheapestOfferPriceTotal` and `cheapestOfferSite`, the cheapest booking site; `offers` gives every site's price and direct link. A hotel without an official-site rate on Google has `officialSitePriceTotal` `null`.

#### How often should I run it, and how do I get only price changes?

Every run fetches live results. Schedule the Actor as often as your use case needs (daily is typical for price tracking) and compare runs by `platformListingId`, `checkIn` and `checkOut`, or let the Actor do it: tick `monitorPrices` (and `onlyChanges`). The first run records every hotel of the search as `new`; each later run flags the new hotels and the price changes, with `previousPrice`, `priceDelta` and `priceDeltaPercent`, and with `onlyChanges` returns and charges only those rows.

#### What are relative dates?

Leave `checkIn` and `checkOut` empty and the Actor searches a stay starting `checkInDaysFromNow` days from today for `nights` nights, so that a scheduled run or an example task never expires. Give fixed dates when you need a quote for precise dates.

### More scrapers by Flatrow Data Studio

The travel scrapers of the studio share the same core columns, so stays from several platforms land in one table; compare their prices on `priceTotalAllIn`, the total of the stay with taxes and fees, filled with the same rule by each scraper (`null` when a platform does not show the taxes):

- [Booking.com Hotels Scraper & Price Tracker](https://apify.com/myth84/booking-hotels-scraper): Booking.com hotel prices for your dates with the excluded taxes, review scores and stars, search URLs and price monitoring.
- [Expedia Hotels Scraper & Price Tracker](https://apify.com/myth84/expedia-hotels-scraper): Expedia hotel prices per night and for the stay, guest ratings and review counts, with price monitoring.
- [Agoda Hotels Scraper & Price Tracker](https://apify.com/myth84/agoda-hotels-scraper): Agoda hotel and rental prices for any city and dates, with taxes shown or not, and price monitoring.
- [Airbnb Listings Scraper & Price Tracker](https://apify.com/myth84/airbnb-listings-scraper): Airbnb prices, ratings, review counts and locations for any place and dates, with price monitoring.

Did this scraper give you the data you needed? A rating on its Store page helps other people find it. For a bug or a missing field, open an issue in the **Issues** tab.

### Legal note

This Actor reads publicly available Google Hotels results without logging in and collects no personal data. You are responsible for your use of the data and for complying with Google's terms and the laws that apply to you.

Not affiliated with, endorsed or sponsored by Google LLC. Google and Google Hotels are trademarks of Google LLC.

# Changelog

This Actor's version history is a separate document: https://apify.com/myth84/google-hotels-scraper/changelog.md

# Actor input Schema

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

One search per line, typed as on Google Hotels: a destination with the word hotels, e.g. <code>hotels in Paris</code>, <code>hotels near Times Square</code>. Each is its own search with the same stay and currency, and <b>maxResults applies to each</b>. A hotel name gives no list: use hotelUrls. Up to 50. Optional: with no search, no URL and no hotel at all, the Actor searches hotels in Lisbon.

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

Google Hotels search URLs copied from your browser (<code>https://www.google.com/travel/search?q=…\&ts=…</code>), one search each, read locally and never opened: the search text (q), the dates, travellers and currency (ts) and the language and market (hl, gl) win over the form, which fills in the rest. Filters of the page are ignored and listed in the log. Default empty: search by text.

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

Precise hotels, one per line: a Google Hotels hotel URL containing /entity/, e.g. <code>https://www.google.com/travel/hotels/entity/ChkIhLCQwvjO2IYWGg0vZy8xMXE0bTZieDkyEAE</code>, or the bare entity id (<code>ChkI…</code>). Each one comes with the rate of every booking site for the stay of the form. Up to 500. Default empty: no precise hotel.

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

Check-in date, YYYY-MM-DD, e.g. <code>2026-12-01</code>, given with checkOut. Leave both empty for a stay relative to today (checkInDaysFromNow and nights), better for schedules: fixed dates expire.

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

Check-out date, YYYY-MM-DD, after checkIn and at most 30 nights later, e.g. <code>2026-12-04</code>. Required when checkIn is set.

## `checkInDaysFromNow` (type: `integer`):

Without fixed dates: check-in this many days after today (UTC), e.g. <code>7</code> for next week. Default 30: a month ahead, a typical booking window, and the stay moves with each scheduled run so it never expires.

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

Without fixed dates: length of the stay in nights, 1 to 30. Default 3: a typical city break.

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

Number of adults, 1 to 6 (Google Hotels prices up to 6); prices depend on it. Default 2: the most searched occupancy.

## `childAges` (type: `array`):

Age of each child, 0 to 17, as a JSON list, e.g. <code>\[8]</code> for one child of 8 or <code>\[3, 12]</code> for two; prices depend on it. Up to 6 children. Default empty: no child.

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

ISO 4217 code of every price, e.g. <code>USD</code>, <code>EUR</code> or <code>JPY</code>; pick one or type any code Google Hotels lists (USD and EUR validated). The currency does not depend on the proxy country. Default USD: the currency of our validation runs.

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

Google language code (hl) of the class labels, deal notes and rental amenities, e.g. <code>en</code>, <code>fr</code>, <code>de</code>; hotel names keep their own language and hotel amenities stay in English. Type the searches in that language. Default en: English, validated with fr and de.

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

Google country code (gl) of the market, e.g. <code>us</code>, <code>fr</code>, <code>de</code>: the country whose Google Hotels you read (offers and booking sites may differ by market). Default us: United States, validated with fr and de.

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

Maximum number of hotels saved and charged for each search (each search text and each search URL), 1 to 300; Google returns 20 per request. With price monitoring it is the number compared. Default 60: three pages of results, enough to compare a city. The form prefills 20 for a quick first run (our daily check).

## `includeVacationRentals` (type: `boolean`):

Also keep the vacation rentals Google Hotels mixes into the results (about one result in ten: apartments, houses), as entire places with their capacity. Default off: hotels, hostels and guest houses only.

## `includeOffers` (type: `boolean`):

Add the rates of every booking site to each hotel row (offers, cheapestOfferSite, officialSitePriceTotal…): one more request per hotel, so runs are slower, at no extra charge. Always on for hotelUrls. Default off: the lowest price only.

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

Keep only the N cheapest booking sites in the offers column of each row, e.g. <code>5</code>; offerCount and the parity columns still count all of them. 0 keeps them all. Default 0: every booking site (usually 15 to 25).

## `freeCancellationOnly` (type: `boolean`):

Keep only the hotels that a booking site shown by Google sells with free cancellation; cancellationPolicy then gives the deadline, e.g. <code>free_cancellation_until:2026-11-18</code>. Applied by the Actor on the booking-site rates: turns includeOffers on (one more request per hotel), and the hotels left out are never charged. Default off: every hotel.

## `monitorPrices` (type: `boolean`):

Compare the total price of each hotel (taxes and fees included) with the one recorded by your previous run of the same search, and fill changeType, previousPrice and priceDelta. maxResults is then the number of hotels compared. Default off: a plain search.

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

Key-value store of your account that keeps the previous prices, one record per search, e.g. <code>google-hotels-paris-daily</code>. Letters, digits and dashes, up to 63 characters. Default google-hotels-price-monitor: one store for all your monitoring runs.

## `onlyChanges` (type: `boolean`):

With monitorPrices: save and charge only the new hotels and the price changes (price drop alerts); a run without any change succeeds with an empty dataset. Default off: every compared hotel is saved with its changeType.

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

Proxies of the requests. Default: Apify datacenter proxies (automatic group), the configuration validated for Google Hotels, included in the price: keep it. Your own proxy URLs are accepted.

## `maxRequests` (type: `integer`):

Safety cap on requests for the whole run, retries included: one per page of 20 hotels, plus one per hotel with includeOffers or hotelUrls. Default 500: enough for 5 searches of 60 hotels with every booking site.

## `concurrency` (type: `integer`):

Requests in flight at the same time for the booking-site rates and hotelUrls, 1 to 5 (the pages of one search run one after the other). Default 3: the pace of our validation runs.

## `delayMs` (type: `integer`):

Pause after each request of a search or of a parallel slot, in milliseconds (retries have their own growing pause); 0 disables it. Default 300: a light pace.

## `debugStoreResponses` (type: `boolean`):

Debugging only: save every raw response (refused attempts included) in the run's key-value store. Default off: it uses storage.

## Actor input object example

```json
{
  "searchQueries": [
    "hotels in Lisbon"
  ],
  "startUrls": [],
  "hotelUrls": [],
  "checkInDaysFromNow": 30,
  "nights": 3,
  "adults": 2,
  "childAges": [],
  "currency": "USD",
  "language": "en",
  "country": "us",
  "maxResults": 20,
  "includeVacationRentals": false,
  "includeOffers": false,
  "maxOffersPerHotel": 0,
  "freeCancellationOnly": false,
  "monitorPrices": false,
  "monitorStoreName": "google-hotels-price-monitor",
  "onlyChanges": false,
  "proxyConfiguration": {
    "useApifyProxy": true
  },
  "maxRequests": 500,
  "concurrency": 3,
  "delayMs": 300,
  "debugStoreResponses": false
}
```

# Actor output Schema

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

All extracted hotels as dataset items, one flat row per hotel. Append ?format=csv or ?format=xlsx for spreadsheets. The Overview view is selected by default; the Booking sites view shows the rate of every site.

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

JSON record: for every search (and every group of hotelUrls), the hotels Google announced and served, the hotels returned, how many were left out and why (beyond maxResults, vacation rentals, found by an earlier search, without free cancellation, unchanged, errors), why the search stopped, and the same in one sentence.

## `runStats` (type: `string`):

Requests and retries made, refused attempts, bytes transferred, search pages and booking-site calls, duplicates, hotels without a price, hotels seen and pushed, and the estimated platform cost of the run.

# 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 Lisbon"
    ],
    "maxResults": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("myth84/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 Lisbon"],
    "maxResults": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("myth84/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 '{
  "searchQueries": [
    "hotels in Lisbon"
  ],
  "maxResults": 20
}' |
apify call myth84/google-hotels-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,myth84/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/2lyxEF4w0vLVZ1I6K/builds/0Ueafj1qzVgfxhPlS/openapi.json