# Google Hotels Scraper — Prices, Providers & Reviews (`inexhaustible_glass/google-hotels-scraper`) Actor

Search Google Hotels: real prices, star class, GPS location, and (opt-in) real multi-provider price comparison (Booking.com, Expedia, etc.) plus real guest reviews. Deep filters: amenities, property type, brand, pool, free cancellation, eco-certified. No API key, no browser.

- **URL**: https://apify.com/inexhaustible_glass/google-hotels-scraper.md
- **Developed by:** [Hitman studio](https://apify.com/inexhaustible_glass) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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 & Vacation Rentals Scraper — Prices, Providers & Reviews

Search **Google Hotels** *or* **Google Vacation Rentals** (villas, apartments, cottages) for any destination — real nightly/total prices, star class, GPS location, address, and photo for every property. Optionally go one level deeper: resolve each hotel's real **multi-provider price comparison** (Booking.com, Expedia, Goibibo, hotel-direct and whatever else Google itself shows for that property) and its **real guest reviews**. No API key, no login, no headless browser.

**Vacation Rentals is a genuine Apify gap** — every other Google Vacation Rentals/Travel Actor on the store has 2 users or fewer at the time of writing. It's also not something any open-source library supports: `propertyCategory: "vacation_rentals"` switches a single undocumented integer in Google's own search request, found by empirically testing values against the live endpoint (Google exposes neither the field nor its meaning anywhere) — verified live, returning real villa/apartment/cottage listings distinct from the hotels results for the same destination.

> **Keywords:** google hotels api, hotel price scraper, hotel price comparison, booking.com price scraper, hotel reviews scraper, travel data api, hotel aggregator data.

### 🌟 Why this one

- **Hotels AND Vacation Rentals in one Actor** — `propertyCategory: "vacation_rentals"` searches Google's villa/apartment/cottage listings instead of hotel chains, same destination/date inputs, same output shape. No other Actor on Apify offers this.
- **Real provider price comparison, not just one price** — turn on `fetchProviderPrices` and get every booking site Google itself lists for that hotel, each with its own real price, room name, cancellation policy and booking URL. Verified live: a single Goa hostel returned 6 real providers (Booking.com, Goibibo, Bluepillow.in, Expedia, …) with different real prices on each.
- **Real reviews, not a star count** — `fetchReviews` returns actual guest review text, author, rating and date, sourced from Google's own review data.
- **Deep server-side filters**: amenities (`free_wifi`, `pool`, `pet_friendly`, `wheelchair_accessible`, …), property type (`hostels`, `resorts`, `boutique_hotels`, …), hotel brand (`hilton_honors`, `marriott_bonvoy`, `hyatt`, …), star class, price range, pool/free-cancellation/eco-certified/special-offers toggles.
- **GPS + full address + photo** on every hotel — ready to drop straight onto a map.
- **No browser** — talks to the same backend Google Hotels' own web app uses, directly. Faster and cheaper to run than a Playwright/Puppeteer-based scraper, and nothing to time out waiting for a page to render.
- **Honest two-tier design**: a broad destination search is fast and free of extra calls. Provider prices and reviews are opt-in (`includeBookingTokens` + `fetchProviderPrices`/`fetchReviews`) because they genuinely cost one extra request per hotel — you choose when that's worth it, capped with `tokenEnrichmentLimit`.

### 📥 Input

Quick search:

```json
{ "destination": "Goa", "checkIn": "2026-12-10", "checkOut": "2026-12-13", "adults": 2 }
```

With filters:

```json
{
  "destination": "New York", "checkIn": "2026-12-15", "checkOut": "2026-12-18",
  "minRating": 4.0, "minHotelClass": 4, "amenities": ["free_wifi", "pool"],
  "freeCancellation": true, "sortBy": "rating"
}
```

With real provider prices + reviews (the deep-data mode):

```json
{
  "destination": "Goa", "checkIn": "2026-12-10", "checkOut": "2026-12-13",
  "maxResultsPerSearch": 10, "includeBookingTokens": true, "tokenEnrichmentLimit": 10,
  "fetchProviderPrices": true, "fetchReviews": true
}
```

Bulk, via `hotelSearches`:

```json
{
  "hotelSearches": [
    { "destination": "Goa", "checkIn": "2026-12-10", "checkOut": "2026-12-13" },
    { "destination": "New York", "checkIn": "2026-12-15", "checkOut": "2026-12-18", "minRating": 4.0 }
  ]
}
```

Full filter list (all optional): `adults`, `rooms`, `currency`, `sortBy`, `minPrice`/`maxPrice`, `minRating`, `minHotelClass`, `amenities`, `propertyTypes`, `brands`, `hasPool`, `freeCancellation`, `specialOffers`, `ecoCertified`, `maxResultsPerSearch`.

### 📤 Output (one row per hotel)

```json
{
  "success": true,
  "name": "Moustache Goa Luxuria",
  "price": 24, "total_price": 72, "currency": "USD",
  "rating": 4.4, "review_count": 4029,
  "hotel_class": 4, "hotel_class_label": "4-star hotel",
  "latitude": 15.6034025, "longitude": 73.7499613,
  "address": "Plot No 399/7N Zorin Village, near St Anthony Hospital, Vagator, Chapora, Anjuna, Goa 403509",
  "image_url": "https://lh3.googleusercontent.com/...",
  "booking_token": "ChkI96i6kJOhqOyVARoML2cvMTJobHp6NHY5EAE",
  "providers": [
    { "name": "Booking.com", "price": 24, "total_price": 73, "currency": "USD", "url": "https://...", "is_free_cancellation": true },
    { "name": "Goibibo.com", "price": 24, "total_price": 72, "currency": "USD", "url": "https://..." }
  ],
  "reviews": [
    { "source": "Google", "author": "hemant dhakad", "rating": 5.0, "relative_date": "3 months ago", "text": "..." }
  ]
}
```

A search that fails (bad destination, no inventory, etc.) produces one row with `success: false` and a real `error` message — it never silently returns nothing, and one bad search in a batch never stops the rest.

### 🎯 Use cases

- **Price comparison tools** — real per-provider prices for a hotel in one call, not just Google's own blended figure.
- **Hotel review aggregation** — real guest review text at scale, for sentiment analysis or display.
- **Travel apps / OTAs** — rich hotel cards (GPS, class, address, photo) ready to render.
- **Market research** — bulk destination/date comparisons via `hotelSearches`.
- **Revenue management** — track a property's own price and its competitors' provider prices over time.

### 🔌 Use this API from Claude / ChatGPT (MCP)

This Actor works out of the box with Apify's hosted MCP server — no extra setup on this Actor's side. Connect your AI client (Claude, ChatGPT, Cursor, etc.) to `https://mcp.apify.com` with your Apify token, then ask it to call this Actor by name:

```
inexhaustible_glass/google-hotels-scraper
```

The MCP server exposes generic tools (`search-actors`, `fetch-actor-details`, `call-actor`, `get-dataset-items`) that work with any public Actor, this one included — your AI assistant can search for it, read its input schema, run it, and fetch the results, all through the same MCP connection.

### ❓ FAQ

**Does this need a Google account or API key?**
No — it reads Google Hotels' own public travel-search data directly.

**Why are `providers` and `reviews` empty by default?**
Because resolving them costs one extra real request per hotel. Turn on `includeBookingTokens` plus `fetchProviderPrices`/`fetchReviews` when you need that depth, and use `tokenEnrichmentLimit` to control how many hotels get the deep lookup.

**How accurate are the prices?**
They're the live prices Google Hotels itself returns at request time — same source data a user would see in their browser.

**Can I search by a specific hotel name instead of a city?**
Yes — `destination` accepts a specific hotel name as well as a city/region.

**How does Vacation Rentals mode work, and is it reliable?**
Google Travel's search backend takes an internal "property category" value most scrapers never touch — 1 for hotels. Testing other integers against the live endpoint, 2 reliably returned villa/apartment/cottage listings instead of hotel chains, same payload shape. It isn't documented by Google, so there's a (small, same as any reverse-engineered endpoint) chance it changes without notice — same risk profile as the rest of this Actor's data source, not a separate concern. `propertyTypes` (hostels/resorts/boutique_hotels/…) is a Hotels-only filter and has no effect in Vacation Rentals mode.

### ⚖️ Notes

Reads Google Hotels' own publicly-accessible travel-search data. No login, scraping of personal accounts, or private data involved.

# Actor input Schema

## `destination` (type: `string`):

A city, region, or specific hotel name.

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

YYYY-MM-DD.

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

YYYY-MM-DD.

## `propertyCategory` (type: `string`):

Hotels searches hotel chains/independents (the default). Vacation rentals switches to Google's villa/apartment/cottage listings for the same destination and dates — a market gap on Apify, no other Actor offers this.

## `hotelSearches` (type: `array`):

For bulk runs across destinations/dates. Each item: {destination, checkIn, checkOut, ...any per-search filter below to override the defaults just for that search}.

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

Number of adult guests.

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

Number of rooms.

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

ISO currency code for prices.

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

Caps how many hotels are pushed per search.

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

Client-side sort order for returned hotels.

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

Only include hotels at or above this nightly price.

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

Only include hotels at or below this nightly price.

## `minRating` (type: `number`):

Only include hotels with a Google rating at or above this value.

## `minHotelClass` (type: `integer`):

Only include hotels with a star class at or above this value.

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

e.g. free_wifi, free_breakfast, pet_friendly, pool, indoor_pool, outdoor_pool, wheelchair_accessible

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

e.g. hostels, motels, resorts, boutique_hotels, apartment_hotels. Only applies when Property category is Hotels — Vacation rentals has no equivalent server-side type filter.

## `brands` (type: `array`):

e.g. hilton_honors, marriott_bonvoy, ihg_hotels_resorts, hyatt

## `hasPool` (type: `boolean`):

Only include hotels with a pool.

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

Only include hotels offering free cancellation.

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

Only include hotels with a special offer.

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

Only include eco-certified hotels.

## `includeBookingTokens` (type: `boolean`):

Runs one exact follow-up search per hotel to attach a pricing/review token. Adds real time per run — use tokenEnrichmentLimit to cap it.

## `tokenEnrichmentLimit` (type: `integer`):

Leave blank to resolve all. Recommended when includeBookingTokens is on for a broad destination search.

## `fetchProviderPrices` (type: `boolean`):

For each hotel with a booking token, fetches every booking provider Google shows (Booking.com, Expedia, hotel-direct, etc.) with real prices and URLs. Requires includeBookingTokens.

## `fetchReviews` (type: `boolean`):

For each hotel with a booking token, fetches real guest reviews (author, rating, text, date). Requires includeBookingTokens.

## Actor input object example

```json
{
  "destination": "Goa",
  "checkIn": "2026-12-10",
  "checkOut": "2026-12-13",
  "propertyCategory": "hotels",
  "hotelSearches": [
    {
      "destination": "Goa",
      "checkIn": "2026-12-10",
      "checkOut": "2026-12-13"
    },
    {
      "destination": "New York",
      "checkIn": "2026-12-15",
      "checkOut": "2026-12-18",
      "minRating": 4
    }
  ],
  "adults": 2,
  "rooms": 1,
  "currency": "USD",
  "maxResultsPerSearch": 30,
  "sortBy": "default",
  "hasPool": false,
  "freeCancellation": false,
  "specialOffers": false,
  "ecoCertified": false,
  "includeBookingTokens": false,
  "fetchProviderPrices": false,
  "fetchReviews": false
}
```

# Actor output Schema

## `hotels` (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 = {
    "destination": "Goa",
    "checkIn": "2026-12-10",
    "checkOut": "2026-12-13",
    "propertyCategory": "hotels",
    "adults": 2,
    "rooms": 1,
    "currency": "USD",
    "maxResultsPerSearch": 30,
    "sortBy": "default"
};

// Run the Actor and wait for it to finish
const run = await client.actor("inexhaustible_glass/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 = {
    "destination": "Goa",
    "checkIn": "2026-12-10",
    "checkOut": "2026-12-13",
    "propertyCategory": "hotels",
    "adults": 2,
    "rooms": 1,
    "currency": "USD",
    "maxResultsPerSearch": 30,
    "sortBy": "default",
}

# Run the Actor and wait for it to finish
run = client.actor("inexhaustible_glass/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 '{
  "destination": "Goa",
  "checkIn": "2026-12-10",
  "checkOut": "2026-12-13",
  "propertyCategory": "hotels",
  "adults": 2,
  "rooms": 1,
  "currency": "USD",
  "maxResultsPerSearch": 30,
  "sortBy": "default"
}' |
apify call inexhaustible_glass/google-hotels-scraper --silent --output-dataset

```

## MCP server setup

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