# Google Hotels Scraper - Prices, Booking Sites & Hotel Data (`santhej/google-hotels-scraper`) Actor

Scrape Google Hotels for any destination and dates: hotels with price per night, deals, rating, class and GPS. Optionally every booking site's price (Booking.com, Expedia, Agoda, official site) on one fixed tax basis, with rooms, address, phone and amenities. 84 currencies. No API keys.

- **URL**: https://apify.com/santhej/google-hotels-scraper.md
- **Developed by:** [Santhej Kallada](https://apify.com/santhej) (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.72 / 1,000 hotel 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

## Google Hotels Scraper — Hotels, Prices & Booking Sites

**Scrape Google Hotels for any destination and dates and get every hotel as a clean row — name, price per night, deal note, guest rating, star class, GPS coordinates and photos — for $0.90 per 1,000 hotels. Turn on booking options to add the price on every booking site, on one fixed tax basis, with rooms, address, phone and amenities.**

Google Hotels compares the rates of every booking site it knows for a hotel and a stay. This Actor reads that comparison for the destinations, dates, guests and currency you choose, with no browser to manage, no proxies and no API keys — and it only charges for searches that worked.

### What does Google Hotels Scraper do?

For each search you give it — `hotels in Paris`, `Tokyo`, `5 star hotels in Bangkok`, `resorts in Bali` or a hotel's name — the Actor runs that search on Google Hotels for your stay and returns one row per hotel, in Google's order. The destination is read from the text exactly as Google reads it, so `hotels in Paris` is Paris, France whichever country you search from.

It works at two levels, and you choose per run:

- **The hotel list** (default). One row per hotel with the price Google shows in its result list. Fast and cheap: the right choice for finding hotels, comparing them inside one search, building hotel lists and reading ratings, classes and locations.
- **Booking options and hotel details** (one switch). The Actor also opens each hotel's own Google Hotels page and adds every booking site Google lists for it — Booking.com, Expedia, Agoda, Hotels.com, Trip.com, the hotel's own site and more — with its price, free-cancellation date and link, plus address, phone, website, amenities, check-in and check-out times and the rating breakdown. `price_per_night` is then taken from that page, which quotes **one fixed basis**: before taxes and fees when you search from the US or Canada, taxes and fees included from other countries. Use this level whenever you compare prices between runs.

Why the difference matters: Google quotes the prices in its result *list* sometimes before and sometimes after taxes and fees, and does not say which. For the same hotel and stay we measured $80 and $96 from the list within minutes; the hotel's own page gave $80 every time when searched from the US and $96 every time from France or the UK. Each row says where its price came from (`price_source`) and, when it is known, whether it includes taxes (`price_includes_taxes`).

### What you get per hotel

| Field | What it tells you |
|---|---|
| `search` / `position` | The search this hotel was found for and its place in Google's results (1 = first) |
| `name` | Hotel name |
| `hotel_id` / `google_hotels_url` | Google's identifier for the hotel and the link to its Google Hotels page |
| `price_per_night` | Lowest nightly rate for your dates and guests. Empty when Google has no rate for those dates |
| `total_price` | `price_per_night` × `nights` |
| `price_source` | `search_results` (read from the result list) or `hotel_page` (read from the hotel's own page, with booking options on) |
| `price_includes_taxes` | `true` or `false` for a `hotel_page` price in a market where the basis is known; empty for list prices, whose basis Google does not fix |
| `currency` | The currency you asked for |
| `deal` / `deal_percent` | Google's deal note as shown ("28% less than usual") and the number in it |
| `stars` | Hotel class, 1–5. Empty for properties Google gives no class (apartments, hostels, guest houses) |
| `rating` / `reviews_count` | Google guest rating out of 5 and the number of reviews |
| `latitude` / `longitude` | GPS coordinates |
| `image_urls` | Up to nine photos |
| `is_sponsored` | `true` for a paid placement |
| `check_in` / `check_out` / `nights` / `adults` / `children` | The stay that was priced |
| `country` / `language` / `checked_at` | Where the search was made from, the language, and when — so results stay reproducible |

Added by **Include booking options and hotel details**:

| Field | What it tells you |
|---|---|
| `booking_options` | One entry per booking site: `source`, `price`, `currency`, `is_official_site`, `is_sponsored`, `free_cancellation_until`, `url`, and `rooms` (room name, price, max guests, cancellation date) where Google lists them |
| `booking_options_count` | How many booking sites quote this hotel |
| `cheapest_source` / `cheapest_price` | The booking site with the lowest rate, and that rate |
| `official_site_price` | The rate on the hotel's own site, when Google lists it — compare it with `cheapest_price` for a rate-parity check |
| `address` / `phone` / `website` | Contact details |
| `description` / `hotel_class` | Google's description of the property and its class label ("4-star hotel") |
| `amenities` / `amenities_unavailable` | What the hotel has ("Wi-Fi (Free)", "Parking (Extra charge)") and what it does not |
| `check_in_time` / `check_out_time` | As `HH:MM`, where the hotel publishes them |
| `rating_breakdown` | Share of reviews (percent) at 5, 4, 3, 2 and 1 stars |
| `review_topics` | What guests mention — service, location, breakfast … — with positive and negative counts |
| `other_site_ratings` | The hotel's rating on Tripadvisor, Trip.com and other sites Google quotes |
| `neighborhood` / `location_score` | Where it is and Google's location score out of 5 |
| `google_maps_url` / `google_maps_cid` | The Maps link and the hotel's Google Maps id, for joining with Maps data |

A run summary is saved alongside the data: hotels per search, how many had a price, how widely each search's hotels are spread, and the billing breakdown.

### Use cases

- **Hotel price tracking and rate shopping** — with booking options on: the price of each hotel on one fixed basis, and what every booking site charges for it, run after run.
- **Rate parity checks** — `official_site_price` next to `cheapest_price` and the full list of booking sites for your property and your competitors'.
- **Hotel lists and lead data** — every hotel in an area with class, rating, coordinates and, with details on, address, phone and website.
- **Market research** — hotel supply, class mix, ratings and price levels across destinations.
- **Travel deal finding** — sort by lowest price, or keep hotels Google marks as cheaper than usual (`deal_percent`).
- **Travel apps and comparison sites** — fresh hotel data with coordinates, photos and booking links.
- **AI agents** — one call answers "which 4-star hotels in Lisbon are available on these dates, and where is each one cheapest?".

### How to use

1. Add one or more **Searches**, written as you would type them into Google Hotels.
2. Pick the **Check-in** and **Check-out** dates — or leave both empty to price a 2-night stay 30 days from the day the run starts.
3. Set **Adults**, **Children's ages** and the **Currency**.
4. Set **Hotels per search** (10–140) and, if you like, a sort order and filters: hotel class, minimum rating, price range, free cancellation, amenities.
5. Turn on **Include booking options and hotel details** when you need each booking site's price, or prices you can compare from one run to the next.
6. Click **Start**, then export the dataset as JSON, CSV or Excel, or read it through the Apify API.

Schedule the Actor with empty or relative dates (`30 days` / `32 days`) and it never goes stale: every run prices the same stay length counted from the day it runs, and every row carries `checked_at`.

#### Example input

```json
{
  "searches": ["hotels in Paris", "hotels in Lisbon"],
  "checkIn": "2026-12-05",
  "checkOut": "2026-12-08",
  "adults": 2,
  "currency": "EUR",
  "maxHotelsPerSearch": 40,
  "sortBy": "lowest_price",
  "hotelClass": ["4", "5"],
  "minRating": "4.0",
  "includeBookingOptions": true
}
```

#### Input configuration

| Field | Type | Default | Description |
|---|---|---|---|
| `searches` | array of strings | — (required) | Searches as typed into Google Hotels: a place, a place with a qualifier, or a hotel name. Up to 100 per run; duplicates are removed. |
| `maxHotelsPerSearch` | integer | `20` | Hotels to return per search, 10–140. |
| `checkIn` / `checkOut` | string | 30 days from the run date, 2 nights | `YYYY-MM-DD`, or relative to the run date: `30 days`, `6 weeks`, `tomorrow`. A stay is 1–30 nights. |
| `adults` | integer | `2` | 1–6. Adults plus children can be at most 6 — Google prices one room. |
| `childrenAges` | string | — | Ages 0–17 separated by commas, for example `5, 9`. |
| `currency` | string | `USD` | 84 currencies: `USD`, `EUR`, `GBP`, `JPY`, `AUD`, `AED`, `INR`, … |
| `countryCode` | string | `us` | Country the search is made **from** (Google's market), not the destination. It decides which booking sites are listed and the tax basis of hotel-page prices. |
| `languageCode` | string | `en` | `en`, `fr`, `de`, `es`, `ja`, `pt-BR`, `zh-CN`, … |
| `sortBy` | string | `relevance` | `relevance`, `lowest_price`, `highest_rating`, `most_reviewed`. |
| `hotelClass` | array of strings | any | Any of `2`, `3`, `4`, `5`. |
| `minRating` | string | `any` | `3.5`, `4.0` or `4.5`. |
| `minPrice` / `maxPrice` | integer | none | Nightly price range in the selected currency. |
| `freeCancellation` | boolean | `false` | Only hotels with a free-cancellation rate. |
| `amenities` | array of strings | none | Hotels that have all of: `free_wifi`, `free_breakfast`, `pool`, `indoor_pool`, `outdoor_pool`, `spa`, `fitness_center`, `restaurant`, `bar`, `room_service`, `free_parking`, `parking`, `air_conditioning`, `kid_friendly`, `pets_allowed`, `wheelchair_accessible`, `beach_access`, `all_inclusive_available`. |
| `onlyWithPrice` | boolean | `false` | Leave out hotels Google has no rate for. |
| `includeBookingOptions` | boolean | `false` | Read each hotel's own page: every booking site's price, hotel details, and `price_per_night` on a fixed basis. |

#### Example output

A real row from a `hotels in Paris` run (list level; the photo list is shortened here from nine links to two):

```json
{
  "record_type": "hotel",
  "search": "hotels in Paris",
  "position": 1,
  "name": "The Originals Boutique, Hôtel Maison Montmartre, Paris",
  "hotel_id": "ChoI_uTZsvz1i6-bARoNL2cvMTFmZHB6eDEwMxAB",
  "stars": 4,
  "rating": 4,
  "reviews_count": 2130,
  "price_per_night": 87,
  "total_price": 174,
  "price_source": "search_results",
  "price_includes_taxes": null,
  "price_before_discount": null,
  "currency": "USD",
  "deal": null,
  "deal_percent": null,
  "is_sponsored": false,
  "latitude": 48.900537,
  "longitude": 2.3362689999999997,
  "image_urls": [
    "https://lh3.googleusercontent.com/grass-cs/AABkmLdhyApx3DxYnJ6b6YL7HJWjiSnWEKwm8nMHupyXRaOAfrAt6SQAZ_qAdu7kXCoRRIOoWuNhMPZMOyA5djTOehsXW6fZ5PQZqJI1ysWqq9_eMdGJWh1s00WWYs5y3Xdv7h8ptbOp=s287-w287-h192-n-k-no-v1",
    "https://lh3.googleusercontent.com/grass-cs/AABkmLfVIhT3AslelaOYe3bBVwnxICUzF8MmKU0dzkqpGsrgb9qjkB7LdFGoNjBcdUa4alMmX_YzJkeTlpIR5MSr-TQJIfY-_C5VFa99V6nqRLjLLsggyBWMjMyDwCNX7VcxWeBQwz1d=s287-w287-h192-n-k-no-v1"
  ],
  "google_hotels_url": "https://www.google.com/travel/hotels/entity/ChoI_uTZsvz1i6-bARoNL2cvMTFmZHB6eDEwMxAB",
  "check_in": "2026-11-11",
  "check_out": "2026-11-13",
  "nights": 2,
  "adults": 2,
  "children": 0,
  "country": "us",
  "language": "en",
  "checked_at": "2026-10-12T03:31:25.595Z"
}
```

With **Include booking options and hotel details** on, a row also carries these fields. Real values from a `hotels in Lisbon` run in EUR, searched from the US (lists shortened: 3 of 19 booking sites, 2 of 12 review topics, 6 of 16 amenities):

```json
{
  "name": "Lutécia Smart Design Hotel",
  "price_per_night": 114,
  "total_price": 228,
  "price_source": "hotel_page",
  "price_includes_taxes": false,
  "currency": "EUR",
  "address": "Av. Frei Miguel Contreiras 52, 1749-086 Lisboa, Portugal",
  "phone": "+351218411300",
  "website": "http://www.luteciahotel.com/",
  "hotel_class": "4-star hotel",
  "check_in_time": "15:00",
  "check_out_time": "12:00",
  "amenities": ["Wi-Fi (Free)", "Restaurant", "Bar", "Room service", "Breakfast", "Breakfast buffet"],
  "amenities_unavailable": ["Pool"],
  "rating_breakdown": { "1": 4, "2": 3, "3": 10, "4": 32, "5": 51 },
  "review_topics": [
    { "topic": "Transit", "mentions": 59, "positive": 43, "negative": 7 },
    { "topic": "Breakfast", "mentions": 60, "positive": 33, "negative": 21 }
  ],
  "other_site_ratings": [
    { "source": "Tripadvisor", "rating": 3.9, "out_of": 5, "reviews_count": 1400 },
    { "source": "Trip.com", "rating": 3.9, "out_of": 5, "reviews_count": 46 },
    { "source": "Priceline", "rating": 7.7, "out_of": 10, "reviews_count": 40 }
  ],
  "neighborhood": null,
  "location_score": 3.5,
  "google_maps_cid": "1117521634975496246",
  "booking_options_count": 19,
  "cheapest_source": "Evendo",
  "cheapest_price": 114,
  "official_site_price": 127,
  "booking_options": [
    {
      "source": "Expedia.com",
      "price": 131,
      "currency": "EUR",
      "is_official_site": false,
      "is_sponsored": true,
      "free_cancellation_until": null,
      "url": "https://google.com/aclk?sa=l&ai=DChsSEwiIqK6Ex7OXAxXyZ0cBHfJeAHcYACICC...",
      "rooms": [
        { "name": "Double or Twin Room, City View", "price": 131, "currency": "EUR", "max_guests": 2, "free_cancellation_until": null },
        { "name": "Double or Twin Room, City View", "price": 136, "currency": "EUR", "max_guests": 2, "free_cancellation_until": "2026-11-08T00:00:00.000Z" }
      ]
    },
    {
      "source": "Lutécia Smart Design Hotel",
      "price": 127,
      "currency": "EUR",
      "is_official_site": true,
      "is_sponsored": false,
      "free_cancellation_until": null,
      "url": "https://book.omnibees.com/hotelresults?q=1316&NRooms=1&CheckIn=1111202...",
      "rooms": []
    },
    {
      "source": "Evendo",
      "price": 114,
      "currency": "EUR",
      "is_official_site": false,
      "is_sponsored": false,
      "free_cancellation_until": null,
      "url": "https://evendo.com/stays/lutecia-smart-design-hotel/93429990?check_in=...",
      "rooms": []
    }
  ]
}
```

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

Pay per event. No monthly fee, no setup fee, and you never pay for a search that failed.

| Event | Price |
|---|---|
| Actor start | $0.005 per run |
| Hotel result | **$0.0009 per hotel — $0.90 per 1,000** |
| Hotel booking options and details (only when turned on) | $0.005 per hotel — $5.00 per 1,000 |

- One search, 20 hotels: $0.005 + 20 × $0.0009 = **$0.023**.
- Five cities, 40 hotels each (200 rows): $0.005 + 200 × $0.0009 = **$0.185**.
- One search, 20 hotels with every booking site's price and the hotel details: $0.005 + 20 × $0.0009 + 20 × $0.005 = **$0.123**.

You pay per hotel actually returned. Each search has a small fixed cost of its own, so in a run whose searches return very few hotels — a hotel-name search returns one — up to six units per search can be billed; the run summary shows any such units as `minimum_charge_units_added`. A run that finds no hotels at all is charged the start fee only, and booking options that could not be fetched for a hotel are not charged.

### FAQ

**Do I need an API key, a proxy or a Google account?** No. Add your searches and run — everything else is handled for you.

**Why did a search return fewer hotels than I asked for?** Google lists what it has for that place, those dates and your filters. A small town may have four hotels, a hotel-name search returns that hotel, and narrow filters (5-star with a pool under a price) cut the list further. `onlyWithPrice` also removes hotels without a rate. You are charged only for the hotels returned.

**Are the prices before or after taxes?** It depends on where the price was read. With booking options on, `price_per_night` and every booking site's price come from the hotel's own Google Hotels page, which is consistent: before taxes and fees when you search from the US or Canada, taxes and fees included from the other countries we checked (UK, Ireland, Germany, France, Spain, Italy, Netherlands, Switzerland, Sweden, Australia, New Zealand, Japan, India, Singapore, UAE, South Africa, Mexico, Brazil). `price_includes_taxes` says which. Without booking options the price is the one in Google's result list, which Google quotes on either basis from one request to the next — good for comparing hotels inside one search, not for tracking a price over time.

**Is the price per night or for the whole stay?** `price_per_night` is the nightly rate for your dates and guests. `total_price` is that rate multiplied by the number of nights.

**How does it know which Paris I mean?** The search goes to Google Hotels as you typed it, so Google decides, as it would for you: `hotels in Paris` is Paris, France. When a name is shared, add the country — `hotels in Valencia, Venezuela`. If Google does not recognise a place at all it answers with popular hotels from a wide area. Whenever a search's hotels are spread over more than 75 km, the run summary marks that search `wide_area` and the log and status message say so, so a typo is unlikely to pass unnoticed.

**A search I know has hotels came back empty. Why?** Google occasionally answers a search with a page that carries no hotel list; in our tests that happened with one landmark search (`hotels near Times Square`) and never with a city search. The Actor checks an empty answer a second time before reporting it. If it stays empty, name the city in the search — `hotels near Times Square New York` returned hotels every time. Hotel-name searches work when made from `us` and most other countries, but returned nothing from `gb` in our tests.

**Why is `price_per_night` empty for some hotels?** Google has no rate for them on those dates — the hotel is sold out, is not bookable online, or cannot take your party in one room. In our test runs with two adults that was about 1 hotel in 30; with children in the room it can be most of them. Turn on **Leave out hotels without a price** to skip them.

**What does "Searching from (country)" change?** It is the Google market the search is made from, not the destination. It changes which booking sites Google lists for a hotel and the tax basis of hotel-page prices.

**How many booking sites do I get per hotel?** As many as Google lists: in our test runs between 4 and 41 per hotel, including the hotel's own site when Google has it. Room-level rates are included where Google shows them.

**Do the booking links keep working?** They are the links Google shows. Some point straight at the booking site, others are Google redirect links that are not meant to be permanent — use them soon after the run.

**Does it return review texts?** No. It returns the rating, the review count and — with booking options on — the rating breakdown, the topics guests mention and the hotel's ratings on other sites.

**Can I run it from my own code or an automation tool?** Yes. Call it through the Apify API, or use the Apify integrations for n8n, Make and Zapier.

### More travel and local data tools

- [Tripadvisor Scraper](https://apify.com/santhej/tripadvisor-scraper-pro) — reviews, hotels and restaurants from Tripadvisor.
- [Airbnb Scraper](https://apify.com/santhej/airbnb-search-scraper) — listings, prices and coordinates for any destination.
- [Google Maps Scraper](https://apify.com/santhej/google-maps-scraper) — businesses with phone, website, reviews and GPS.
- [Google Reviews Scraper](https://apify.com/santhej/google-reviews-scraper-pro) — ratings and review texts for any place on Google.

***

*Tags: google hotels scraper, google hotels api, hotel prices scraper, hotel price tracker, hotel price monitoring, google hotels prices, hotel rates api, rate parity, rate shopping, booking.com prices, expedia prices, ota price comparison, hotel data, travel data, hotel price comparison api*

# Actor input Schema

## `searches` (type: `array`):

What to search on Google Hotels, exactly as you would type it there: 'hotels in Paris', 'Tokyo', '5 star hotels in Bangkok', 'hotels near Times Square' or a hotel's name. One search per line, up to 100 per run. The destination is read from the text - add the country when a place name is shared by several cities ('Valencia, Venezuela').

## `maxHotelsPerSearch` (type: `integer`):

How many hotels to return for each search (10-140). You are charged per hotel actually returned. Google lists fewer for small places and for very narrow filters.

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

Check-in date as YYYY-MM-DD, or relative to the day the run starts: '30 days', '6 weeks', 'tomorrow'. Leave both dates empty to price a 2-night stay starting 30 days from the run date - a schedule set up this way never goes stale.

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

Check-out date as YYYY-MM-DD, or relative: '32 days'. Must be after check-in; a stay can be 1 to 30 nights. Empty = 2 nights after check-in.

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

Adults in the room. Google prices one room for the whole party: adults plus children can be at most 6.

## `childrenAges` (type: `string`):

Age of each child in the room, separated by commas - for example '5, 9' for two children. Ages 0 to 17. Leave empty for no children. Prices change with the ages, as on Google.

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

Currency for every price in the run.

## `countryCode` (type: `string`):

Two-letter code of the country the search is made FROM (Google's market) - not the destination. 'hotels in Paris' finds Paris, France from any country. The market decides which booking sites are listed and, with booking options on, whether prices include taxes: 'us' and 'ca' quote before taxes and fees, other countries ('gb', 'de', 'fr', 'jp', 'au' ...) with them included.

## `languageCode` (type: `string`):

Language of hotel names, deal notes, room names and amenities: 'en', 'fr', 'de', 'es', 'ja', 'pt-BR', 'zh-CN' ...

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

Google Hotels' own order. With 'Hotels per search' it gives you, for example, the 30 cheapest or the 50 most reviewed hotels of a city.

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

Only hotels of these star classes. Empty = any class.

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

Only hotels with at least this Google guest rating (out of 5).

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

Lowest nightly price, in the selected currency. Empty or 0 = no minimum.

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

Highest nightly price, in the selected currency. Empty or 0 = no maximum.

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

Only hotels with a free-cancellation rate for the dates. Google then quotes that refundable rate as the price.

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

Only hotels that have all of the selected amenities.

## `onlyWithPrice` (type: `boolean`):

A few hotels have no rate on Google for the dates (sold out, or not bookable online). Turn this on to leave them out, so every row you pay for has a price.

## `includeBookingOptions` (type: `boolean`):

Reads each hotel's own Google Hotels page. Adds the price on every booking site Google lists (Booking.com, Expedia, Agoda, the hotel's own site ...) with free-cancellation dates and links, plus address, phone, website, amenities, check-in and check-out times and the rating breakdown. Prices are then on one fixed basis - before taxes and fees when searching from the US or Canada, taxes and fees included from other countries - which is what you need to track prices over time. Charged per hotel as a separate event - see the pricing section.

## Actor input object example

```json
{
  "searches": [
    "hotels in Paris"
  ],
  "maxHotelsPerSearch": 20,
  "adults": 2,
  "currency": "USD",
  "countryCode": "us",
  "languageCode": "en",
  "sortBy": "relevance",
  "minRating": "any",
  "freeCancellation": false,
  "onlyWithPrice": false,
  "includeBookingOptions": false
}
```

# Actor output Schema

## `dataset` (type: `string`):

Every hotel found, with its price for the stay.

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

Searches run, hotels returned per search, the stay priced and the billing breakdown.

# 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 = {
    "searches": [
        "hotels in Paris"
    ],
    "maxHotelsPerSearch": 20,
    "countryCode": "us",
    "languageCode": "en"
};

// Run the Actor and wait for it to finish
const run = await client.actor("santhej/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 = {
    "searches": ["hotels in Paris"],
    "maxHotelsPerSearch": 20,
    "countryCode": "us",
    "languageCode": "en",
}

# Run the Actor and wait for it to finish
run = client.actor("santhej/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 '{
  "searches": [
    "hotels in Paris"
  ],
  "maxHotelsPerSearch": 20,
  "countryCode": "us",
  "languageCode": "en"
}' |
apify call santhej/google-hotels-scraper --silent --output-dataset

```

## MCP server setup

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