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

Google Hotels API alternative: hotels in any city with live prices, every booking site's rate (Booking.com, Expedia, Agoda, official site) across a date range, room rates, free-cancellation deadlines and guest reviews. Rate parity and hotel price monitoring. From $1.50 per 1,000.

- **URL**: https://apify.com/alom/google-hotels-scraper.md
- **Developed by:** [Alom Dev](https://apify.com/alom) (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 $1.50 / 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

Scrape **Google Hotels** for any city, area or landmark: hotel names, **live prices for your dates**, star class,
guest rating, review count, rating breakdown, what guests say about cleanliness / location / service, address,
phone, amenities, photos, coordinates and nearby places. Or track **specific hotels across a date range** and get
**every booking site's price** (Booking.com, Expedia, Hotels.com, Agoda, Trip.com, the hotel's **official website**
and 20+ more) with **free-cancellation deadlines** and **every room type and rate**, for rate parity checks and price
calendars. And get **guest reviews** (Google, Tripadvisor and more) with the hotel's responses.

✅ **Reliable by design.** Pure HTTP against Google's own data, no browser. Failed requests are retried on a fresh IP,
bad input is caught before the run starts, and a run that could not deliver says so ("partial" / "failed") instead
of pretending to succeed with nothing.
✅ **Correct dates, or no data.** Google silently swaps past or too-long stays for other dates. This Actor checks
every answer and never delivers prices for dates you did not ask for.
✅ **Every booking site, every date.** One row per hotel x check-in date x booking site, with the official-site flag,
the cheapest offer marked, and booking links.
✅ **Price monitoring built in.** Schedule it and get **only the prices that changed** since the last run, with the
previous price. Unchanged prices are not charged.

### What can you use Google Hotels data for?

- **Revenue management & rate shopping:** compare your hotel's rates with your competitive set, date by date.
- **OTA rate parity:** see whether Booking.com, Expedia or Agoda undercut your official website.
- **Price calendars:** find the cheapest check-in dates for a trip or an event over the next weeks.
- **Market research:** map every hotel in a city with its price level, stars, rating and amenities.
- **Travel apps, AI agents & dashboards:** feed clean JSON to your app, Google Sheets, BI tool or LLM workflow.

### Three modes

- **Search** (default): what you get when you type *"hotels in Paris"* into Google Hotels, for your dates and
  guests. Filters: price range, guest rating, star class, amenities, free cancellation, special offers (deals),
  sort order. Optionally add every booking site's price to each hotel (`includeProviderPrices`).
- **Hotel prices (price calendar):** give hotels by Google Hotels link, entity token or name, and a date range.
  You get one row per hotel x check-in date x booking site. A free `SUMMARY` record lists every hotel/date with
  its status: offers found, no offers (sold out), or failed.
- **Reviews:** give hotels (link, token or name) and get their guest reviews, newest / most relevant / highest /
  lowest first. You can also add reviews to the other two modes with `includeReviews`.

### What data does Google Hotels Scraper extract?

#### Hotel rows (search)

| Field | What it is |
|---|---|
| `name`, `propertyType` | Hotel name; `hotel` or `vacation_rental` |
| `hotelClass`, `rating`, `reviewCount` | Star class (1-5), guest rating (1-5), number of reviews |
| `pricePerNight`, `totalPrice` | Lead price for your dates, per night and for the whole stay |
| `pricePerNightWithTaxes`, `totalPriceWithTaxes` | Same including taxes & fees (see *Market* below) |
| `dealLabel` | e.g. "22% less than usual" |
| `address`, `phone`, `website`, `latitude`, `longitude` | Location and contacts |
| `amenities`, `amenitiesUnavailable` | Wi-Fi, pool, parking...; and what the hotel does NOT have |
| `images`, `description`, `descriptionLong` | Photos (1024 px, `maxImages`, full gallery with booking-site prices); Google's summary and long description |
| `ratingBreakdown` | Share and number of 5, 4, 3, 2 and 1-star reviews |
| `reviewAspects` | What reviews say per topic (Cleanliness, Location, Service, Breakfast...): mentions, positive, negative, sentiment |
| `externalRatings` | Ratings on Tripadvisor, Trip.com, the chain's site... (with booking-site prices) |
| `googleMapsUrl` | The hotel on Google Maps |
| `checkInTime`, `checkOutTime`, `nearbyPlaces` | House times; attractions, transit and airports with travel times |
| `entityToken`, `googleHotelsUrl`, `googlePlaceId` | Stable Google ids and a link to the hotel on Google Hotels |
| `offers` | With `includeProviderPrices`: every booking site's price, link and free-cancellation terms (+ `roomRates`) |
| `position`, `searchQuery`, `checkIn`, `checkOut`, `nights`, `adults`, `childrenAges`, `currency`, `market` | Context |

#### Price rows (hotel prices mode)

| Field | What it is |
|---|---|
| `hotelName`, `entityToken`, `googleHotelsUrl` | The hotel |
| `checkIn`, `checkOut`, `nights`, `adults`, `childrenAges`, `currency`, `market` | The stay that was priced |
| `provider`, `isOfficialSite`, `rank` | Booking site, whether it's the hotel's own site, position in Google's list |
| `pricePerNight`, `totalPrice` (+ `...WithTaxes`) | That site's price |
| `isLowestPrice`, `hotelLowestPricePerNight` | Cheapest offer for this hotel and date |
| `roomName`, `bookingUrl` | Room type (for featured offers) and the booking link (a Google redirect) |
| `freeCancellation`, `freeCancellationUntil(Date)` | Refundable or not, as Google states it for that site, and until when (null = Google does not say) |
| `roomRates` | With `includeRoomRates`: every room type x rate of Google's featured sites - price, free cancellation + deadline, breakfast included, max guests, beds |
| `previousPricePerNight` | In monitoring mode: the price in the previous run |

#### Review rows

| Field | What it is |
|---|---|
| `hotelName`, `entityToken`, `hotelRating`, `hotelReviewCount` | The hotel |
| `source` | `Google`, or the site Google shows the review from (Tripadvisor, TrustYou, Trip.com...) |
| `rating`, `ratingScale`, `text` | The review (some Google reviews are a rating without text) |
| `publishedRelative`, `stayMonth` | "3 weeks ago" as Google shows it; month of the stay |
| `tripType`, `travelGroup` | vacation / business; family / couple / friends / solo (Google reviews that state it) |
| `subRatings` | Rooms, service, location scores (Google reviews) |
| `ownerResponse`, `ownerResponseRelative` | The hotel's reply |
| `reviewerName`, `highlights`, `photos`, `reviewUrl` | Reviewer, tags like "Quiet" / "Great value", review photos, link to the original |

```json
{
  "type": "price", "hotelName": "Novotel Paris Les Halles", "checkIn": "2026-11-10", "checkOut": "2026-11-12",
  "provider": "Booking.com", "isOfficialSite": false, "isLowestPrice": false, "rank": 7,
  "pricePerNight": 269, "pricePerNightWithTaxes": 315, "totalPrice": 539, "totalPriceWithTaxes": 631,
  "currency": "USD", "market": "US", "freeCancellation": false, "bookingUrl": "https://www.google.com/travel/lodging/clk?...",
  "roomRates": [{ "roomName": "Superior Room with Two Queen Beds", "pricePerNight": 613, "pricePerNightWithTaxes": 693,
    "freeCancellation": true, "freeCancellationUntil": "Nov 9", "breakfastIncluded": true, "maxGuests": 4, "features": ["2 queen beds"] }]
}
```

### Why this Google Hotels scraper?

| | This Actor | Typical Google Hotels scrapers |
|---|---|---|
| How it works | Google's own JSON over HTTP | Often a headless browser |
| Bad input (past dates, wrong links) | Clear error before the run, or the one bad entry is skipped and reported | Often a crashed or empty run |
| Dates Google silently changed | Detected, never delivered | Delivered as if correct |
| Blocked / flaky requests | Retried on a fresh IP; an honest "partial" status | Often "succeeded" with 0 results |
| Every booking site per hotel | ✅ with official-site flag and free-cancellation deadline | Often lead price only |
| Room types x rates | ✅ breakfast / refundable per rate | Rarely |
| Guest reviews | ✅ Google + Tripadvisor & co., owner responses, traveler type | Often a separate actor |
| Date-range price calendar | ✅ up to a year of check-in dates | Usually one date |
| Only-changed-prices monitoring | ✅ | Rarely |
| Short timeouts | Stops in time and keeps its results | Can time out and lose the status |

Every release is tested end to end on the Apify platform across 20 scenarios: US and non-US cities, other
currencies and markets, families, pagination to 200+ hotels, filters, deals, booking-site prices, room rates, price
calendars, reviews, past dates, broken links, unknown hotels, monitoring, short timeouts, and scale runs (1,500 hotels from 6 cities in ~2 minutes; 4 hotels x
21 dates = 2,600 prices in ~2.5 minutes).

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

Platform usage is included. Failed, duplicate and unchanged (monitoring) rows are never charged.

| Apify plan | Hotels (search) per 1,000 | Price-calendar rows per 1,000 | Reviews per 1,000 |
|---|---|---|---|
| Free | $2.50 | $1.00 | $1.00 |
| Starter (Bronze) | $2.00 | $0.80 | $0.80 |
| Scale (Silver) | $1.75 | $0.70 | $0.70 |
| Business (Gold) and above | $1.50 | $0.60 | $0.60 |

A **hotel** row is one hotel from a search, with all its details. A **price-calendar row** is one booking site's
price for one hotel and date (its room rates included). A **review** row is one guest review; reviews are only
fetched when you ask for them.

Examples on the Free plan:

- 200 hotels in a city = **$0.50**.
- A 4-star Paris hotel has ~25-35 booking sites per date, so one hotel x 30 dates ≈ 900 rows = **$0.90**. Use
  `providers` (e.g. `["booking.com", "expedia", "official"]`) to keep only the sites you care about.

### How to use it

1. Click **Try for free**.
2. Pick the mode. For **search**, type what you'd type into Google Hotels (`hotels in Lisbon`, `resorts in Cancun`).
   For **hotel prices**, paste Google Hotels links or names with the city.
3. Set the check-in date (a date, or `+14` = 14 days from today), nights, guests, currency and market.
4. Click **Start** and download JSON, CSV or Excel, or read the dataset via API.

#### Price calendar input

```json
{
    "mode": "hotelPrices",
    "hotels": ["https://www.google.com/travel/hotels/entity/ChcIo_TJ-bLYkfIUGgsvZy8xdGtzbW56dhAB", "Hilton Paris Opera"],
    "checkInDate": "+7",
    "lastCheckInDate": "+36",
    "nights": 2,
    "adults": 2,
    "currency": "EUR",
    "providers": ["booking.com", "expedia", "official"]
}
```

**Tip:** run a search first and copy `entityToken` values into `hotels` - tokens are exact, names must match
Google's hotel name (we only accept confident matches and tell you the closest names otherwise).

#### Reviews input

```json
{
    "mode": "reviews",
    "hotels": ["Novotel Paris Les Halles", "https://www.google.com/travel/hotels/entity/ChcIo_TJ-bLYkfIUGgsvZy8xdGtzbW56dhAB"],
    "maxReviews": 200,
    "reviewsSort": "newest"
}
```

#### Monitoring: only changed prices

Set `deltaMode: true` and a monitor name (`monitorName`), then create a schedule. Each run delivers only
hotels/offers that are new or whose price changed since the previous run with that name, with
`previousPricePerNight`. With reviews, only reviews not delivered before. If nothing changed, the run says so
("empty: nothing changed since the previous run...") and costs nothing. Relative dates
(`"+30"`) keep a scheduled run valid forever; fixed dates that pass are skipped with a warning.

#### Market, currency and taxes

- `currency` (USD, EUR, GBP, JPY...) is honoured for any market.
- `country` (the **market**, default `US`) is the country Google believes you are browsing from. It changes which
  booking sites appear and how prices are shown: **in the US market, `pricePerNight` excludes taxes & fees and
  `pricePerNightWithTaxes` includes them; most other markets show one tax-inclusive price**, so
  `pricePerNightWithTaxes` is empty there. Non-US markets are served from residential IPs in that country (a bit
  slower, same price for you).

### Google Hotels API in Python, JavaScript, Make, Zapier, n8n and AI agents

Run it from the Apify API with the Python or JavaScript client, schedule it, or connect it to Make, Zapier, n8n and
Google Sheets. AI agents can call it through the Apify MCP server. See the **API** tab for ready-made code.

```python
from apify_client import ApifyClient  # pip install "apify-client>=3"

client = ApifyClient("<YOUR_API_TOKEN>")
run = client.actor("alom/google-hotels-scraper").call(run_input={
    "searchQueries": ["hotels in Lisbon"], "checkInDate": "+30", "nights": 2, "maxResults": 50,
})
for hotel in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(hotel["name"], hotel["pricePerNight"], hotel["rating"])
```

### Limitations

- **Prices are what Google Hotels shows** for the market and moment of the run. Sites change prices constantly, and
  your own Google results can differ (signed-in deals, member prices, your country).
- **Up to a few hundred hotels per query** in big cities (Google's list order; verified to 300+ unique hotels for Paris). For full
  coverage, split by area (`hotels in Montmartre`, `hotels near Eiffel Tower`) - duplicates are removed.
- **Booking links** are Google redirect links, as on the site; they are meant to be opened, not stored for months.
- **Room types x rates** exist only for Google's featured booking sites (usually 3-5 per hotel); for the other sites
  Google shows one lead price with its free-cancellation terms (or nothing - then `freeCancellation` is null).
  Pay-at-property and per-site deal badges are not in Google's data we read.
- **Reviews:** Google shows relative dates ("3 weeks ago"), not exact ones. `tripType` / `travelGroup` labels are
  derived from Google's codes (verified against ~1,000 reviews); unknown codes stay in `travelerTypeCodes`.
- **Amenities** come from Google's amenity codes; we only name the codes we could verify, so the list may be shorter
  than on the hotel page.
- **Families:** fewer booking sites sell rooms with children - fewer offers is Google's data, not a scraping gap.
- Dates more than ~11 months ahead usually have few prices on Google; stays are limited to 30 nights by Google.
- Google Hotels mixes in **vacation rentals**; turn off `includeVacationRentals` to exclude them.

### FAQ

**Is there an official Google Hotels API?** Google's Hotel Center / Hotel Prices APIs are for hotels and partners to
*send* their rates to Google, and require onboarding. There is no public API to read the comparison results. This
Actor returns what the Google Hotels website shows, as structured data.

**Is it legal to scrape Google Hotels?** The Actor reads publicly available hotel and price information without
logging in. You are responsible for how you use the data.

**Why does a hotel have no price?** Google had no bookable offer for your dates and guests (sold out, closed, or too
far ahead). Hotels without a price still appear in search; in a price calendar the date is listed as `no-offers` in
the `SUMMARY` record and costs nothing.

**Can I track prices every day?** Yes: schedule the Actor with relative dates and monitoring on, and send the
results to Google Sheets, a webhook or your database.

### More scrapers from the same developer

- [Google Trends API & Scraper](https://apify.com/alom/google-trends-scraper): interest over time, regions, related queries and Trending Now, a pytrends alternative
- [YouTube Scraper](https://apify.com/alom/youtube-scraper): videos, channels, Shorts, comments, subtitles and community posts without the API quota
- [Threads Scraper](https://apify.com/alom/threads-scraper): posts, profiles, replies and keyword search on Meta Threads, no login
- [Bilibili Scraper](https://apify.com/alom/bilibili-scraper): videos, creators, full comment threads and danmaku from B站, no login
- [Google Ads Transparency Scraper](https://apify.com/alom/google-ads-transparency-scraper): every Google ad a competitor runs, with the real ad copy
- [Threads Account Finder](https://apify.com/alom/threads-lead-finder): Threads accounts by keyword with followers, bio links and the contacts they list
- [Threads Hashtag & Keyword Monitor](https://apify.com/alom/threads-keyword-monitor): only the new posts for your keywords and #hashtags, for scheduled runs

### Feedback

Missing a field, found a bug, or need a feature? Open an issue in the **Issues** tab and I'll take a look. If this
Actor saved you time, a short review on the Store page helps other people find it.

# Actor input Schema

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

<b>Search</b>: one row per hotel for a destination. <b>Hotel prices</b>: one row per hotel x check-in date x booking site (Booking.com, Expedia, the official site...). <b>Reviews</b>: one row per guest review of the hotels you list (Google reviews plus Tripadvisor / TrustYou reviews shown on Google).

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

For <b>search</b> mode. Anything you would type into Google Hotels: <code>hotels in Paris</code>, <code>Lisbon</code>, <code>resorts in Cancun</code>, <code>hotels near Times Square</code>.

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

Stop after this many hotels per search query. Google's list for a big city runs into the hundreds.

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

Order of search results.

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

In the chosen currency. Hotels without a price are left out when a price filter is set.

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

In the chosen currency.

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

Only hotels rated at least this (1-5).

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

Only hotels with these star ratings.

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

Only hotels with all of these (filtered by Google).

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

Only hotels with a free-cancellation offer.

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

Google mixes apartments and holiday homes into hotel results. Turn off for hotels only.

## `onlyDeals` (type: `boolean`):

Google's <i>Special offers</i> filter: only hotels with a deal for your dates (e.g. "22% less than usual", in <code>dealLabel</code>).

## `maxImages` (type: `integer`):

Photo URLs per hotel (1024 px). Search cards carry ~9; with booking-site prices or in hotel-prices mode the full gallery (hotel, guest and booking-site photos, often 20+) is available.

## `includeProviderPrices` (type: `boolean`):

Adds <code>offers</code> to each hotel row: price per booking site (Booking.com, Expedia, official site...) with booking links. One extra request per hotel; still billed as one result.

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

For <b>hotel prices</b> and <b>reviews</b> modes. Google Hotels links (<code>google.com/travel/hotels/entity/...</code>), entity tokens (<code>ChcI...</code>, from the <code>entityToken</code> field of a search), or hotel names with the city (<code>Hilton Paris Opera</code>). Names are only accepted when Google finds a confident match.

## `lastCheckInDate` (type: `string`):

Price every check-in date from <b>Check-in date</b> to this one (inclusive), e.g. 30 days of prices. Same formats as Check-in date.

## `checkInDates` (type: `array`):

Alternative to a range: a list of check-in dates (<code>2026-12-24</code>, <code>+30</code>). Past dates are skipped with a warning, so a scheduled run keeps working.

## `providers` (type: `array`):

Optional. Keep only offers whose site name contains one of these (<code>booking.com</code>, <code>expedia</code>). <code>official</code> = the hotel's own website.

## `includeRoomRates` (type: `boolean`):

Adds <code>roomRates</code> to the offers of Google's featured booking sites (usually 3-5 per hotel, e.g. Booking.com, Expedia): every room type x rate with price, free cancellation (+ deadline), breakfast included and max guests. No extra requests; rows get larger. Every offer always carries <code>freeCancellation</code> as Google states it.

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

Also fetch guest reviews for every hotel delivered (search and hotel-prices modes; mode <b>Reviews</b> always does). Each review is its own row (<code>type: review</code>): text, rating, date, source (Google, Tripadvisor...), trip type / travel group, room/service/location sub-ratings and the hotel's response. Charged per review.

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

Stop after this many reviews per hotel (100 per request).

## `reviewsSort` (type: `string`):

Which reviews come first (and are kept when capped by Max reviews).

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

<code>2026-11-10</code>, or relative: <code>+14</code> (14 days from today), <code>today</code>, <code>tomorrow</code>. Relative dates keep scheduled runs valid. Default: 7 days from today.

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

Optional; otherwise check-in + <b>Nights</b>. Google allows stays of up to 30 nights.

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

Length of stay when no check-out date is given (also for every date of a price calendar).

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

Adult guests.

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

One age (0-17) per child, e.g. <code>\[7, 12]</code>. Fewer sites sell rooms for families, so expect fewer offers.

## `rooms` (type: `integer`):

Number of rooms.

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

3-letter code: USD, EUR, GBP, JPY, INR, AUD...

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

Google shows prices as seen from this country (e.g. US prices exclude taxes and add a with-taxes figure; EU prices include taxes; some sites only sell in some countries). <b>US</b> is fastest. Other countries use residential IPs there.

## `deltaMode` (type: `boolean`):

For scheduled runs: deliver only hotels / offers that are new or whose price changed since the previous run with the same monitor name, with the previous price. Unchanged prices are skipped and not charged.

## `monitorName` (type: `string`):

Separate memory per monitor, e.g. <code>paris-weekly</code>. Default: <code>default</code>.

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

Parallel queries / hotels.

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

Leave the default: US datacenter proxies, or residential proxies in the chosen market's country. Explicit settings here are used as given.

## Actor input object example

```json
{
  "mode": "search",
  "searchQueries": [
    "hotels in Paris"
  ],
  "maxResults": 100,
  "sortBy": "relevance",
  "freeCancellation": false,
  "includeVacationRentals": true,
  "onlyDeals": false,
  "maxImages": 5,
  "includeProviderPrices": false,
  "hotels": [
    "Novotel Paris Les Halles"
  ],
  "includeRoomRates": false,
  "includeReviews": false,
  "maxReviews": 50,
  "reviewsSort": "newest",
  "checkInDate": "+14",
  "nights": 1,
  "adults": 2,
  "rooms": 1,
  "currency": "USD",
  "country": "US",
  "deltaMode": false,
  "maxConcurrency": 4,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `results` (type: `string`):

No description

## `summary` (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 = {
    "searchQueries": [
        "hotels in Paris"
    ],
    "hotels": [
        "Novotel Paris Les Halles"
    ],
    "checkInDate": "+14"
};

// Run the Actor and wait for it to finish
const run = await client.actor("alom/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 Paris"],
    "hotels": ["Novotel Paris Les Halles"],
    "checkInDate": "+14",
}

# Run the Actor and wait for it to finish
run = client.actor("alom/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 Paris"
  ],
  "hotels": [
    "Novotel Paris Les Halles"
  ],
  "checkInDate": "+14"
}' |
apify call alom/google-hotels-scraper --silent --output-dataset

```

## MCP server setup

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