# Google Hotels Scraper - Prices, Reviews & Hotel Leads (`scrapesage/google-hotels-scraper`) Actor

Scrape Google Hotels for prices, per-OTA price comparison, ratings, reviews, amenities, geo, deals and hotel contacts. Search or paste URLs, track prices with monitor mode. No browser, no API key.

- **URL**: https://apify.com/scrapesage/google-hotels-scraper.md
- **Developed by:** [Scrape Sage](https://apify.com/scrapesage) (community)
- **Categories:** Travel, Lead generation, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.50 / 1,000 hotel scrapeds

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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## Google Hotels Scraper — Prices, Per-OTA Comparison, Reviews & Hotel Leads

Extract **complete Google Hotels data** — the fields thin scrapers leave empty: **real nightly + taxes-included prices, featured booking rates** (official site vs. top partner) and Google's lowest **"from" price**, **star class, guest ratings & reviews, full amenities, GPS coordinates, deal flags, street address and phone**. Search by keyword or paste URLs, and turn on **monitor mode** to pull only new hotels and price drops.

No login, no cookies, no browser, no API key — fast SSR extraction with high reliability.

### Why this Google Hotels scraper?

Most Google Hotels scrapers return the listing card and stop. This actor merges the search card **and** the property page into one rich record — the **richest dataset in the category** — and adds a price monitor for recurring price-drop alerts.

| Data | Typical scrapers | This actor |
|---|---|---|
| Nightly price + taxes-included total | partial | ✅ both |
| **Featured booking rates** (official site vs. partner, nightly + total) | ❌ | ✅ |
| Google's lowest **"from" price** across all providers | ❌ | ✅ |
| Star class + guest rating + review count | partial | ✅ |
| Guest reviews (source, rating, text, date) | ❌ | ✅ opt-in |
| Full amenities list | partial | ✅ |
| Street address + phone (hotel contact leads) | ❌ | ✅ opt-in |
| Check-in / check-out times | ❌ | ✅ opt-in |
| GPS coordinates (lat/lng) | ❌ | ✅ |
| Deal flags ("Great deal · 30% less than usual") | ❌ | ✅ |
| Vacation-rental facts (beds, baths, sleeps, size) | ❌ | ✅ |
| Photos | partial | ✅ |
| Monitor mode — only new & price-changed | ❌ | ✅ |

### Use cases

- **Hotel price intelligence** — track nightly and taxes-included prices, compare the **official-site rate vs. a top partner rate**, and capture Google's lowest **"from" price** for every property, on any dates and in any currency.
- **Price-drop alerts** — turn on monitor mode + [Schedules](https://docs.apify.com/platform/schedules) to get only the hotels whose price dropped since your last run.
- **Travel apps & metasearch** — feed hotel listings, prices, ratings, amenities, photos and geo into your own booking or comparison product.
- **Hospitality lead generation** — with details on, every hotel record carries a **street address and phone** — a clean list of properties to prospect for SaaS, supplies, OTAs, revenue management, or services, scored by rating and review volume.
- **Market & revenue research** — benchmark competitor pricing, star mix, review scores and deal frequency by city, neighborhood, or brand.

### How to use

1. [Sign up for Apify](https://console.apify.com/sign-up) — the free plan is enough to try this actor.
2. Open the **Google Hotels Scraper**, enter one or more search queries (or paste Google Hotels URLs), pick your dates, and click **Start**.
3. Watch results stream into the dataset table.
4. **Export** as JSON, CSV, Excel, XML, or RSS — or pull results programmatically via the [Apify API](https://docs.apify.com/api/v2).

### Input

```json
{
    "searchQueries": ["hotels in Austin", "5-star hotels in Miami"],
    "checkInDate": "2026-08-15",
    "checkOutDate": "2026-08-17",
    "adults": 2,
    "maxResults": 50,
    "sortBy": "lowest_price",
    "includeDetails": true,
    "includeReviews": true,
    "maxReviewsPerHotel": 10,
    "currency": "USD",
    "countryCode": "us"
}
```

- **searchQueries** — free-text Google Hotels searches. Each returns the first page (~20 properties). For broad coverage, add several narrower queries (by neighborhood, brand, or star level) — the actor de-duplicates hotels across them.
- **startUrls** — paste Google Hotels URLs directly: a search page (`…/travel/search?q=…`) or a single property page (`…/travel/hotels/entity/…`). Property URLs are always enriched with full details.
- **checkInDate / checkOutDate** — `YYYY-MM-DD`. Leave both empty and the actor uses an upcoming 2-night stay so the search price and per-OTA detail prices line up.
- **adults / children** — occupancy.
- **maxResults** — total hotels to return after de-dup, filtering and sorting (default 50; `0` = no limit).
- **sortBy** — `relevance`, `lowest_price`, `highest_rating`, or `most_reviewed`.
- **includeDetails** *(default false)* — add street address, phone, check-in/out times, coordinates, description, full amenities, and the **featured booking rates** (official site + top partner, each with nightly & taxes-included total) plus Google's **"from" price**. One extra request per hotel.
- **includeReviews** *(default false)* — attach guest reviews (source, rating, reviewer, date, text). **maxReviewsPerHotel** caps how many.
- **minRating / minPrice / maxPrice / hotelClasses / propertyTypes** — filters.
- **currency / countryCode / languageCode** — market controls; the country also pins the proxy so prices come back in the local currency.
- **monitorMode / monitorKey** — only output new & price-changed hotels between runs (see below).

### Output

One record per hotel (`type: "hotel"`). With details and reviews on:

```json
{
    "type": "hotel",
    "hotelId": "ChkIisyi57DBkdktGg0vZy8xMWJ5X3pkdHBoEAE",
    "hotelUrl": "https://www.google.com/travel/hotels/entity/ChkIisyi57DBkdktGg0vZy8xMWJ5X3pkdHBoEAE",
    "name": "Fairmont Austin",
    "propertyType": "hotel",
    "hotelClass": 4,
    "rating": 4.6,
    "reviewsCount": 5231,
    "price": 289,
    "currency": "USD",
    "pricePerNight": 289,
    "totalPrice": 331,
    "taxesIncludedInTotal": true,
    "dealLabel": "Great deal",
    "dealPercentOff": 22,
    "amenities": ["Free Wi-Fi", "Pool", "Spa", "Fitness center", "Bar", "Restaurant", "Air conditioning", "Pet-friendly"],
    "topMentions": ["Rooftop pool", "Service", "Location"],
    "address": "101 Red River St, Austin, TX 78701",
    "phone": "(512) 600-2000",
    "checkInTime": "3:00 PM",
    "checkOutTime": "12:00 PM",
    "latitude": 30.2626,
    "longitude": -97.7396,
    "description": "Polished property featuring multiple bars & restaurants, plus a rooftop pool & spa.",
    "featuredOffers": [
        { "provider": "Official site", "pricePerNight": 289, "totalPrice": 331, "currency": "USD" },
        { "provider": "Super.com", "pricePerNight": 262, "totalPrice": 300, "currency": "USD" }
    ],
    "lowestOfferProvider": "Super.com",
    "lowestOfferPrice": 300,
    "offerProviderCount": 2,
    "pricesFrom": 279,
    "reviews": [
        { "source": "Tripadvisor", "rating": 4.5, "reviewer": "Tony", "relativeDate": "2 weeks ago", "text": "Great location, attentive front desk…" }
    ],
    "thumbnail": "https://lh3.googleusercontent.com/…",
    "images": ["https://lh3.googleusercontent.com/…"],
    "searchQuery": "hotels in Austin",
    "searchCheckIn": "2026-08-15",
    "searchCheckOut": "2026-08-17",
    "scrapedAt": "2026-07-02T12:00:00.000Z"
}
```

### Monitor mode — price-drop alerts

Turn on **monitorMode** and give each saved search a **monitorKey** (e.g. `austin-4star`). The actor remembers every hotel and its price between runs and outputs **only new hotels and ones whose price changed** — each price-changed record carries `previousPrice` and `monitorStatus`. Pair it with [Schedules](https://docs.apify.com/platform/schedules) to run daily or hourly.

Monitor state is stored in a named key-value store and keyed independently per `monitorKey`, so it never conflicts with the Apify scheduler or with your other saved searches — schedule as many as you like.

### Automate & schedule

Run this actor on autopilot and pull results into your own stack:

- **[Apify API](https://docs.apify.com/api/v2)** — start runs, fetch datasets, and manage schedules over REST.
- **[apify-client for JavaScript](https://docs.apify.com/api/client/js/)** and **[apify-client for Python](https://docs.apify.com/api/client/python/)** — official SDKs.
- **[Schedules](https://docs.apify.com/platform/schedules)** — run it hourly/daily/weekly to track prices for a city, route, or specific hotels; perfect for price-drop pipelines.
- **[Webhooks](https://docs.apify.com/platform/integrations/webhooks)** — trigger downstream actions (CRM import, Slack alert, price-drop email) the moment a run finishes.

```js
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: 'MY_APIFY_TOKEN' });

const run = await client.actor('scrapesage/google-hotels-scraper').call({
    searchQueries: ['hotels in Austin'],
    checkInDate: '2026-08-15',
    checkOutDate: '2026-08-17',
    includeDetails: true,
    maxResults: 50,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(`Got ${items.length} hotels with price comparison`);
```

### Integrate with any app

Connect the dataset to 5,000+ apps — no code required:

- **[Make](https://docs.apify.com/platform/integrations/make)** — multi-step automation scenarios.
- **[Zapier](https://docs.apify.com/platform/integrations/zapier)** — push price drops straight into Sheets, Slack, or your CRM.
- **[Slack](https://docs.apify.com/platform/integrations/slack)** — get notified when a monitored search finds a cheaper price.
- **[Google Drive / Sheets](https://docs.apify.com/platform/integrations/drive)** — auto-export every run to a spreadsheet.
- **[Airbyte](https://docs.apify.com/platform/integrations/airbyte)** — pipe results into your data warehouse.
- **[GitHub](https://docs.apify.com/platform/integrations/github)** — trigger runs from commits or releases.

### Use with AI assistants (MCP)

The output is clean, LLM-ready JSON. You can call this actor from Claude, ChatGPT, or any agent framework through the **[Apify MCP server](https://docs.apify.com/platform/integrations/mcp)** — ask your assistant to "find 4-star hotels in Austin for next weekend and tell me which site is cheapest" and let it run this scraper for you.

### Agent-ready: autonomous payments (x402 & Skyfire)

This actor is **agent-ready** — AI agents can discover it, run it, and **pay for it autonomously**, with no Apify account and no human in the loop. It uses [pay-per-event](https://docs.apify.com/platform/actors/publishing/monetize/pay-per-event) pricing and [limited permissions](https://docs.apify.com/platform/actors/development/permissions), so it qualifies for Apify's agentic-payment standards:

- **[x402](https://docs.apify.com/platform/integrations/x402)** — an open, HTTP-native payment protocol. Agents pay per run in USDC on the Base network directly through the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp) — no account, no API key.
- **[Skyfire](https://docs.apify.com/platform/integrations/skyfire)** — agent-to-service payments for fully autonomous AI-agent workflows.

Building an AI agent, MCP tool, or autonomous data pipeline? This scraper is ready to plug in and pay as it goes.

### More scrapers from scrapesage

Build a complete **travel & local-market intelligence stack**:

- **[Google Flights Scraper](https://apify.com/scrapesage/google-flights-scraper)** — live fares, routes, layovers and price tracking.
- **[Booking.com Scraper](https://apify.com/scrapesage/booking-scraper)** — hotels, prices and availability.
- **[Agoda Scraper](https://apify.com/scrapesage/agoda-scraper)** — hotels, amenities, category scores and full guest reviews.
- **[Trip.com Scraper](https://apify.com/scrapesage/trip-com-scraper)** — hotels, prices and reviews.
- **[Airbnb Scraper](https://apify.com/scrapesage/airbnb-scraper)** — listings, prices, and market monitoring.
- **[GetYourGuide Scraper](https://apify.com/scrapesage/getyourguide-scraper)** — tours, activities, prices and reviews.
- **[Google Maps Scraper](https://apify.com/scrapesage/google-maps-scraper)** — places, leads and contacts.
- **[Website Contact Scraper](https://apify.com/scrapesage/website-contact-scraper)** — emails, phones and socials for any hotel website.

### Tips

- **Breadth**: Google shows ~20 hotels per search. To cover a big city, add several narrower queries — by neighborhood ("hotels in Downtown Austin"), brand ("Marriott Austin"), or star level ("5-star hotels Austin"). The actor de-duplicates across them.
- **Currency**: Google sets the price currency from the proxy IP's country. The default (fast datacenter) proxy returns USD. For prices in a specific local currency (e.g. GBP, EUR), set `countryCode` **and** switch `proxyConfiguration` to a **RESIDENTIAL** proxy pinned to that country. The per-OTA comparison (which site is cheapest) is meaningful in any currency.
- **Consistent prices**: provide `checkInDate`/`checkOutDate` (or let the actor default them) so the headline price and the per-OTA comparison are for the same dates.
- **Cost control**: keep `includeDetails`/`includeReviews` off for a fast, cheap price sweep; turn them on only when you need address, phone, per-OTA comparison, or reviews.
- **Reliability**: for heavy or high-frequency runs, switch `proxyConfiguration` to RESIDENTIAL.

### FAQ

**How do I compare booking prices?** Turn on **includeDetails**. Each hotel then includes `featuredOffers` — the rates Google features on the property page (the official site and a top partner, each with `pricePerNight` and taxes-included `totalPrice`) — plus `pricesFrom` (Google's lowest advertised price across every provider) and `lowestOfferProvider` / `lowestOfferPrice`. Google only renders these featured rates in the page itself; the full 20+ provider list sits behind an in-page click that isn't part of the public HTML.

**Does it work without the Google Hotels API?** Yes — Google Hotels has no public API. This actor reads the same public results pages a visitor sees, no key or login needed.

**Can I track price drops?** Yes — turn on **monitorMode**, set a **monitorKey**, and schedule the run. You'll get only new hotels and ones whose price changed, with `previousPrice` on each change.

**Can I export to Google Sheets, CSV, or Excel?** Yes — one click in the dataset view, or automatically on every run via the [Google Drive integration](https://docs.apify.com/platform/integrations/drive).

**A field is null — why?** Some properties genuinely don't publish everything: vacation rentals hide the exact street address and phone (privacy), and not every hotel has an editorial description or a star class. Fields are `null` only when Google doesn't expose the data, never because the scraper skipped them.

**Is scraping Google Hotels legal?** This actor collects publicly available data only. You are responsible for using the data in compliance with applicable laws and Google's terms.

### Need help?

Open an issue on the actor's **Issues** tab, or visit the [Apify help center](https://help.apify.com/). Feature requests are welcome — this actor is actively maintained.

# Actor input Schema

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

Free-text Google Hotels searches — e.g. "hotels in Austin", "5-star hotels Paris", "beachfront resorts Cancun", "Marriott Times Square New York", "pet friendly hotels Denver". Each query returns the first page (~20 properties). For broad coverage, add several narrower queries (by neighborhood, brand, or star level).

## `startUrls` (type: `array`):

Paste Google Hotels URLs directly — either a search results page (…/travel/search?q=…) or a single property page (…/travel/hotels/entity/…). Property URLs are always enriched with full details.

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

Check-in date in YYYY-MM-DD format. Leave both dates empty and the actor uses an upcoming 2-night stay (~3 weeks out) so the search price and the per-OTA detail prices line up. If you set one date, set the other too.

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

Check-out date in YYYY-MM-DD format.

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

Number of adult guests.

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

Number of children.

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

Maximum number of hotels to return across all queries (after de-duplication, filtering and sorting). Set 0 for no limit. Keep the default for fast, low-cost runs.

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

How to order the collected hotels before applying the Max hotels cap.

## `includeDetails` (type: `boolean`):

For each hotel, open its property page to add street address, phone, check-in/out times, coordinates, description, the full amenity list, the featured booking rates (official site + a top partner, each with nightly & taxes-included total) and Google's lowest 'from' price. One extra request per hotel.

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

Attach guest reviews (source, star rating, reviewer, date, text) to each hotel. One extra request per hotel.

## `maxReviewsPerHotel` (type: `integer`):

Cap the number of reviews attached to each hotel when "Include guest reviews" is on.

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

Only keep hotels with a guest rating at or above this value (0–5).

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

Only keep hotels whose starting price is at or above this amount (in the selected currency).

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

Only keep hotels whose starting price is at or below this amount (in the selected currency).

## `hotelClasses` (type: `array`):

Only keep hotels of these star classes. Leave empty for all. (Vacation rentals have no star class and are excluded when this is set.)

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

Keep only these property types. Leave empty for all.

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

3-letter currency code for prices (e.g. USD, EUR, GBP, CAD, AUD, SGD).

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

2-letter country code for the Google market (gl). Also pins the proxy to that country so prices come back in the local market's currency.

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

2-letter UI language code (hl), e.g. en, es, fr, de.

## `monitorMode` (type: `boolean`):

Remember hotels and prices between runs (keyed by Monitor key) and output only NEW hotels and ones whose price changed since the last run — ideal for price-drop alerts. Pair with Apify Schedules to run daily/hourly.

## `monitorKey` (type: `string`):

Names the saved state for monitor mode. Use a distinct key per saved search (e.g. "austin-4star") so different searches track independently.

## `maxRetries` (type: `integer`):

How many times to retry a page on a fresh proxy IP when Google returns a temporary block or an empty "loading" shell.

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

Proxy settings. The default uses Apify Proxy pinned to the selected country. For heavy or high-frequency use, switch to RESIDENTIAL for the best reliability.

## Actor input object example

```json
{
  "searchQueries": [
    "hotels in Austin",
    "5-star hotels in Miami"
  ],
  "startUrls": [],
  "checkInDate": "2026-08-15",
  "checkOutDate": "2026-08-17",
  "adults": 2,
  "children": 0,
  "maxResults": 50,
  "sortBy": "relevance",
  "includeDetails": false,
  "includeReviews": false,
  "maxReviewsPerHotel": 10,
  "hotelClasses": [],
  "propertyTypes": [],
  "currency": "USD",
  "countryCode": "us",
  "languageCode": "en",
  "monitorMode": false,
  "monitorKey": "default",
  "maxRetries": 4,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

All scraped hotel records in the default dataset. Use the Hotels view for the headline table and the Price monitor view for monitor-mode changes.

# 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 Austin"
    ],
    "startUrls": [],
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapesage/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 Austin"],
    "startUrls": [],
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("scrapesage/google-hotels-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).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 Austin"
  ],
  "startUrls": [],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call scrapesage/google-hotels-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=scrapesage/google-hotels-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/tNAZg0cCs5MTveQP5/builds/MIp36RQpDKfKf3Ips/openapi.json