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

Hotel and vacation-rental prices from Google Hotels for any place, dates and guests: nightly prices before and after taxes, deals, ratings, amenities and location, with Google's own filters. Compare every booking site's price and room rates, price specific hotels, and track price drops between runs.

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

## Pricing

from $0.50 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
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

Get **hotel prices from Google Hotels** for any place and dates: **the nightly price before and after taxes**, Google's **deal badges** ("19% less than usual"), **ratings and reviews**, star class, amenities, location and photos, for hotels and vacation rentals alike. Compare **every booking site's price and room rate** for the stay, price **specific hotels** by name or link, and get **price-drop alerts**: scheduled runs that return only the prices that changed.

- **Any place, any dates.** A city, a neighbourhood, or any Google Hotels search such as "hotels near Times Square, New York" or "vacation rentals in Banff". Dates as `2026-11-05` or "2 weeks" from today, any number of nights, adults and children.
- **Specific hotels.** Paste Google Hotels links, or write names such as "Fairmont Royal York Toronto". A name Google doesn't recognise is reported as not found, never swapped for another hotel.
- **Prices in your currency.** 35 currencies, whatever the place: EUR for Paris, JPY for Tokyo, or USD for all of them.
- **Google's own filters.** Price range, star class, guest rating, 20 amenities, property type, free cancellation, special offers, eco-certified, and Google's four sort orders.
- **Every booking site's price (hotel price comparison).** 13 to 27 sites per hotel in our tests, cheapest first, each with the nightly and total price before and after taxes, free cancellation and its deadline, the room and a booking link.
- **Every room rate.** Dozens of rates per hotel across the sites (7 to 108 in our tests), each with the room name, price, whether breakfast is included, and free cancellation. Plus review quotes, the hotel's full amenity list by category, the languages its staff speak, its address and phone.
- **Price-drop alerts (hotel price tracker).** Turn on **Only price changes** and schedule the run: each run returns just the price drops and rises since the last one, with the previous price and the change. Unchanged hotels aren't returned or charged.
- **Many check-in dates in one run.** Up to 60 check-in dates in a row, to see how prices move across a month.
- **Deep lists.** 18 properties a page, as many pages as you ask for, with no property twice.

No login, no API key and no cookie setup. Runs are quick: 20 properties take about 10 to 20 seconds, 100 about a minute, and a hotel with every booking site's price about 3 seconds.

### What you get for each property

| Field | Example |
|---|---|
| `name`, `type`, `hotelClass` | Hyatt Regency Paris Étoile, hotel, 4 |
| `pricePerNight`, `pricePerNightWithTaxes`, `currency` | 192.05, 228, EUR (the lowest price Google shows for the stay) |
| `deal`, `dealPercentBelowUsual` | Deal, 19 |
| `rating`, `reviewCount`, `ratingHistogram` | 4.4, 6432, and the count of each star rating |
| `reviewHighlights` | what reviews mention and how: Service, Location, Cleanliness... with positive and negative counts |
| `checkIn`, `checkOut`, `nights` | 2026-11-05, 2026-11-08, 3 |
| `amenities` | Free Wi-Fi, Pool, Fitness center, Bar, Restaurant... |
| `propertyDetails` | rentals: Entire house, Sleeps 6, 2 bedrooms, 2 bathrooms |
| `latitude`, `longitude`, `nearbyPlaces` | 48.88, 2.28, and nearby attractions, transit and airports with walking, taxi and transit times |
| `checkInTime`, `checkOutTime`, `description`, `images` | 3:00 PM, 12:00 PM, a one-line description, photo links |
| `officialWebsite`, `googleHotelsUrl`, `googleMapsUrl` | the hotel's site, its Google Hotels page for your dates, its map |
| `position`, `matchesFilters` | its place in Google's list; false for the near matches Google adds outside your filters |
| `searchLocation`, `googlePlace` | the place you asked for, and where Google says it searched (they differ when Google reads a landmark as somewhere else) |

With **Booking-site prices** on, and for every hotel under **Specific hotels**, each property also gets:

| Field | Example |
|---|---|
| `offers` | every booking site's price, cheapest first (below) |
| `offersCount`, `cheapestSite` | 23, Vio.com |
| `rooms` | every room rate the sites list, cheapest first (below) |
| `reviewSnippets` | short review quotes Google shows, such as "Great location and tasty breakfast" |
| `amenitiesByCategory`, `amenities` | Internet: Free Wi-Fi...; Pools: Indoor pool, Hot tub; Parking: Parking ($), EV charger... (45 amenities for the Hyatt above) |
| `languagesSpoken` | Arabic, English, French, Japanese... |
| `address`, `phone` | 3 Pl. du Général Kœnig, 75017 Paris, France; +33 1 40 68 12 34 |

| Offer field | Example |
|---|---|
| `site`, `isOfficialSite` | Expedia.ca, false |
| `pricePerNight`, `pricePerNightWithTaxes` | 180.48, 216.19 |
| `totalPrice`, `totalPriceWithTaxes` | 541.44, 648.56 (the whole stay) |
| `freeCancellation`, `freeCancellationUntil` | true, 2026-10-30 |
| `roomName` | Room, 2 Double Beds, Non Smoking (the site's cheapest room, where Google lists rooms) |
| `url` | Google's link to book with that site |

| Room field | Example |
|---|---|
| `site`, `roomName` | Hotels.com, Deluxe Room, 1 King Bed |
| `pricePerNight`, `pricePerNightWithTaxes`, `totalPrice`, `totalPriceWithTaxes` | 304.35, 351.69, 913.04, 1055.06 |
| `breakfastIncluded` | true, false, or null where the site doesn't say |
| `freeCancellation`, `freeCancellationUntil` | true, 2026-11-04 |
| `features`, `url` | Nonsmoking...; the booking link |

With **Only price changes** on, each returned property also carries `changeType` (`new`, `priceDrop`, `priceRise`, `priceAvailable` or `priceUnavailable`), `previousPrice`, `priceChange` and `priceChangePercent`.

### How to use it

Enter one or more places, a check-in date and the nights, then press **Start**.

#### Hotels in a city for your dates

```json
{ "locations": ["Paris"], "checkIn": "2026-11-05", "nights": 3, "adults": 2, "currency": "EUR", "maxResultsPerSearch": 50 }
```

A bare place is searched as "hotels in Paris". Write your own Google Hotels search to get something else: `hostels in Berlin`, `vacation rentals in Banff`, `hotels near Times Square, New York`. Name the city with a landmark: Google reads "hotels near the Colosseum" on its own as the Las Vegas venue and searches the whole United States, and "hotels near Times Square" alone finds nothing. Each row's `googlePlace` says where Google searched, and the run's status message points out a search Google read as somewhere else. Children go in **Children's ages**, one age per child.

#### With Google's filters

```json
{ "locations": ["Miami Beach"], "hotelClass": ["4", "5"], "minRating": "4.5", "amenities": ["pool", "beachAccess"], "maxPrice": 400, "sortBy": "lowestPrice" }
```

Prices in the filters are per night, in your currency. When too few properties match, Google fills its list with near matches outside your filters; they are left out unless you turn on **Include near matches**, and then come with `matchesFilters: false`. "Lowest price" is Google's own order: close to the nightly price, though not strictly.

#### Hotel price comparison across booking sites

```json
{ "locations": ["Toronto"], "checkIn": "2 weeks", "nights": 3, "maxResultsPerSearch": 10, "includeOffers": true }
```

Each property then comes with every booking site's price and room rate for the stay, cheapest first. This reads one more page per property, so it is charged separately and takes a little longer.

#### Specific hotels

```json
{ "hotels": ["Fairmont Royal York Toronto", "https://www.google.com/travel/hotels/entity/ChcIpP7F8OHV3Y5FGgsvZy8xdGdzMDdichAB"], "checkIn": "2026-12-18", "nights": 2, "currency": "CAD" }
```

One hotel per line: its Google Hotels link, the id in that link, or its name with the city. Each comes with everything Booking-site prices adds. Google resolves a name it knows to that hotel; a name it doesn't know is reported as not found rather than replaced by the first hotel in town. When **Specific hotels** is filled, **Locations** is ignored.

#### Price-drop alerts on a schedule

```json
{ "hotels": ["Fairmont Royal York Toronto", "Chelsea Hotel Toronto"], "checkIn": "2026-12-18", "nights": 2, "onlyChanges": true, "minPriceChangePercent": 3 }
```

Save this as a task and schedule it daily. The first run returns every stay, marked `new`, as the baseline. After that, each run returns only the stays whose price moved by at least **Minimum price change** (1% by default), marked `priceDrop` or `priceRise` with `previousPrice`, `priceChange` and `priceChangePercent`, plus stays that became priced again or stopped being priced. Unchanged stays aren't returned or charged. Connect the task to email, Slack or a webhook in its **Integrations** tab to receive each run's changes as a price alert.

It works for city searches too, for example the 100 best-rated hotels in a city on your dates: **Max results per search** then sets how many of Google's properties are watched. Google reshuffles its list from run to run, so a property that has only moved into the first 100 joins the watch list quietly; turn on **Also return properties new to the list** to get those too. Use a fixed check-in date, or several check-in dates, so that each run prices the same stays. The prices seen are kept in a key-value store named after the watch list; name it yourself under **History name** to share one history between tasks. Tasks with different guests, currency, stay length or filters keep their prices apart inside it, and tasks that run at the same time don't overwrite each other's.

#### Many check-in dates in one run

```json
{ "locations": ["New York"], "checkIn": "2026-12-01", "days": 30, "nights": 1, "maxResultsPerSearch": 20 }
```

Each check-in date is its own search, so this returns up to 20 properties for each of the 30 nights of December. Compare `pricePerNight` by `checkIn` to see when prices peak.

### Use it as a hotel prices API or from AI agents

Call it from your own code like any Apify Actor. This call waits for the run and returns the rows directly:

```bash
curl -X POST "https://api.apify.com/v2/acts/akhil_rajesh~google-hotels-scraper/run-sync-get-dataset-items" \
  -H "Authorization: Bearer YOUR_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{ "locations": ["Lisbon"], "checkIn": "3 weeks", "nights": 2, "currency": "EUR", "maxResultsPerSearch": 20 }'
```

Or from Python:

```python
from apify_client import ApifyClient  # pip install apify-client

client = ApifyClient("YOUR_API_TOKEN")
run = client.actor("akhil_rajesh/google-hotels-scraper").call(run_input={
    "locations": ["Lisbon", "Porto"], "checkIn": "3 weeks", "nights": 2, "currency": "EUR", "maxResultsPerSearch": 20,
})
for h in client.dataset(run.default_dataset_id).iterate_items():
    print(h["searchLocation"], h["name"], h["pricePerNight"], h["pricePerNightWithTaxes"], h["rating"], h["deal"])
```

Through the [Apify MCP server](https://mcp.apify.com), assistants such as Claude, ChatGPT and Cursor can run it as a tool. Add `https://mcp.apify.com?tools=akhil_rajesh/google-hotels-scraper` as an MCP server, then ask in plain words, for example *"find 4-star hotels in Rome under 200 euros for the first weekend of December, with free cancellation"* or *"which booking site is cheapest for the Chelsea Hotel in Toronto next Friday, and does its rate include breakfast?"*.

### Sample output

A hotel with booking-site prices (lists shortened):

```json
{
  "name": "Hyatt Regency Paris Étoile",
  "type": "hotel",
  "hotelClass": 4,
  "rating": 4.4,
  "reviewCount": 6432,
  "pricePerNight": 192.05,
  "pricePerNightWithTaxes": 228,
  "currency": "EUR",
  "checkIn": "2026-11-05",
  "checkOut": "2026-11-08",
  "nights": 3,
  "latitude": 48.8805064,
  "longitude": 2.284538,
  "amenities": ["Free Wi-Fi", "Wi-Fi in public areas", "Front desk (24 hour)", "Concierge", "Free fitness center", "Pet-friendly ($)"],
  "amenitiesByCategory": {"Internet": ["Free Wi-Fi", "Wi-Fi in public areas", "Public internet workstation"], "Pets": ["Pet-friendly ($)", "Dogs allowed", "Cats allowed"]},
  "languagesSpoken": ["Arabic", "English", "French", "Japanese", "Korean", "Mandarin", "Portuguese", "Spanish"],
  "checkInTime": "3:00 PM",
  "checkOutTime": "12:00 PM",
  "address": "3 Pl. du Général Kœnig, 75017 Paris, France",
  "phone": "+33 1 40 68 12 34",
  "offersCount": 23,
  "cheapestSite": "Vio.com",
  "offers": [
    {"site": "Vio.com", "isOfficialSite": false, "pricePerNight": 192.05, "pricePerNightWithTaxes": 227.5,
     "totalPrice": 576.14, "totalPriceWithTaxes": 682.51, "freeCancellation": null, "roomName": "Standard Room",
     "url": "https://www.google.com/travel/lodging/clk?..."}
  ],
  "rooms": [
    {"site": "Hotels.com", "roomName": "Deluxe Room, 1 King Bed", "pricePerNight": 304.35, "pricePerNightWithTaxes": 351.69,
     "totalPrice": 913.04, "totalPriceWithTaxes": 1055.06, "breakfastIncluded": true, "freeCancellation": true,
     "freeCancellationUntil": "2026-11-04", "url": "https://www.google.com/aclk?..."}
  ],
  "googleHotelsUrl": "https://www.google.com/travel/hotels/entity/ChcIpP7F8OHV3Y5FGgsvZy8xdGdzMDdichAB?...",
  "googleMapsUrl": "https://www.google.com/maps?cid=11087988900678711622"
}
```

A change returned by a run with **Only price changes** (other fields as above). This one is real: an 18-cent move between two Toronto runs a minute apart, the kind of jitter the default 1% **Minimum price change** leaves out:

```json
{ "name": "The Clarence Park", "changeType": "priceDrop", "previousPrice": 120.87, "pricePerNight": 120.69, "priceChange": -0.18, "priceChangePercent": -0.1, "currency": "CAD", "checkIn": "2026-10-19", "searchLocation": "Toronto" }
```

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

This Actor uses pay-per-event pricing, and platform usage is included, so there's nothing else to pay. You pay for each property returned, plus **$0.001** each time a run starts. A property that comes with every booking site's price and room rate (Booking-site prices on, or any hotel under Specific hotels) costs **$0.001** more, whatever your plan. The price per property depends on your Apify plan:

| Your plan | Per 1,000 properties | Per 1,000 with booking-site prices |
|---|---|---|
| Free | $0.80 | $1.80 |
| Starter | $0.75 | $1.75 |
| Scale | $0.60 | $1.60 |
| Business and above | $0.50 | $1.50 |

| Run | Properties | On Free | On Business |
|---|---|---|---|
| 20 hotels in Toronto (the default input) | 20 | $0.017 | $0.011 |
| 10 hotels with every booking site's price | 10 | $0.019 | $0.016 |
| 5 specific hotels | 5 | $0.010 | $0.009 |
| 20 hotels for each of 30 check-in dates | 600 | $0.481 | $0.301 |
| A daily price check of 100 hotels where 8 prices moved | 8 | $0.007 | $0.005 |

Properties your filters leave out, near matches you didn't ask for, and unchanged properties when **Only price changes** is on are not charged. When a hotel's page doesn't load, the property still comes with its list price and isn't charged the booking-site price. To cap spending, set **Max results per search** or a maximum cost per run in the run options; the Actor stops cleanly at the limit.

### Input

| Field | Default | What it does |
|---|---|---|
| `locations` | Toronto | Places or Google Hotels searches, one per line; up to 100 |
| `hotels` | none | Specific hotels instead: Google Hotels links, ids, or names with the city; up to 100 |
| `checkIn` | 14 days from today | `YYYY-MM-DD`, or a time from today such as `2 weeks` (UTC) |
| `nights` | 1 | 1 to 30; or give `checkOut` instead |
| `adults`, `childrenAges` | 2, none | Up to 12 adults; one age (0-17) per child |
| `currency` | USD | One of 35 currencies |
| `maxResultsPerSearch` | 20 | Most properties per place and check-in date, 1 to 1,000 |
| `sortBy` | relevance | `relevance`, `lowestPrice`, `highestRating` or `mostReviewed` |
| `minPrice`, `maxPrice` | none | Per night, in your currency |
| `hotelClass` | all | Any of `2`, `3`, `4`, `5` |
| `minRating` | any | `3.5`, `4.0` or `4.5` |
| `amenities` | none | Any of `freeWifi`, `freeBreakfast`, `freeParking`, `parking`, `pool`, `indoorPool`, `outdoorPool`, `hotTub`, `fitnessCenter`, `spa`, `restaurant`, `bar`, `roomService`, `airConditioned`, `kidFriendly`, `petFriendly`, `wheelchairAccessible`, `evCharger`, `beachAccess`, `allInclusive` |
| `propertyTypes` | all | Any of `bedAndBreakfasts`, `spaHotels`, `resorts`, `motels`, `inns`, `hostels`, `boutiqueHotels`, `beachHotels`, `other` |
| `freeCancellation`, `specialOffers`, `ecoCertified` | off | Google's offer filters |
| `includeNearMatches` | off | Also return Google's near matches outside your filters |
| `includeOffers` | off | Every booking site's price and room rate, review quotes, all amenities, address and phone for each property |
| `days` | 1 | Search this many check-in dates in a row, up to 60 |
| `onlyChanges` | off | Return only price changes since the last run of the same watch list |
| `minPriceChangePercent` | 1 | With `onlyChanges`: ignore smaller moves; 0 reports every move |
| `reportNewProperties` | off | With `onlyChanges`: also return properties new to a city search's list |
| `historyName` | automatic | With `onlyChanges`: the key-value store that keeps the prices seen |
| `country`, `language` | us, en | Google's country and language for the pages; prices stay in your currency. The amenities and deal badges on search results are read from English pages only |
| `proxy` | Apify Proxy | Apify's standard datacenter proxy, or your own proxies. Residential and other per-GB proxies aren't available: the result price covers datacenter traffic only |

### FAQ

**Are the prices per night or for the whole stay?** The main prices are per night, as Google shows them: before taxes and fees, and with them. Each booking site and room rate also gives its total for the whole stay, before and after taxes.

**Why do some properties have the same price with and without taxes?** Vacation rentals and some sites quote a price that already includes fees, so the two are the same.

**Why did a search say it "didn't load" when Google Hotels works in my browser?** Google now and then answers one session with an empty page, or with a page that shows every price with taxes already in and no price before taxes (about one session in seven on Apify's servers). The Actor asks again in a new session, which almost always gets the usual page. When all three tries come back that way, it reports the search as not loaded rather than returning prices that don't compare with the rest, and you aren't charged for it. Run it again later.

**Why is a hotel missing from my list?** Google shows what it ranks for your search, dates and guests, and a property that isn't bookable for those dates drops out. Raise **Max results per search**, loosen the filters, search the neighbourhood, or name the hotel under **Specific hotels**.

**How does price tracking know the last price?** Each watch list (the places or hotels, guests, currency, stay length and filters) keeps the prices it has seen in a key-value store in your account, and each run compares with it. A stay's history ends once its check-in date has passed. A run that is restarted on another server carries on without returning or charging a property twice.

**Why did a landmark search return hotels somewhere else?** Google Hotels reads some landmark names on their own as other places: "hotels near the Colosseum" came back as the whole United States, with Las Vegas hotels, and "hotels near Times Square" alone found nothing. Add the city ("hotels near the Colosseum, Rome"). Every row's `googlePlace` says where Google searched, and the run's status message points out a search Google read as somewhere else.

**Can I use another language?** Yes, with **Language** (hl): names and texts come translated and prices are read correctly in any language. The amenities and deal badges on the search results are read from English pages only; turn on **Booking-site prices** to get each hotel's full amenity list in any language.

**Why does "Lowest price" not come out strictly in order?** It is Google's own order, which is close to the nightly price but not exact. `position` keeps Google's order; sort the data yourself by `pricePerNight` if you need a strict order.

**How far ahead can I search?** Up to about 11 months, as far as Google Hotels prices stays.

**Does it need a login or an API key?** No. It reads the Google Hotels pages anyone can open.

**Can I get full reviews or room photos?** Ratings, the star histogram, review highlights and the review quotes Google shows are included. Full review texts and photo galleries aren't; ask in the Issues tab if you need them.

### Other Actors by this developer

- [Tennis API - Live Scores, Stats & Odds (ATP, WTA, ITF)](https://apify.com/akhil_rajesh/tennis-scraper): live scores, results, match statistics, point-by-point and bookmaker odds for ATP, WTA, Challenger and ITF
- [Canada Price Comparison - Amazon, Best Buy & Walmart](https://apify.com/akhil_rajesh/bot-wall-price-scraper): live price comparison across major Canadian retailers
- [AutoTrader Canada Scraper - Used Cars & Prices](https://apify.com/akhil_rajesh/autotrader-canada-scraper): Canadian vehicle listings with price, mileage, trim and dealer
- [Indeed Jobs Scraper - Canada, US, UK, Australia & More](https://apify.com/akhil_rajesh/indeed-jobs-scraper): job listings from Indeed in eight countries
- [SEEK, JobStreet & JobsDB Jobs Scraper](https://apify.com/akhil_rajesh/seek-jobstreet-jobsdb-scraper): jobs in Australia, New Zealand and six Asian markets
- [Wellfound (AngelList) Jobs Scraper - Salary & Equity](https://apify.com/akhil_rajesh/wellfound-jobs-scraper): startup jobs with salary and equity ranges
- [Job Bank Scraper - Canada Jobs, Salary & NOC Codes](https://apify.com/akhil_rajesh/canadian-jobs-scraper): Canada's Job Bank listings with wages and NOC codes

### Disclaimer

This Actor is an independent tool. It is not affiliated with, endorsed by or sponsored by Google or any booking site. It reads publicly available pages at a modest pace. Use the data in line with the sources' terms and the laws that apply to you.

# Changelog

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

# Actor input Schema

## `locations` (type: `array`):

Places to search, one per line: a city, a neighbourhood or any Google Hotels search such as "hotels near Times Square, New York" or "vacation rentals in Banff". Name the city with a landmark. A bare place like Toronto is searched as "hotels in Toronto". Ignored when Specific hotels is filled.

## `hotels` (type: `array`):

Instead of searching places, price these hotels, one per line: a Google Hotels link (google.com/travel/hotels/entity/...), its id, or the hotel's name with its city, such as "Fairmont Royal York Toronto". A name Google doesn't recognise is reported as not found rather than swapped for another hotel. Each hotel comes with everything Booking-site prices adds and is charged the same way.

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

A date (YYYY-MM-DD) or a time from today (UTC), such as "2 weeks". Empty means 14 days from today. Google Hotels prices stays up to about 11 months ahead.

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

Length of the stay. Prices are per night; each booking site's total for the whole stay comes with Booking-site prices.

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

Guests aged 18 or over.

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

One age (0 to 17) per child, such as 8 and 12. Leave empty for no children.

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

Prices come in this currency, whatever the place.

## `maxResultsPerSearch` (type: `integer`):

Most properties to return for each place and check-in date. Google lists 18 a page, in its own order unless you pick a sort below. This is also your cost ceiling: places x check-in dates x this number. With Only price changes, it is how many of Google's properties are watched; only the changed ones are returned.

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

Google's own orders. Relevance is the default list.

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

In the currency above. Leave empty or 0 for no minimum.

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

In the currency above. Leave empty or 0 for no maximum.

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

Star classes to keep. Leave empty for all. Vacation rentals and hostels have no class and drop out when you pick one.

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

Minimum Google guest rating.

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

Keep only properties with all of these.

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

Keep only these kinds of property. Leave empty for all.

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

Keep only properties with a free-cancellation rate.

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

Keep only properties with a special offer.

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

Keep only properties with an eco certification.

## `includeNearMatches` (type: `boolean`):

Also return the properties Google adds when too few match your filters. They come with matchesFilters false.

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

For each property, also read its own Google Hotels page: every booking site's price (Booking.com, Expedia, Hotels.com, Agoda, the hotel's own site and more) per night and in total, before and after taxes, with free cancellation; every room rate the sites list; review quotes; the full amenity list by category and languages spoken; and the address and phone. One more page per property, charged separately.

## `days` (type: `integer`):

Search this many check-in dates in a row, starting at the check-in date, to see how prices move (for example 30 for a month). Each date is a separate search with its own Max results.

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

For scheduled runs: return only what changed since the last run of the same watch list (the same places or hotels, guests, currency, stay length and filters): price drops and rises (with the previous price and the change), and stays that became priced again or stopped being priced. Unchanged properties aren't returned or charged. The first run of each search returns everything, marked new. Use a fixed check-in date (or several check-in dates) so that runs price the same stays.

## `minPriceChangePercent` (type: `integer`):

With Only price changes: ignore price moves smaller than this percentage. 1 by default, since prices can move by cents between checks with nothing really changed; 0 reports every move.

## `reportNewProperties` (type: `boolean`):

With Only price changes: after the first run, also return properties that weren't in the list before, marked new. Google reshuffles its list from run to run, so most of them have only moved into the first N; off, they join the watch list without being returned or charged. The first run of a search always returns everything, as the baseline.

## `historyName` (type: `string`):

With Only price changes: the name of the store that remembers the prices seen. Leave empty to get one per watch list automatically; name it to share one history between tasks. Tasks with different guests, currency, stay length or filters keep their prices apart inside it. Letters, digits and hyphens.

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

Instead of Nights: a check-out date (YYYY-MM-DD) or a time from today, such as "16 days".

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

Two-letter country code Google localises the page for (gl), such as us, gb or ca. It doesn't change the currency.

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

Language of names and texts Google translates (hl), such as en, fr or de. Prices are read in any language. The amenities and deal badges on search results are read from English pages only, so other languages leave them empty (booking-site prices bring each hotel's full amenity list in any language).

## `proxy` (type: `object`):

Apify's standard datacenter proxy by default. Each search keeps one address and one Google session.

## Actor input object example

```json
{
  "locations": [
    "Toronto"
  ],
  "checkIn": "2 weeks",
  "nights": 1,
  "adults": 2,
  "currency": "USD",
  "maxResultsPerSearch": 20,
  "sortBy": "relevance",
  "minRating": "any",
  "freeCancellation": false,
  "specialOffers": false,
  "ecoCertified": false,
  "includeNearMatches": false,
  "includeOffers": false,
  "days": 1,
  "onlyChanges": false,
  "minPriceChangePercent": 1,
  "reportNewProperties": false,
  "country": "us",
  "language": "en",
  "proxy": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `properties` (type: `string`):

No description

## `priceChanges` (type: `string`):

No description

## `bookingSites` (type: `string`):

No description

## `rooms` (type: `string`):

No description

## `location` (type: `string`):

No description

## `allData` (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 = {
    "locations": [
        "Toronto"
    ],
    "checkIn": "2 weeks",
    "maxResultsPerSearch": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("akhil_rajesh/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 = {
    "locations": ["Toronto"],
    "checkIn": "2 weeks",
    "maxResultsPerSearch": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("akhil_rajesh/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 '{
  "locations": [
    "Toronto"
  ],
  "checkIn": "2 weeks",
  "maxResultsPerSearch": 20
}' |
apify call akhil_rajesh/google-hotels-scraper --silent --output-dataset

```

## MCP server setup

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