# Google Hotels Scraper: Hotel Rates & Price Comparison, No Login (`headply/google-hotels-scraper`) Actor

Get Google Hotels prices for any city, dates and guests, and compare every booking site's rate (Booking.com, Expedia, Agoda, the hotel's own site). Ratings, amenities, address and phone included. Track price changes on a schedule. No login, no API key.

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

## Pricing

from $1.40 / 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 & API: hotel prices from every booking site, no login

Get **hotel prices from Google Hotels** for any city, dates and number of guests, and see **what Booking.com, Expedia, Hotels.com, Agoda and the hotel's own website charge**, side by side. Export to JSON, CSV or Excel, call it as an API, or schedule it as a **hotel price tracker** that only tells you when a price changes.

No Google account, no API key, no cookies, no browser extension.

### What can you do with this Google Hotels scraper?

- 🏨 **Get every hotel in a city with its price for your dates**: price per night and for the whole stay, with and without taxes, in USD, EUR, GBP or any other currency.
- 💸 **Compare hotel prices across booking sites**: for each hotel, the price on every site Google lists (Booking.com, Expedia, Hotels.com, Agoda, Priceline, Trip.com, the hotel's official site…), sorted cheapest first, with booking links.
- 📉 **Track hotel prices over time**: schedule a daily run and receive only the hotels whose price went up or down, with the old price, the new price and the difference.
- ⭐ **Collect hotel data for research and lead lists**: star class, guest rating, review count, rating distribution, review topics (location, service, cleanliness…), amenities, address, phone, website, coordinates and Google Maps / Places IDs.
- 🌍 **Cover a whole city**: walks through Google's result pages, up to 1,000 hotels per destination.

**Who uses it:** hotel revenue managers watching competitors' rates, travel startups and AI travel agents that need live prices, analysts studying tourism markets, and agencies building hotel lead lists.

### Why use this instead of the Google Hotels website or other scrapers?

Google has **no public Google Hotels API**. Copying prices by hand stops working past a few hotels, and many scrapers drive a full browser, which is slow and breaks when Google changes a button.

This Actor reads the same data the Google Hotels page itself loads, with plain web requests:

- **Fast:** 20 hotels with prices in about 5 seconds; 100 hotels with every booking site's price in about a minute.
- **Reliable:** in our tests, every request succeeded with no blocks or retries. A self-test runs every day, so a change on Google's side is caught and fixed before it reaches you.
- **Accurate:** dates, guests and currency are set exactly the way Google's own interface sets them, so prices match what you see on google.com/travel for the same search.
- **Stable output:** the same fields in every record, `null` when Google shows nothing. Fields are never renamed, so your sheets and code keep working.

### How to scrape Google Hotels prices (3 steps)

1. Click **Try for free** and type one or more destinations, such as `Lisbon` or `hotels near Times Square`.
2. Set your **check-in date**, **nights**, **adults** and **currency**. Turn on **Include every booking site's price** if you want the comparison across Booking.com, Expedia and others.
3. Click **Start**. Download the results as Excel, CSV or JSON, or open them in the **Hotels and prices** table view.

### Input examples

**Hotels in a city, 2 nights starting two weeks from today, prices in euros:**

```json
{ "queries": ["Lisbon"], "checkInDate": "14", "nights": 2, "adults": 2, "currency": "EUR", "maxHotelsPerQuery": 100 }
```

**Compare booking sites for your own hotel and its competitors:**

```json
{
  "hotelUrls": [
    { "url": "https://www.google.com/travel/hotels/entity/ChkIy5GZ0o_g66VJGg0vZy8xMWI3eHBmcGJsEAE" },
    { "url": "https://www.google.com/travel/hotels/entity/ChoIn5iv34iajuemARoNL2cvMTFidjFubnp6MxAB" }
  ],
  "checkInDate": "2026-12-05", "checkOutDate": "2026-12-08"
}
```

Copy a hotel's URL from Google Hotels: open the hotel on google.com/travel and copy the address bar.

**Daily hotel price alert for a destination (use with a schedule):**

```json
{ "queries": ["hotels near Times Square"], "checkInDate": "30", "nights": 1, "mode": "newOrChanged", "monitorName": "nyc-alerts", "maxHotelsPerQuery": 200 }
```

`checkInDate` takes a date (`2026-12-05`) or a number of days from the day of the run (`14`). With a number, a daily schedule always checks the same distance ahead.

### What data do you get? (output example)

A real record from Austin, Texas, for 2 nights, with booking-site prices included (shortened):

```json
{
  "hotelId": "ChkIy5GZ0o_g66VJGg0vZy8xMWI3eHBmcGJsEAE",
  "name": "DoubleTree by Hilton Hotel Austin Northwest Arboretum",
  "hotelClass": 4,
  "rating": 3.8,
  "reviewCount": 1893,
  "checkInDate": "2026-11-03",
  "checkOutDate": "2026-11-05",
  "nights": 2,
  "adults": 2,
  "currency": "USD",
  "pricePerNight": 88,
  "pricePerNightBeforeTaxes": 75.21,
  "totalPrice": 176,
  "totalPriceBeforeTaxes": 150.43,
  "dealNote": "17% less than usual",
  "address": "8901 Business Park Dr, Austin, TX 78759",
  "phone": "(512) 343-0888",
  "googlePlaceId": "ChIJh9ddSZ3LRIYRy0hG-gCvS0k",
  "amenities": ["Wi-Fi", "Wi-Fi in public areas", "Smoke-free property", "Credit cards", "Cash", "Front desk"],
  "offers": [
    { "source": "trivago DEALS", "pricePerNight": 88, "totalPrice": 176, "isOfficialSite": false, "bookingUrl": "https://www.google.com/travel/lodging/clk?…" },
    { "source": "DoubleTree by Hilton Hotel Austin Northwest Arboretum", "pricePerNight": 98.29, "totalPrice": 196.59, "isOfficialSite": true, "bookingUrl": "…" },
    { "source": "Billabook.com", "pricePerNight": 102.74, "totalPrice": 205.48, "isOfficialSite": false, "bookingUrl": "…" }
  ],
  "lowestOfferSource": "trivago DEALS",
  "latitude": 30.3787899,
  "longitude": -97.7405166,
  "url": "https://www.google.com/travel/hotels/entity/ChkIy5GZ0o_g66VJGg0vZy8xMWI3eHBmcGJsEAE?…",
  "scrapedAt": "2026-10-04T22:09:01.000Z"
}
```

| Field group | Fields |
|---|---|
| Price for your stay | `pricePerNight`, `pricePerNightBeforeTaxes`, `totalPrice`, `totalPriceBeforeTaxes`, `currency`, `checkInDate`, `checkOutDate`, `nights`, `adults`, `dealNote` |
| Booking-site comparison | `offers[]` (`source`, `pricePerNight`, `totalPrice`, `isOfficialSite`, `bookingUrl`), `offerCount`, `lowestOfferSource` |
| Ratings and reviews | `rating`, `reviewCount`, `ratingDistribution`, `reviewTopics` |
| Hotel details | `name`, `hotelClass`, `description`, `amenities`, `amenityDetails`, `checkInTime`, `checkOutTime`, `imageUrls`, `isVacationRental` |
| Location and contact | `address`, `phone`, `website`, `latitude`, `longitude`, `countryCode`, `nearbyPlaces`, `googlePlaceId`, `googleMapsUrl` |
| Price tracking | `changeType`, `previousPricePerNight`, `priceChange` |

Address, phone, Places ID, the full amenity list and `offers` come with **Include every booking site's price** (or with hotel URLs). Vacation rentals that Google mixes into hotel results are marked `isVacationRental: true`. Each run also saves a `SUMMARY` record with counts and anything that was skipped.

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

You pay only for results, with no monthly fee:

| What you get | Price per 1,000 hotels |
|---|---|
| Hotels with price, rating, class, amenities and photos | **$2.00** |
| Add every booking site's price, address, phone and full amenities | **+ $2.00** (so $4.00 total) |

Apify subscribers pay less: $1.80 (Bronze), $1.60 (Silver) and $1.40 (Gold and above) per 1,000 for each part.

**Examples on the free plan:** 100 hotels in Paris costs $0.20. 500 hotels with every booking site's price costs $2.00. Apify's free $5 monthly credit covers about 2,500 hotels, or 1,250 with booking-site prices.

In price-tracking mode you pay only for hotels whose price changed. Unchanged hotels are free. You can cap any run with **Max cost per run** in the run options.

### How to track hotel prices automatically

1. Set **Mode** to **Only new or changed price**, give the run a **Monitor name**, and use a relative check-in date such as `30`.
2. In Apify Console, click **Schedule** and choose daily or hourly.
3. The first run gives you every hotel as a starting point. After that, each run returns only hotels whose nightly price moved, with `previousPricePerNight` and `priceChange`.

Google reorders its results between visits, so a hotel missing from yesterday's list is usually not a new hotel. Those are remembered quietly. Turn on **Also report hotels new to the search** if you want them anyway. For revenue management, track a fixed list of hotel URLs: you get a clean daily feed of your competitors' rates.

Send the changes to Slack, email or Google Sheets with Apify's integrations, n8n or Make.

### Google Hotels API: use it from your code, n8n, Make or AI agents

**One API call that returns the hotels (run-sync):**

```bash
curl -X POST "https://api.apify.com/v2/acts/headply~google-hotels-scraper/run-sync-get-dataset-items?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"queries":["Paris"],"checkInDate":"21","nights":2,"maxHotelsPerQuery":40}'
```

**Python:**

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("headply/google-hotels-scraper").call(run_input={
    "queries": ["Barcelona"], "checkInDate": "30", "nights": 3, "currency": "EUR", "includeOffers": True,
})
for hotel in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(hotel["name"], hotel["pricePerNight"], hotel["lowestOfferSource"])
```

**n8n and Make:** add the Apify node or module, choose **Run an Actor and get dataset items**, select `headply/google-hotels-scraper` and paste the JSON input. Then connect Google Sheets, Airtable, Slack or your database.

**AI agents and MCP:** every input field is described for tool use. Give a destination, dates and a currency, and read `pricePerNight`, `totalPrice` and `offers`. Runs are short, so agents get answers while the user waits.

### FAQ

**Is there an official Google Hotels API?**
No. Google offers hotel data only to its booking partners. This Actor is the practical Google Hotels API: you send a destination and dates, and you get structured prices back.

**Do I need a Google account, cookies or proxies?**
No. It reads public Google Hotels pages without logging in. Apify Proxy is included and set up for you.

**Which country are the prices for?**
Google prices for the visitor's country. By default the Actor visits from the United States, so you get US-market prices in the currency you choose. To see prices as travellers in another country do, change the proxy country in the input.

**Can I get prices for specific dates and number of guests?**
Yes. Set check-in, check-out (or nights) and adults; every price is for that exact stay and party size.

**How many hotels can I get per city?**
Google lists up to about 1,000 hotels per search. For more, search smaller areas ("hotels in Shibuya", "hotels in Manhattan").

**Why does a hotel have no price?**
Google shows no rate when nothing is bookable for those dates and guests. The hotel is still returned with its details.

**Can I scrape Google Hotels reviews?**
This Actor returns the rating, review count, star distribution and review topics. Full review text is planned as a separate Actor.

**Is it legal to scrape Google Hotels?**
It collects publicly visible prices and hotel facts, with no personal data. Check that your use complies with the laws and terms that apply to you.

### Limits

- Prices are what Google shows at the moment of the run; booking sites can change them minutes later.
- Booking links are Google's click-out links for that search and expire after a while. Store the prices and `source`, not the link.
- Up to 1,000 hotels per destination, 1–30 nights per stay, 1–12 adults.

### More travel data from the same developer

- [Google Flights Scraper & API](https://apify.com/headply/google-flights-scraper): every flight and fare for any route and date, round trips with return options, Google's typical price range and 60-day price history, and a flight price tracker.

### Help and feedback

Something missing or not working? Open an issue on the **Issues** tab. Issues are usually answered within a day.

# Changelog

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

# Actor input Schema

## `queries` (type: `array`):

Where to look, one per line: a city or area ("Austin, TX", "Shibuya, Tokyo") or a full Google Hotels search ("pet friendly hotels near Times Square"). Place names are searched as "hotels in <place>". Leave empty when you only use hotel URLs.

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

Google Hotels hotel pages (https://www.google.com/travel/hotels/entity/...) to fetch directly, e.g. a fixed list of competitor hotels to track. Each returns full details and every booking site's price.

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

YYYY-MM-DD, or a number of days from the run date ("14" = two weeks ahead, so scheduled runs keep looking the same distance ahead). Leave empty for Google's default dates.

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

YYYY-MM-DD or days from the run date. Leave empty to use check-in plus "Nights".

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

Length of stay when no check-out date is given (1–30).

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

Number of adult guests; prices are for this party size.

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

Three-letter currency code for all prices (USD, EUR, GBP, INR, JPY…).

## `maxHotelsPerQuery` (type: `integer`):

Stop after this many hotels for each place or search. Google shows about 20 per page; large cities have 1,000+.

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

Also load each hotel's page for the price on every booking site (Booking.com, Expedia, Hotels.com, Agoda, the hotel's own site…) with booking links, plus address, phone, Google Places id and the full amenity list. Slower and billed as an extra event per hotel.

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

"All hotels" returns everything found. "Only new or changed price" remembers the last price of every hotel per search and returns (and bills) only hotels that are new or whose price moved since the previous run with the same monitor name. Use it with a schedule for price alerts.

## `includeNewHotels` (type: `boolean`):

Only used in "new or changed" mode. The first run always returns every hotel as the baseline. After that, by default only price changes are returned, because Google reshuffles its ranking between visits and many "new" hotels are just reordering. Turn this on to also get hotels that were never seen before in this search.

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

Only used in "new or changed" mode. Separate schedules with different names keep separate memories.

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

How many photo URLs to include per hotel (0–50).

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

How many pages to load at once. The default is fast and safe.

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

Apify datacenter proxy with US exits works well. The exit country sets the market Google prices for.

## `selfTest` (type: `boolean`):

Fail the run if the output looks broken. Used by the daily health check.

## Actor input object example

```json
{
  "queries": [
    "New York"
  ],
  "hotelUrls": [],
  "checkInDate": "14",
  "checkOutDate": "",
  "nights": 1,
  "adults": 2,
  "currency": "USD",
  "maxHotelsPerQuery": 20,
  "includeOffers": false,
  "mode": "all",
  "includeNewHotels": false,
  "monitorName": "default",
  "maxImages": 10,
  "maxConcurrency": 8,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyCountry": "US"
  },
  "selfTest": false
}
```

# Actor output Schema

## `hotels` (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 = {
    "queries": [
        "New York"
    ],
    "checkInDate": "14",
    "maxHotelsPerQuery": 20,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyCountry": "US"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("headply/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 = {
    "queries": ["New York"],
    "checkInDate": "14",
    "maxHotelsPerQuery": 20,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyCountry": "US",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("headply/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 '{
  "queries": [
    "New York"
  ],
  "checkInDate": "14",
  "maxHotelsPerQuery": 20,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyCountry": "US"
  }
}' |
apify call headply/google-hotels-scraper --silent --output-dataset

```

## MCP server setup

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