# Google Hotels Scraper — Prices, OTA Rates & Price Calendar (`lergassy/google-hotels-scraper`) Actor

Google Hotels scraper and API: nightly rate, stay total and taxes for your dates, OTA rates from Booking.com, Agoda, Expedia with links, a 60-day price calendar with the cheapest day to book, family pricing with children, ratings, reviews. No login. JSON, CSV, Excel.

- **URL**: https://apify.com/lergassy/google-hotels-scraper.md
- **Developed by:** [Matvey](https://apify.com/lergassy) (community)
- **Categories:** Travel, E-commerce, Automation
- **Features:** Limited permissions
- **Stats:** 53 total users, 30 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $2.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.
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** is a **Google Hotels API** alternative for **hotel prices** on any dates: it extracts hotels from **Google Hotels** for any place — the **nightly price, the stay total and the total with taxes and fees**, the guest **rating and review count**, star class, property type, **amenities**, coordinates, photos, check-in and check-out times, the Google Hotels page and the **booking link**. Turn on **OTA rates** and each hotel also gets **the price on every booking site Google lists — Agoda, Expedia, Trip.com, Priceline, Hotels.com, the hotel's own website and more — for your dates**, with deep links, plus its full address and phone and the **guest reviews** Google aggregates. Google shows 20 hotels and stops; this Actor walks Google's own sort orders, star classes and price bands and de-duplicates by hotel, so one search for a city returns **well over a hundred properties** instead of twenty. **Pure HTTP, no browser, no login, no API key** — a search of 150 hotels takes about 17 seconds, and 15 hotels with OTA rates for all 15 about 20 seconds ($0.165 on the free plan). New in November 2026: a **price calendar** that reprices the same stay for **every check-in day up to 60 days ahead** and names the **cheapest day to book** and the cheapest booking site for each day, and **family pricing** with children and their ages.

![Google Hotels Scraper output: hotels with star class, rating, review count, nightly price, stay total and amenities](https://raw.githubusercontent.com/lergassy/apify-actor-assets/main/google-hotels-scraper/google-hotels-scraper-output-table.png)

Paste a city, pick dates, click Start, and download JSON, CSV or Excel — or pull the rows through the Apify API into Google Sheets, n8n, Make, Zapier, a database or an AI agent.

### Tested head-to-head — 14 November 2026

![Google Hotels Scraper vs the Rising Star Google Hotels Actor: run time, columns, booking links, taxes and price on the same input](https://api.apify.com/v2/key-value-stores/EYYgSSpOuVAWXdsdK/records/google-hotels-tested-2026-11-14.png)

Same input for both Actors, same day, run from an ordinary Apify account (not the developer's): 20 hotels in
Paris, France for 10–12 December 2026, 2 adults, OTA rates on — and one hotel by link with a 7-day price calendar.

| | This Actor | Rival (Apify "Rising Star" pick) |
|---|---|---|
| Run time, 20 hotels with OTA rates | **9 s** | 38 s |
| Columns per hotel | **59** | 27 |
| Booking-site offers that carry a link to book | **288 of 288 (100%)** | 167 of 528 (32%) |
| Booking sites per hotel (11 hotels both returned) | about the same (±2) | about the same |
| Taxes and fees as separate numbers | **20 of 20 hotels** | 0 of 20 |
| Address, phone and amenity list | **15 of 20 hotels** | 0 of 20 |
| Hotel by link: name, rating, star class | **filled** | name "Hotel", rating and stars empty |
| Price calendar, 7 days, one hotel | **$0.029** | $0.039 |
| Hotel row without add-ons | **$0.003** | $0.004 |
| 20 hotels with OTA rates for every hotel | $0.22 | **$0.18** |

Where the rival is ahead: OTA rates for every hotel cost a little less there, it lists each room type as a separate
offer row (here room names sit inside each offer's `rooms`), and it reads the full Google review feed — this Actor
returns the review summary, rating histogram, review topics and the review sources instead (see "Limits, honestly").
Prices are FREE-tier list prices; the calendar add-on is billed from 28 November 2026 and is free until then.

### What is Google Hotels Scraper?

Google Hotels is the price comparison inside Google Travel: for a place and a stay it lists the properties, the cheapest rate it found across Booking.com, Expedia, Agoda, Hotels.com, Trip.com, the hotel's own site and dozens of smaller sellers, the aggregate guest rating, and the amenities. There is no official **Google Hotels API**. This Actor is the **Google Hotels API alternative**: it reads the same JSON endpoint the Google Hotels page itself calls — for the hotel list and, with OTA rates on, for each hotel's prices panel — and turns them into flat rows you can sort, filter and join.

It answers the questions a revenue manager, an OTA analyst or a travel-data team actually asks:

- What does every hotel in Lisbon cost for the first weekend of October, and how does that compare with last month?
- Which 4- and 5-star properties in Ubud are rated 4.5 or better, and what is the cheapest nightly rate among them?
- Which booking sites sell a given hotel, at what total, and where is the official site's price against Booking.com?
- What do guests praise and complain about — service, location, dining, cleanliness — and how many say so?

Three modes, one row shape:

| Mode | You give | You get |
|---|---|---|
| **Search** | places, check-in, check-out, guests | hotels with price for that stay, rating, reviews, class, amenities, location, photos, booking link |
| **Search + OTA rates** (add-on, on in the form) | the same, with *OTA rates* on | everything above plus every booking site's price for your dates with a deep link, the number of booking sites, the official-site price, address and phone, review scores per source, guest reviews |
| **Hotel pages** | Google Hotels URLs or entity ids | one row per hotel with offers, reviews and full details — no search |

### What data can Google Hotels Scraper extract?

Every hotel row carries these fields. Nothing is invented: a field Google did not show for a property is empty rather than guessed.

| Field | Example | Notes |
|---|---|---|
| `name` | Alaya Resort Ubud | |
| `hotelClass`, `hotelClassLabel` | 5, "5-star hotel" | empty for unrated properties |
| `propertyType` | resort hotel | hotel, villa, bed and breakfast, hostel, apartment, guest house … |
| `rating`, `reviewCount` | 4.7, 4006 | Google's aggregate, 5-point scale |
| `pricePerNight`, `pricePerNightDisplay` | 340.29, "$340" | the cheapest rate Google found for the searched stay, averaged per night, as Google displays it — **before taxes** (fees are already in); the all-in figure is `totalWithTaxes` |
| `totalPrice`, `totalPriceDisplay` | 680.59, "$681" | the whole stay, exactly as Google prints it — **equal to `priceBeforeTaxes` + `fees`, with `taxes` left outside**; checked on 755 rows, 755 of 755 (21 Oct 2026) |
| `priceBeforeTaxes`, `taxesAndFees` | 562.45, 118.13 | when Google itemises them (whole stay) |
| `taxes`, `fees`, `totalWithTaxes` | 118.13, 0, 680.58 | the same itemisation split out, and the all-in stay total. **`totalWithTaxes` − `totalPrice` = `taxes`** in all 755 rows measured; across Ubud, Barcelona, Bangkok, Singapore, Tokyo, Paris and Lisbon that gap ran from 9.1% to 17.6% of the all-in total by city median |
| `currency` | USD | any code Google supports |
| `checkIn`, `checkOut`, `nights`, `adults` | 2026-10-10, 2026-10-12, 2, 2 | what the price was quoted for |
| `description` | Polished rooms in a chic getaway offering a spa… | Google's one-line summary |
| `address`, `phone`, `website` | Jl. Hanoman, Ubud…, +62 361 972200, alayahotels.com | on every hotel row; when Google's search answer leaves address and phone out, they are completed from the hotel's own record at no extra charge (vacation rentals have none) |
| `country`, `latitude`, `longitude` | ID, -8.5188, 115.2635 | |
| `checkInTime`, `checkOutTime` | 3:00 PM, 12:00 PM | |
| `amenities`, `amenityIds` | \["Free Wi-Fi", "Outdoor pool", "Spa"], \[29, 22, 26] | names for the ids Google uses; the OTA-rates add-on merges in the hotel record's grouped amenity ids |
| `ratingHistogram` | {stars5: 3272, stars4: 518, …} | review counts per star |
| `reviewTopics` | Service 705 mentions, 667 positive, 28 negative | what guests write about |
| `nearbyPlaces` | Sacred Monkey Forest Sanctuary, 7 min | landmarks, transport, airport with travel time |
| `thumbnail`, `photos` | image URLs | |
| `entityId`, `placeId`, `googleMapsUrl`, `hotelUrl`, `bookingUrl` | ChgI…, 0x2dd2…, google.com/maps?cid=…, google.com/travel/hotels/entity/…, google.com/travel/clk/… | the booking link goes to the cheapest seller for the searched stay |
| `location`, `searchRank` | Ubud, Bali, 1 | the place you searched and the row's position |
| `offers[]` | Agoda $236, Trip.com $237, official site $405 … | OTA-rates add-on: seller, stay total, per night, dates quoted (your dates), deep link, official-site flag; `rooms[]` (room name, per-night price) for the sellers Google features |
| `vendorCount`, `officialSiteTotal`, `offersForSearchedDates` | 19, 405, true | how many booking sites list a price, the hotel's own website total, and whether the offers are for your dates |
| `cheapestOfferSeller`, `cheapestOfferTotal`, `cheapestOfferPerNight` | Agoda, 236, 118 | the lowest of the offers |
| `reviewSources[]` | Tripadvisor 4.8 (1,490), Trip.com 4.7 (104) | rating and count per source Google aggregates |
| `reviews[]` | source, author, date, rating, text, link | the review snippets Google attaches to the hotel — usually one per source, 1–3 per hotel |

### Beyond Google's 20 results

Google Hotels returns 20 properties per request, and its "next page" is the same request with a different filter — there is no offset to walk. Other scrapers stop at those 20, or page blindly and return the same hotels again.

This Actor reads the way Google itself lets you explore: it asks for the same place sorted by relevance, by lowest price, by highest rating and by most reviewed, then per star class, then under a few price caps, and keeps every hotel once. Measured on Ubud, Bali on 14 September 2026: **197 distinct hotels from 15 requests**, against 20 from the first request. Set **Hotels per place** to what you need; the walk stops when the count is reached or when four facets in a row bring nothing new, so a small town does not burn requests looking for hotels it does not have.

The price on each row is still Google's own cheapest rate for your dates — the facet walk only changes which hotels come back, never what Google says they cost.

### Price calendar: the cheapest night to book

A hotel price is only true for one pair of dates. Move check-in by a day and the nightly rate can drop by a third — or the room is gone. Revenue managers, travel-deal sites and anyone planning a trip ask the same question: **which check-in day is cheapest for this stay?** Answering it by hand means one Google Hotels search per day.

Set **`priceCalendarTo`** to a date and the Actor prices the **same-length stay for every check-in day** from your check-in up to that date — 60 days at most — for each hotel:

- `priceCalendar` — one entry per check-in day: `checkIn`, `checkOut`, `pricePerNight`, `totalPrice`, `cheapestSeller`, `cheapestTotal`, `vendorCount`, `available`;
- `calendarCheapestCheckIn` and `calendarCheapestPerNight` — the day to book and its price;
- `calendarHighestCheckIn`, `calendarHighestPerNight` and `calendarAveragePerNight` — how wide the swing is;
- `calendarDatesPriced` — how many extra days came back with a price.

Each day is Google's own dated price, the same figure the hotel row carries for your dates, read from the same request that powers the OTA rates. A day the hotel is sold out comes back as `available: false` with empty prices and is **not charged**. The day you searched is copied from the hotel row and is never asked again.

Hotels you list under **Specific hotels** (`hotelUrls`) always get the calendar. For a location search, **`maxCalendarHotels`** (default 10) decides how many of the results get it, in result order, so a 200-hotel city with a 60-day calendar does not price 12,000 days by accident.

A real run, 13 November 2026, Ubud, two nights from 10 December, 2 adults + 1 child aged 8 (local test, prices as Google quoted them):

```json
{
  "name": "Puji Bungalows & Hostel",
  "pricePerNight": 13.32,
  "checkIn": "2026-12-10",
  "checkOut": "2026-12-12",
  "children": 1,
  "childrenAges": [8],
  "calendarCheapestCheckIn": "2026-12-10",
  "calendarCheapestPerNight": 13.32,
  "calendarHighestPerNight": 14.94,
  "calendarAveragePerNight": 14.58,
  "calendarDatesPriced": 4,
  "priceCalendar": [
    { "checkIn": "2026-12-10", "checkOut": "2026-12-12", "pricePerNight": 13.32, "totalPrice": 27, "cheapestSeller": "Booking.com", "cheapestTotal": 27, "vendorCount": 2, "available": true },
    { "checkIn": "2026-12-11", "checkOut": "2026-12-13", "pricePerNight": null, "totalPrice": null, "cheapestSeller": null, "cheapestTotal": null, "vendorCount": null, "available": false },
    { "checkIn": "2026-12-13", "checkOut": "2026-12-15", "pricePerNight": 14.88, "totalPrice": 30, "cheapestSeller": "Hostelworld", "cheapestTotal": 30, "vendorCount": 1, "available": true }
  ]
}
```

The dataset has its own **Price calendar** view: one line per hotel and day, ready to sort by price or to chart in a spreadsheet.

### Family stays: children and their ages

Google prices a room for the people in it. Two adults and a child are not two adults: at Element by Marriott Bali Ubud, 10–12 December 2026, Google quoted **$76 a night for 2 adults and $128 a night for 2 adults + a child of 8** (measured 13 November 2026). Set **`children`** (0–6) and, if you know them, **`childrenAges`** — one age per child; a child without an age is priced as 8. Every price in the run — the hotel row, the OTA rates and the price calendar — is then for that family, and the row carries `children` and `childrenAges` so you can tell family and adult-only runs apart in one dataset. Some hotels have no room for the party you ask for; they come back without a price rather than with an adult-only one.

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

The Actor is priced **per hotel row**, with an add-on per hotel priced on every booking site (OTA rates). There is **no start fee**, and rows that failed or came back empty are never charged.

| Event | Price | What it buys |
|---|---|---|
| Hotel | **$3.00 per 1,000** | one hotel with price, rating, class, amenities, location, photos, booking link |
| OTA rates (add-on, event "Hotel page read") | **$8.00 per 1,000** | that hotel's price on every booking site for your dates, with deep links, booking-site count, official-site total, address, phone, review sources, guest reviews |
| Price calendar (add-on, event "Calendar day priced") | **$3.00 per 1,000 days** | one extra check-in day priced for one hotel: lead price, stay total, cheapest booking site; sold-out days are free |

**Worked example — the cheapest week to book.** 10 hotels you track, a 30-day calendar, OTA rates on: 10 hotel rows ($0.03) + 10 OTA lookups ($0.08) + at most 290 extra days (10 × 29, the searched day is not charged) ($0.87) = **$0.98 on the free plan**, about $0.69 on Gold. Days a hotel is sold out cost nothing, so the real bill is usually lower.

Two hundred hotels for a city cost $0.60. OTA rates for the fifty you shortlist add $0.40. The form has OTA rates **on** for the first 20 hotels; an API call without `includeOffers` gets hotel rows only. There is no residential proxy and no browser to pay for: the Actor's own platform usage is a fraction of a cent per run. Bronze, Silver and Gold plans get 10 %, 20 % and 30 % off.

The **free plan** includes $5 of usage every month — about 1,600 hotel rows, or a full city every day of the month.

#### Bulk export: what 50,000 hotel records actually cost

This Actor is built for bulk jobs — put hundreds of inputs into one run, or call it from the API on
a schedule. There is **no fee per run, no fee per page and no proxy charge**: you pay for the rows
you keep, and error rows are free. That is what decides the bill once you pull a whole market
rather than a single property.

| Job | This Actor | Most-used Actor in this category |
|---|---|---|
| 50,000 hotel records across 100 runs | **$150** | $249.50 |

Checked on the Apify Store on 21 September 2026 against the Actor with the most monthly users in
this category; its per-run fee is counted in, as ours would be if we charged one. Some Actors here
ask less per row — this table compares against the one buyers actually use most.

### Switching from another Google Hotels Actor

Measured on 5 October 2026 from Apify's own public Store data. The comparison is with the most-used Google Hotels Actor on the Store; it is not named here on purpose — the numbers are public and checkable, the name adds nothing.

| | The most-used Google Hotels Actor | This Actor |
|---|---|---|
| Price per 1,000 hotels, free plan | $4.99 | **$3.00** |
| Price per 1,000 hotels, Gold plan | $2.99 | **$2.10** |
| Start fee | none | none |
| Runs in the last 30 days that ended SUCCEEDED | **32%** of 49,296 | 97% of 63 |

Read that last row honestly in both directions: their 32% is a large sample and includes runs that failed because of the caller's own input, and our 97% is 63 runs — a sample, not a promise. On the same day we ran both on the same request (Lisbon, 10–12 November 2026, 2 adults, 5 hotels). Both returned 5 hotels with prices. Ours took 5 seconds and cost $0.015; the other took 8 seconds and cost $0.025.

#### Input mapping

| Common field elsewhere | This Actor | Note |
|---|---|---|
| `searchQuery`, `locations` | `locations` | one place per line |
| `checkInDate` / `checkOutDate` | `checkIn` / `checkOut` | `YYYY-MM-DD`; leave empty and we search 30 days ahead |
| `adults` | `adults` | |
| `maxItems`, `maxResults` | `maxHotelsPerLocation` | ours goes past Google's 20-per-page limit |
| `currency` | `currency` | |
| `languageCode` | `language` | |
| `countryCode` | `market` | |
| `includeBookingSources`, `includeOtaRates` | `includeOffers` | billed as a separate "hotel page read" event |

#### Output mapping

| Common field elsewhere | This Actor |
|---|---|
| `hotelName`, `name` | `name` |
| `price`, `priceValue` | `pricePerNight` / `pricePerNightDisplay` |
| `totalRate` | `totalPrice` |
| `rating` | `rating` |
| `reviewCount` | `reviewCount` |
| `hotelClass` ("5-star hotel"), `starRating` (5) | `hotelClassLabel` / `hotelClass` |
| `latitude` / `longitude` | `latitude` / `longitude` |
| `placeId` | `placeId` |
| `googleMapsUrl` | `googleMapsUrl` |
| `hotelDescription` | `description` |
| `imageUrl` | `thumbnail` (and `photos` for the rest) |
| `googleHotelsUrl` | `hotelUrl` |
| `checkInDate` / `checkOutDate` | `checkIn` / `checkOut` |
| `bookingSources[]`, `vendors[]` | `offers[]` (with `includeOffers` on) |
| `vendorCount` | `vendorCount` |
| `leadPrice`, `leadPriceTotal` | `cheapestOfferPerNight`, `cheapestOfferTotal` (and `pricePerNight` / `totalPrice` from search) |

One caveat worth a minute of your time: other Actors differ on whether their numeric price field means **per night** or **the whole stay**. Ours is explicit — `pricePerNight` and `totalPrice` are separate columns. Check one row against the hotel's page before you rewire a pipeline on the assumption.

#### Feature by feature (November 2026)

Checked on 13 November 2026 against the input schema, field list and event prices that the fastest-growing newer Google Hotels Actor publishes on the Store. Where it does something we do not, the row says so.

| | This Actor | Fastest-growing newer Google Hotels Actor |
|---|---|---|
| Hotel row, free plan / Gold | **$3.00 / $2.10 per 1,000** | $4.00 / $3.20 per 1,000 |
| Hotels per city | walk over sort orders, star classes and price bands — **197 for Ubud** | paginated search |
| Price with **taxes and fees itemised** (`taxes`, `fees`, `totalWithTaxes`) | **yes** | headline price |
| OTA rates for your dates, with deep links | yes, $8 per 1,000 hotels | yes, about $5 per 1,000 hotels |
| Price calendar, up to 60 check-in days | **$3 per 1,000 days, sold-out days free** | about $5 per 1,000 days |
| Cheapest day to book, highest day, average on the row | **yes** | no |
| Children with ages | yes | yes (count) |
| Several rooms in one search | no | yes |
| Full paginated Google review history | no — review snippets per source | yes, paid per review |
| Review topics with positive/negative mentions, rating histogram, nearby places | **yes, free** | no |
| Address, phone, website, amenities, photos, description, check-in/out times | **yes** | not in its published field list |
| Markdown card per hotel for RAG | yes | yes |

### How to scrape Google Hotels

1. Open the Actor and type the **place** the way you would in Google Hotels: a city, a district, a landmark. One per line for several.
2. Set **check-in and check-out**. Leave them empty for a two-night stay 30 days out — the Actor never searches a date that has passed, even from a saved task.
3. Pick the **currency** and how many **hotels per place** you want. Twenty is one Google page; a hundred or more is what Google would never show you at once.
4. Optionally filter — **star class**, **minimum rating**, **maximum price per night**, **pool** — and keep **OTA rates** on to get every booking site's price for your dates and the guest reviews.
5. Click **Start**. Results appear in the dataset as the run goes; export them as JSON, CSV or Excel, or read them through the API.

### ⬇️ Input

![Google Hotels Scraper input form: place, check-in and check-out dates, adults, hotels per place, currency and filters](https://raw.githubusercontent.com/lergassy/apify-actor-assets/main/google-hotels-scraper/google-hotels-scraper-input-form.png)

#### Hotels for a city and dates

```json
{
  "locations": ["Ubud, Bali"],
  "checkIn": "2026-12-12",
  "checkOut": "2026-12-14",
  "adults": 2,
  "currency": "USD",
  "maxHotelsPerLocation": 100
}
```

#### Shortlist with filters

```json
{
  "locations": ["Lisbon", "Porto"],
  "checkIn": "2026-11-06",
  "checkOut": "2026-11-08",
  "hotelClass": ["4", "5"],
  "minRating": "4.5",
  "maxPricePerNight": 250,
  "sortBy": "lowest_price",
  "maxHotelsPerLocation": 60
}
```

Filters are sent to Google where it supports them and checked again on every row, so a 3-star property cannot slip into a 4–5-star shortlist through a ranking quirk.

#### OTA rates: every booking site's price, plus reviews

```json
{
  "locations": ["Shibuya, Tokyo"],
  "checkIn": "2026-12-20",
  "checkOut": "2026-12-23",
  "maxHotelsPerLocation": 30,
  "includeOffers": true,
  "maxOfferLookups": 30,
  "includeReviews": true,
  "maxReviews": 10
}
```

#### Hotel pages by URL

```json
{
  "hotelUrls": [
    "https://www.google.com/travel/hotels/entity/ChgI56yqtNfw86kxGgwvZy8xMXpicXFianMQAQ",
    "ChkIjJ2ht8Gcu_h5Gg0vZy8xMWM1cnRwc3lmEAE"
  ],
  "includeReviews": true
}
```

Entity ids come from an earlier run's `entityId` column, so a daily price monitor for a fixed set of hotels needs no search at all.

#### Every input field

| Field | Default | Meaning |
|---|---|---|
| `locations` | `["Ubud, Bali"]` | places to search, one per line |
| `checkIn`, `checkOut` | 30 days out, 2 nights | `YYYY-MM-DD` |
| `adults` | 2 | guests in one room, 1–8 |
| `children` | 0 | children in the same room, 0–6 |
| `childrenAges` | 8 each | one age (0–17) per child |
| `maxHotelsPerLocation` | 40 | how deep to go per place, up to 500 |
| `currency` | USD | any ISO code |
| `sortBy` | relevance | `relevance`, `lowest_price`, `highest_rating`, `most_reviewed` — the order of the rows you get (`searchRank` follows it); hotels without a price or rating go last |
| `hotelClass` | any | keep only these star classes |
| `minRating` | any | 3.5, 4 or 4.5 |
| `maxPricePerNight` | none | in the output currency |
| `poolOnly` | false | only hotels with a pool |
| `includeOffers` | false (on in the form) | OTA rates: every booking site's price for your dates, booking-site count, official-site total, address, phone, review sources ($) |
| `maxOfferLookups` | 20 | how many hotels per run get OTA rates |
| `priceCalendarTo` | — | reprice the same stay for every check-in day up to this date, 60 days at most ($) |
| `maxCalendarHotels` | 10 | how many search results get the calendar (named hotels always do) |
| `minPricePerNight` | none | drop hotels cheaper than this per night, in the output currency |
| `includeReviews` | false | include guest review snippets (needs `includeOffers` or `hotelUrls`) |
| `maxReviews` | 10 | per hotel |
| `hotelUrls` | — | Google Hotels URLs or entity ids to read directly |
| `language`, `market` | en, us | language of labels; country Google prices for |
| `proxyConfiguration` | Apify datacenter | residential only if a run reports consent pages |

### ⬆️ Output

One row per hotel. Error rows carry `type: "error"` and an explanation, and are never charged.

```json
{
  "type": "hotel",
  "name": "Alaya Resort Ubud",
  "hotelClass": 5,
  "hotelClassLabel": "5-star hotel",
  "propertyType": "resort hotel",
  "rating": 4.7,
  "reviewCount": 4006,
  "pricePerNight": 340.29,
  "pricePerNightDisplay": "$340",
  "totalPrice": 680.59,
  "totalPriceDisplay": "$681",
  "priceBeforeTaxes": 562.45,
  "taxesAndFees": 118.13,
  "currency": "USD",
  "checkIn": "2026-12-12",
  "checkOut": "2026-12-14",
  "nights": 2,
  "adults": 2,
  "description": "Polished rooms in a chic getaway offering a spa, a low-key bar & a bright restaurant.",
  "website": "https://alayahotels.com/alaya-resort-ubud/",
  "country": "ID",
  "latitude": -8.5187697,
  "longitude": 115.263528,
  "checkInTime": "3:00 PM",
  "checkOutTime": "12:00 PM",
  "amenities": ["Air conditioning", "Bar", "Free breakfast", "Fitness center", "Free parking", "Pet-friendly", "Outdoor pool", "Restaurant", "Spa", "Free Wi-Fi"],
  "amenityIds": [2, 4, 6, 8, 16, 18, 22, 23, 26, 29],
  "ratingHistogram": { "stars5": 3272, "stars4": 518, "stars3": 114, "stars2": 42, "stars1": 60 },
  "reviewTopics": [
    { "topic": "Service", "mentions": 705, "positive": 667, "negative": 28, "score": 0.81 },
    { "topic": "Location", "mentions": 423, "positive": 384, "negative": 11, "score": 0.74 }
  ],
  "nearbyPlaces": [
    { "name": "Sacred Monkey Forest Sanctuary", "travelTime": "7 min" },
    { "name": "I Gusti Ngurah Rai International Airport", "travelTime": "1 hr 8 min" }
  ],
  "thumbnail": "https://lh3.googleusercontent.com/…",
  "photos": ["https://lh3.googleusercontent.com/…"],
  "entityId": "ChgI56yqtNfw86kxGgwvZy8xMXpicXFianMQAQ",
  "placeId": "0x2dd23d6c35a395c7:0x3153cf85768a9667",
  "googleMapsUrl": "https://www.google.com/maps?cid=3554412703051847271",
  "hotelUrl": "https://www.google.com/travel/hotels/entity/ChgI56yqtNfw86kxGgwvZy8xMXpicXFianMQAQ",
  "bookingUrl": "https://www.google.com/travel/clk/hi?qid=…",
  "location": "Ubud, Bali",
  "searchRank": 1,
  "scrapedAt": "2026-09-14T13:14:01.199Z"
}
```

#### With OTA rates on

```json
{
  "address": "Jl. Raya Sanggingan, Ubud, Kecamatan Ubud, Kabupaten Gianyar, Bali 80571, Indonesia",
  "phone": "+62 361 974330",
  "offers": [
    { "seller": "Agoda", "totalPrice": 236, "totalPriceDisplay": "US$236", "pricePerNight": 118, "pricePerNightDisplay": "US$118", "checkIn": "2026-11-20", "checkOut": "2026-11-22", "nights": 2, "bookingUrl": "https://www.agoda.com/partners/partnersearch.aspx?…", "isOfficialSite": false,
      "rooms": [ { "roomName": "The Valley Suite", "pricePerNight": 126.23, "pricePerNightDisplay": "$126" }, { "roomName": "Garden Villa", "pricePerNight": 162.87, "pricePerNightDisplay": "$163" } ] },
    { "seller": "Pita Maha Resort & Spa", "totalPrice": 405, "totalPriceDisplay": "US$405", "pricePerNight": 203, "pricePerNightDisplay": "US$203", "checkIn": "2026-11-20", "checkOut": "2026-11-22", "nights": 2, "bookingUrl": "https://pitamaha.reserveonline.id/book/359?…", "isOfficialSite": true }
  ],
  "vendorCount": 19,
  "offersCheckIn": "2026-11-20",
  "offersCheckOut": "2026-11-22",
  "offersForSearchedDates": true,
  "cheapestOfferSeller": "Agoda",
  "cheapestOfferTotal": 236,
  "cheapestOfferPerNight": 118,
  "officialSiteTotal": 405,
  "reviewSources": [
    { "source": "Tripadvisor", "rating": 4.8, "ratingScale": 5, "reviewCount": 1490 },
    { "source": "Trip.com", "rating": 4.7, "ratingScale": 5, "reviewCount": 104 }
  ],
  "reviews": [
    { "source": "Tripadvisor", "author": "N8293ABtammyh", "date": "2 weeks ago", "rating": 5, "ratingScale": 5, "text": "We had an absolutely wonderful stay…", "url": "https://www.tripadvisor.com/…" }
  ],
  "detailsFetched": true
}
```

OTA rates are quoted for **your** check-in, check-out, guests and currency — the same answer the Google Hotels prices panel shows when you open a hotel from a search (`offersForSearchedDates: true`). Prices are Google's displayed figures, rounded to the whole currency unit, before taxes like the headline price. The `rooms` list appears only for the few sellers Google features with room names; its per-night figures can sit on another rate plan than the seller's headline price, so they are reported next to it. If Google's dated answer fails for a hotel, the Actor falls back to the hotel page, whose prices are for Google's default stay — the row then says so (`offersForSearchedDates: false`, with `offersCheckIn` / `offersCheckOut`).

The dataset has three table views: **Hotels**, **Booking sites (OTA rates)** (one line per seller) and **Guest reviews** (one line per review).

### Use cases for Google Hotels data

#### Rate shopping and revenue management

Run the same city every morning and diff `pricePerNight` per `entityId`: who dropped, who raised, where you sit against the compset for the next weekend. The facet walk means the compset is the whole market, not the twenty hotels Google felt like showing.

#### OTA and metasearch analysis

With OTA rates on, `offers` tells you which sellers list a property and at what total for your dates. Count how often the official site is the cheapest, which OTAs undercut whom, and where a hotel is missing from a channel entirely.

#### Market research and site selection

Class, price band, rating and amenity mix for every property in a district, with coordinates for a map. Compare Shibuya with Shinjuku, or Ubud with Seminyak, in one run.

#### Guest-experience research

`reviewTopics` gives you what guests talk about and how it splits positive against negative, for every hotel in a city, without reading a review. `reviews` gives you the text when you do want to read.

#### Travel products and AI agents

Flat rows with a stable `entityId`, a booking link and a per-night price are what a trip planner, a price-alert bot or an agent answering "find me a 4-star under $150 near the station" needs. The Actor runs from the Apify API and through the Apify MCP server.

### Integrations

- **API**: start a run with `POST https://api.apify.com/v2/acts/lergassy~google-hotels-scraper/runs?token=…` and read `…/datasets/{id}/items?format=csv`.
- **Clients**: `apify-client` for Python and JavaScript wrap the same calls.
- **Google Sheets, n8n, Make, Zapier**: use the Apify integration; the flat row shape needs no transformation.
- **Webhooks**: fire on run finish to pull the dataset into your own system.
- **MCP**: the Actor is callable as a tool through the Apify MCP server, so an AI agent can search hotels and read prices in a conversation.
- **Schedules**: a daily task with a fixed `hotelUrls` list is a price monitor for your own properties and competitors.

```python
from apify_client import ApifyClient

client = ApifyClient("<APIFY_TOKEN>")
run = client.actor("lergassy/google-hotels-scraper").call(run_input={
    "locations": ["Lisbon"], "checkIn": "2026-11-06", "checkOut": "2026-11-08",
    "hotelClass": ["4", "5"], "maxHotelsPerLocation": 100,
})
for hotel in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(hotel["name"], hotel["pricePerNight"], hotel["rating"])
```

### 🤖 For AI agents and LLM apps

Inputs that matter: `locations` (list of place strings), `checkIn` and `checkOut` (`YYYY-MM-DD`), `maxHotelsPerLocation` (integer), `currency` (ISO code), optional `hotelClass` (list of "1"–"5"), `minRating` ("3.5" | "4" | "4.5"), `maxPricePerNight` (number), `includeOffers` (boolean, OTA rates; one extra paid lookup per hotel, default false), `hotelUrls` (list of Google Hotels URLs or entity ids), `children` (integer) and `childrenAges` (list), `minPricePerNight` (number), `priceCalendarTo` (`YYYY-MM-DD`, paid per extra day) and `maxCalendarHotels` (integer).

Every hotel row also carries **`markdownContent`** — a ready Markdown card (class, rating, price with and without taxes, cheapest booking site, cheapest calendar day, address, amenities, description, link) you can drop straight into a vector store or an LLM prompt. It is free and built from the row itself.

Output: one JSON object per hotel with `name`, `hotelClass`, `rating`, `reviewCount`, `pricePerNight`, `totalPrice`, `currency`, `checkIn`, `checkOut`, `amenities`, `latitude`, `longitude`, `address`, `hotelUrl`, `bookingUrl`, `entityId`; with `includeOffers`, also `offers[]` (`seller`, `totalPrice`, `pricePerNight`, `checkIn`, `checkOut`, `bookingUrl`, `isOfficialSite`), `vendorCount`, `cheapestOfferSeller`, `officialSiteTotal`, `reviewSources[]` and `reviews[]`. Rows with `type: "error"` explain what to change. Sort or filter on the numeric fields directly; use `entityId` to refer to the same hotel across runs.

### Limits, honestly

- **Search returns what Google shows for the place.** Google decides which properties belong to "Ubud, Bali"; the facet walk enlarges that set but cannot add a hotel Google does not list there.
- **`totalPrice` is Google's headline, not the all-in.** It equals `priceBeforeTaxes` + `fees`; the `taxes` slot is outside it on every row measured. Use `totalWithTaxes` for the number a guest pays. Two properties can swap places when you re-sort on the all-in figure — in 9 of 14 Ubud runs the cheapest hotel changed identity.
- **OTA rates need one extra lookup per hotel**, which is why they are an add-on: Google's search answer carries only the cheapest price, not the per-site list. They are for your dates; only the hotel-page fallback quotes Google's default stay, and the row says so.
- **Vacation rentals** (no `placeId`) usually list one or two sellers and have no address or phone on Google.
- **Amenities from search** are the ids Google tags the property with, named where the table in this Actor knows them and returned raw otherwise.
- **One room.** `adults` and `children` share one room; Google Hotels prices a single room per search, so multi-room bookings are not an input.
- **The price calendar is one request per hotel and day.** 10 hotels × 60 days is 590 requests — about two minutes. Keep `maxCalendarHotels` small on a wide search.
- **Reviews are what Google attaches to the hotel record**, not the full history of each review site. The full scrollable Google review list did not load for anonymous visitors in our test of 13 November 2026, so it is not offered rather than offered half-working.
- **Rate limits.** Google answers these requests from datacenter IPs today; each request retries on a new IP, and a run that meets a consent page says so in the log. Residential proxies are a switch away if that changes.

### ❓ FAQ

#### Is there a Google Hotels API?

Not a public one. This Actor reads the same endpoint the Google Hotels page uses, which is why the fields match what you see on the page — including the itemised taxes and the review topics.

#### How many hotels can I get for one city?

As many as Google lists for it, up to the cap you set. The facet walk measured 197 distinct hotels for Ubud from 15 requests; a big city yields several hundred. Set `maxHotelsPerLocation` to what you need.

#### Are the prices for my dates?

Yes for `pricePerNight` and `totalPrice` — those are Google's cheapest rate across booking sites for the check-in and check-out you gave. They are the figures Google prints, which means taxes are **not** in them; `totalWithTaxes` is. The per-seller `offers` (OTA rates add-on) are for the same dates; `offersForSearchedDates` confirms it on each row.

#### Does it include taxes?

Not in `totalPrice`, and this is worth a minute of your time. Google's headline price is `priceBeforeTaxes` + `fees`; the `taxes` slot sits outside it. That held in **755 of 755 rows** measured on 21 October 2026 across eight destinations and three currencies, with no exception. The all-in figure is on the same row as **`totalWithTaxes`**, and `totalWithTaxes` − `totalPrice` equals `taxes` exactly.

`totalPrice` stays the headline on purpose: it matches what the Google Hotels page shows you, so you can check any row against the page in ten seconds. Sum `totalWithTaxes` when you need the number a guest actually pays. By city median the difference was 9.1% (Bangkok) to 17.6% (Barcelona) of the all-in total, and single rows reached 30.4%.

One edge worth knowing: Google's displayed total is rounded to the whole currency unit while the itemisation is not, so on very cheap stays `totalPrice` can land a few cents **above** `totalWithTaxes` — $17 against $16.66 on a two-night Ubud homestay. Trust the itemisation when the two disagree by less than a unit.

#### Can I find the cheapest day to book?

Yes. Set `priceCalendarTo` to the last check-in day you would consider. Each hotel gets `calendarCheapestCheckIn` and `calendarCheapestPerNight` plus the full day-by-day `priceCalendar`, each day with the cheapest booking site. It costs $3 per 1,000 extra days priced and nothing for sold-out days.

#### Can I price a family stay?

Yes. Set `children` and `childrenAges`. Google prices the room for adults plus children, which can be very different from the adult-only price (we measured $76 against $128 a night at the same hotel and dates). Every price in the run follows: hotel rows, OTA rates and the calendar.

#### Can I skip hostels and guesthouses?

Use `minPricePerNight` (for example 80) together with `hotelClass` (4 and 5). The search then keeps only properties at or above that nightly price.

#### Can I get reviews?

Yes — turn on `includeReviews` with the OTA-rates add-on or with `hotelUrls`. You get the review snippets Google attaches to the hotel (source, author, date, rating, text, link) — usually one per source, 1–3 per hotel in our Ubud test of 22 October 2026 — plus the rating and review count per source in `reviewSources`. For full review histories use a reviews scraper for the source site.

#### Can I use it with the Apify API or an MCP server?

Both. Start runs and read datasets through the REST API or the Python and JavaScript clients, and call the Actor as a tool from any MCP-capable agent through the Apify MCP server.

#### Can I integrate it with other apps?

Through the Apify integrations for Google Sheets, n8n, Make and Zapier, or through webhooks on run finish.

#### Why does a default run search 30 days out?

Because a saved task or a scheduled monitor must never search a date that has already passed and come back empty. Give explicit dates and they are used; give a past date and the row says the date was adjusted.

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

The Actor reads public pages and public data — prices, ratings, amenities — with no login and no personal data beyond reviewer display names Google already publishes. How you use the data is subject to your local law and Google's terms; consult a lawyer for your case.

#### One row per hotel?

Yes. Offers and reviews are arrays on the hotel's row; the dataset views unwind them into one line per seller or per review when you want a flat table.

### Your feedback

If a field is missing, a place returns fewer hotels than Google shows, or a price does not match the page, open an issue on the Actor with the input you used — it is answered quickly and fixed in the next build. A short review after your first run helps other people find a scraper that works.

### You might also like

| Actor | What it does |
|---|---|
| [Google Flights Scraper](https://apify.com/lergassy/google-flights-scraper) | fares, price calendar and booking options by route and dates |
| [Hotel Price Scraper](https://apify.com/lergassy/hotel-price-scraper) | just the hotel prices: nightly rate and total with taxes for a city and dates, filtered by stars, rating and price |
| [Booking.com Scraper](https://apify.com/lergassy/booking-hotels-scraper) | Booking.com search with rooms, rates and reviews |
| [Booking.com Reviews Scraper](https://apify.com/lergassy/booking-reviews-scraper) | Booking.com guest reviews with hotel replies, $1 per 1,000 |
| [Agoda Reviews Scraper](https://apify.com/lergassy/agoda-reviews-scraper) | guest reviews and ratings from Agoda |
| [Trip.com Scraper](https://apify.com/lergassy/tripcom-scraper) | Trip.com hotel prices and availability |
| [Airbnb Scraper](https://apify.com/lergassy/airbnb-scraper) | vacation rental prices and availability |

### Also known as

Google Hotels API, Google Hotel Search scraper, Google Travel hotels scraper, hotel price scraper, hotel rate shopping tool, hotel price comparison API, scrape hotel prices from Google, Google hotel reviews scraper, hotel metasearch data.

# Changelog

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

# Actor input Schema

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

Required unless you give `hotelUrls`. One place per line, the way you would type it into Google Hotels: a city (<code>Lisbon</code>), a neighbourhood (<code>Shibuya, Tokyo</code>), a region or a landmark (<code>hotels near Eiffel Tower</code>). Each place is searched separately.

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

Format <code>YYYY-MM-DD</code>. Leave empty and the Actor searches a stay 30 days from today, so a saved task never runs on a date that has passed.

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

Format <code>YYYY-MM-DD</code>. Leave empty for a two-night stay. Prices are the total for the whole stay and the average per night.

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

Number of adult guests in one room, 1–8. Google prices the room for this many people.

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

Children sharing the room, 0–6. Google prices the room for adults plus children, so family rates differ from adult-only rates (measured: 2 adults $76/night, 2 adults + a child of 8 $128/night at the same hotel and dates).

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

One age (0–17) per child, in order, e.g. <code>8</code> and <code>12</code>. A child without an age is priced as 8 years old.

## `maxHotelsPerLocation` (type: `integer`):

Google shows 20 hotels per page and stops there. This Actor keeps going through sort orders, star classes and price bands and de-duplicates by hotel, so it can collect well over a hundred hotels for one city. Set how many you want per place.

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

Turn on to get, for each hotel, the price on every booking site Google lists — Agoda, Expedia, Trip.com, Priceline, Hotels.com, the hotel's own website and more — with the stay total, price per night and a deep link, quoted for <b>your</b> dates, guests and currency. Adds <code>offers</code>, <code>vendorCount</code>, <code>cheapestOfferSeller</code>, <code>officialSiteTotal</code>, review sources and the full address and phone. One extra request per hotel, charged as the <i>Add-on: Hotel page read</i> event ($8 per 1,000 hotels). Off by default for API calls; on in this form. <a href='https://apify.com/lergassy/google-hotels-scraper#how-much-does-it-cost-to-scrape-google-hotels' target='_blank'>Pricing</a>.

## `maxOfferLookups` (type: `integer`):

Cap on the OTA-rates add-on: how many hotels (per run, in result order) get the booking-site prices. Keeps a wide search from pricing every hotel.

## `priceCalendarTo` (type: `string`):

Optional. Format <code>YYYY-MM-DD</code>. The same-length stay is priced for <b>every check-in day</b> from your check-in up to this date (60 days at most) — Google's lead price, the stay total and the cheapest booking site for each day — in <code>priceCalendar</code>, plus <code>calendarCheapestCheckIn</code>, <code>calendarCheapestPerNight</code>, <code>calendarHighestPerNight</code> and <code>calendarAveragePerNight</code> on the hotel row. Each extra priced day is charged as the <i>Add-on: Calendar day priced</i> event; days with no availability are free. Leave empty to price only your dates.

## `maxCalendarHotels` (type: `integer`):

How many hotels from the location search (in result order, per run) get the price calendar. Hotels you list under <i>Specific hotels</i> always get it. Keeps a wide search with a long calendar from pricing thousands of days.

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

Three-letter code for every price in the output: <code>USD</code>, <code>EUR</code>, <code>GBP</code>, <code>IDR</code> …

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

Which of Google's orders to read first. The deep search visits the other orders anyway; this one decides the first page and the <code>searchRank</code> numbering.

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

Keep only these hotel classes, e.g. <code>4</code> and <code>5</code>. Unrated properties are dropped when this is set.

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

Drop hotels rated below this, on Google's 5-point scale. Hotels without a rating are dropped too.

## `minPricePerNight` (type: `integer`):

In the output currency. Hotels whose nightly price is below this (or that show no price) are not returned — handy to skip hostels and guesthouses in a luxury scan. Leave empty for no lower bound.

## `maxPricePerNight` (type: `integer`):

In the output currency. Hotels whose average nightly price is above this are not returned.

## `poolOnly` (type: `boolean`):

Only hotels with a pool.

## `includeReviews` (type: `boolean`):

Include the reviews Google shows for the hotel (text, rating, date, source such as Tripadvisor or Trip.com). Needs the OTA-rates add-on above or hotel URLs.

## `maxReviews` (type: `integer`):

Up to what Google renders on the page — typically 10 to 20.

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

Google Hotels page URLs (<code>https://www.google.com/travel/hotels/entity/…</code>) or entity ids from an earlier run. Each becomes one row with offers, reviews and the full amenity list — no search needed.

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

Two-letter code for names, descriptions and amenity labels, e.g. <code>en</code>, <code>de</code>, <code>es</code>.

## `market` (type: `string`):

Two-letter country code Google prices for, e.g. <code>US</code>, <code>GB</code>, <code>DE</code>. Sellers and rates differ per market.

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

Google answers this Actor's requests from ordinary datacenter IPs; the default Apify proxy is enough. Switch to residential only if a run reports consent pages or empty answers.

## `maxRequestRetries` (type: `integer`):

Each retry uses a new IP.

## Actor input object example

```json
{
  "locations": [
    "Ubud, Bali"
  ],
  "adults": 2,
  "children": 0,
  "maxHotelsPerLocation": 40,
  "includeOffers": true,
  "maxOfferLookups": 20,
  "maxCalendarHotels": 10,
  "currency": "USD",
  "sortBy": "relevance",
  "poolOnly": false,
  "includeReviews": false,
  "maxReviews": 10,
  "language": "en",
  "market": "us",
  "proxyConfiguration": {
    "useApifyProxy": true
  },
  "maxRequestRetries": 3
}
```

# Actor output Schema

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

One row per hotel: name, star class, guest rating and review count, nightly and total price with taxes for the searched stay, amenities, coordinates, address, photos, check-in times, Google Hotels page and booking link — plus per-site offers, review sources and guest reviews when the hotel page is read.

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

Counts of locations, hotels, hotel pages read, requests and errors, with the searched dates.

# 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": [
        "Ubud, Bali"
    ],
    "includeOffers": true
};

// Run the Actor and wait for it to finish
const run = await client.actor("lergassy/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": ["Ubud, Bali"],
    "includeOffers": True,
}

# Run the Actor and wait for it to finish
run = client.actor("lergassy/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": [
    "Ubud, Bali"
  ],
  "includeOffers": true
}' |
apify call lergassy/google-hotels-scraper --silent --output-dataset

```

## MCP server setup

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