# Google Hotels Scraper - Prices, Ratings & Amenities (`cirkit/google-hotels-scraper`) Actor

Scrape Google Hotels prices for any city, landmark or hotel search and dates. Get nightly and total price incl. taxes, deal badges, star class, rating, review breakdown, amenities and coordinates. No login. From $0.75 per 1,000.

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

## Pricing

$0.75 / 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.

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

### What is Google Hotels Scraper?

**Google Hotels Scraper** lets you extract hotel prices, star ratings, guest reviews and amenities from Google Hotels for any city, neighbourhood, landmark or hotel brand, helping you benchmark room rates against your competitors, build hotel datasets for travel products, and track how prices move for the dates you care about.

- 💲 **Shop rates in bulk:** get the nightly price, the stay total, taxes and fees and the tax-inclusive total for every property Google lists, for your exact check-in date, length of stay and number of guests.
- 📉 **Spot deals automatically:** each row carries Google's own deal badge, such as "18% less than usual", so a price is either a bargain or not instead of just a number.
- 🏨 **Build a competitor set in one run:** star class, guest rating, review count, the 1 to 5 star breakdown and what guests praise or complain about (service, cleanliness, breakfast, location) for hundreds of hotels at once.
- 🗺 **Map a market:** latitude and longitude, check-in and check-out times, website, Google Maps link and the nearest airport, transit stops and attractions with travel times.
- 🏖 **Hotels or vacation rentals:** search the Hotels tab, the Vacation rentals tab, or both.
- 🔁 **Schedule it:** relative dates such as `+14d` keep a daily or weekly run pricing the same window forever, which is how revenue managers and rate-parity tools actually use this data.

Google does not offer a public Google Hotels API. Google Hotels Scraper reads the same data the Google Hotels website shows, with no login, no cookies and no API key, and it pages past the first screen of results: a single "hotels in London" query returned 670 unique hotels in QA.

### What data does Google Hotels Scraper extract?

- 🏷 Property name, type (hotel or vacation rental) and category (`name`, `propertyType`, `category`)
- ⭐️ Star class as a number and as text (`hotelClass`, `hotelClassText`)
- 📝 Google's one-line description of the property (`description`)
- 💯 Guest rating and review count (`rating`, `reviewCount`)
- 📊 Review breakdown by star, 5 to 1 (`ratingHistogram`)
- 💬 Review topics with mention, positive and negative counts, for example Service, Cleanliness, Breakfast (`reviewTopics`)
- 💲 Price per night, before and including taxes (`pricePerNight`, `pricePerNightWithTaxes`)
- 🧾 Stay total, taxes and fees, and total including taxes (`totalPrice`, `taxesAndFees`, `totalPriceWithTaxes`)
- 🔤 The prices exactly as Google displays them, for example "$98" (`pricePerNightText`, `totalPriceWithTaxesText`)
- 📉 Deal badge, for example "16% less than usual" (`dealBadge`)
- ✅ Whether the property had a rate for your dates (`isPriced`)
- 📍 Latitude, longitude and country code
- 🕒 Check-in and check-out times
- 🛎 Amenities in plain English, for example Free Wi-Fi, Outdoor pool, Pet-friendly, Free parking, Spa (`amenities`)
- 🚇 Nearby places: airport, transit stops, attractions and restaurants, with travel times by car, on foot or by public transit (`nearbyPlaces`)
- 🌐 Official website, Google Maps link, Google Hotels link and Google's booking link
- 🖼 Thumbnail and up to 10 photo URLs
- 🆔 Google place id and Google Hotels entity id, for joining runs over time
- 🗓 The search that produced the row: query, resolved location, dates, nights, adults, currency, position in the results

### How to use Google Hotels Scraper

1. Open the actor and type one or more **search queries**, the same way you would on Google Hotels: `hotels in Lisbon`, `hotels near Times Square`, `Marriott Chicago`.
2. Pick a **check-in date** (`2026-12-20`, or `+14d` for 14 days from whenever the run starts) and a **check-out date** (`+2d` means a 2-night stay).
3. Set the number of **adults**, the **currency** and whether you want hotels, vacation rentals or both.
4. Set **Max results per query** so the cost is capped.
5. Run it, then download JSON, CSV or Excel, or pull the results from the Apify API.

### Input

```json
{
  "queries": ["hotels in Austin, TX", "hotels in Lisbon", "Hilton Paris"],
  "checkInDate": "+14d",
  "checkOutDate": "+2d",
  "adults": 2,
  "propertyType": "hotels",
  "maxResultsPerQuery": 100,
  "maxItems": 1000,
  "currency": "USD",
  "country": "us",
  "language": "en"
}
```

- `queries`: one search per entry. Anything Google Hotels understands works: a city, a neighbourhood, a landmark, a hotel brand plus a place.
- `checkInDate` / `checkOutDate`: `YYYY-MM-DD`, or relative. `+14d` for check-in counts from today; `+2d` for check-out counts from check-in. Stays of up to 30 nights.
- `propertyType`: `hotels` (default), `vacationRentals`, or `all` (everything on the Hotels tab, which mixes in a few rentals).
- `maxResultsPerQuery`: stop each query after this many properties. 0 means no limit.
- `maxItems`: a hard cap across all queries.
- `currency`, `country`, `language`: every price comes back in `currency`; `country` sets the Google market, which changes the partners and rates Google shows.

### Output

One row per property. A trimmed real record from a QA run:

```json
{
  "query": "hotels in Rome",
  "checkInDate": "2026-10-09",
  "checkOutDate": "2026-10-11",
  "nights": 2,
  "adults": 2,
  "position": 50,
  "name": "Excel Roma Montemario",
  "propertyType": "hotel",
  "hotelClass": 4,
  "rating": 3.6,
  "reviewCount": 2083,
  "ratingHistogram": { "5": 676, "4": 609, "3": 334, "2": 166, "1": 298 },
  "reviewTopics": [{ "topic": "Room amenities", "mentions": 55, "positive": 4, "negative": 48 }],
  "pricePerNight": 93.53,
  "pricePerNightWithTaxes": 119.54,
  "totalPrice": 184.27,
  "taxesAndFees": 52.02,
  "totalPriceWithTaxes": 239.08,
  "currency": "USD",
  "dealBadge": "16% less than usual",
  "latitude": 41.9327083,
  "longitude": 12.4336487,
  "checkInTime": "2:00 PM",
  "checkOutTime": "11:00 AM",
  "amenities": ["Free breakfast", "Free Wi-Fi", "Air conditioning", "Fitness center", "Bar", "Restaurant"],
  "nearbyPlaces": [
    { "name": "Leonardo da Vinci International Airport", "category": "airport",
      "travelTimes": [{ "mode": "driving", "duration": "46 min" }, { "mode": "public transit", "duration": "1 hr 11 min" }] }
  ],
  "website": "http://www.laminhotels.com/",
  "googleMapsUrl": "https://www.google.com/maps?cid=10081842658463503728",
  "googleHotelsUrl": "https://www.google.com/travel/hotels/entity/ChgIwpjj863slZiqARoLL2cvMXRoaDRwZjAQAQ?hl=en&gl=us&curr=USD",
  "...": "..."
}
```

The dataset has three ready-made table views: **Overview** (photo, name, price, stars, rating, deal), **Rates** (the full price breakdown and booking link) and **Location and amenities**.

A search that finds nothing, or an input the actor cannot use, still finishes successfully and writes one row with `noResults: true`, a `noResultsReason` (`location-not-recognized`, `no-properties`, `invalid-input`, `fetch-failed`) and a plain-English `message`. You never get a silent empty dataset.

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

**$0.75 per 1,000 properties**, flat. No monthly rental, no tiers.

| Properties | Cost |
|---|---|
| 1,000 | $0.75 |
| 10,000 | $7.50 |
| 100,000 | $75.00 |

A 20-hotel test run costs under two cents. The best-known Google Hotels scraper on the Store charges $4.99 per 1,000.

### Measured coverage

From QA runs on 2026-09-25 over 360 hotels in New York, Tokyo, Rome, Cancun, Sydney and Dubai, all through the production proxy:

| Field | Filled |
|---|---|
| Name, coordinates, rating, review count, rating histogram, place id, links | 100% |
| Photos and thumbnail | 99.7% |
| Amenities, website | 97.2% |
| Review topics | 94.7% |
| Nightly price, stay total, taxes (every price field) | 91.9% |
| Star class | 91.4% |
| Description | 80.8% |
| Check-in and check-out time | 79.7% |
| Deal badge | 23.9% on the US market, 0% on GB (only shown when Google flags a deal) |

Rows without a price are properties Google lists but has no rate for on those dates. They carry `isPriced: false` so you can filter them out.

### Limits

- Street addresses are not in the Google Hotels results list, so they are not returned. Coordinates and the Google Maps link are.
- Prices are the lowest rate Google shows for the property. Per-partner rate ladders (Booking.com vs Expedia vs the hotel's own site) are not included.
- Google caps how deep a list goes. Very large cities stop somewhere between 400 and 700 unique hotels per query. Split a city into neighbourhoods for more.
- Google re-ranks results between pages, so the actor removes duplicates and stops a query after three pages in a row add nothing new.
- A query Google cannot match to a place returns one `location-not-recognized` row rather than hotels from a default city.
- Children are not supported yet; prices are quoted for adults only.

### FAQ

#### Is it legal to scrape Google Hotels?

Google Hotels Scraper collects publicly visible information about businesses: hotel names, prices, ratings and amenities. It does not log in, does not bypass any paywall and does not collect personal data. You are responsible for how you use the data and for complying with Google's terms and the laws that apply to you. If in doubt, ask a lawyer.

#### Do I need a Google account, cookies or an API key?

No. Nothing to paste, nothing to log into.

#### Can I use Google Hotels Scraper as an API?

Yes. Every Apify actor is an API. Start runs and fetch results over HTTP with the [Apify API](https://docs.apify.com/api/v2), or call it from an AI agent through the Apify MCP server.

#### Can I use it in Python?

```python
from apify_client import ApifyClient
run = ApifyClient("<YOUR_TOKEN>").actor("cirkit/google-hotels-scraper").call(run_input={"queries": ["hotels in Lisbon"]})
```

Then iterate `client.dataset(run["defaultDatasetId"]).iterate_items()`.

#### How do I track hotel prices every day?

Save your input with relative dates (`"checkInDate": "+30d"`, `"checkOutDate": "+2d"`) and create a schedule in Apify Console. Each run prices a stay 30 days out, and the Google place id lets you join the runs into a price history.

#### Can I integrate Google Hotels Scraper with other apps?

Yes: Google Sheets, Zapier, Make, Slack, Airbyte and webhooks are all built into the Apify platform.

#### Why did I get fewer results than expected?

Three usual reasons: Google's list for that query really is that short (a small town, or a specific brand); `propertyType` is filtering rentals out; or the list stopped producing new properties and the actor stopped rather than bill you for repeats. The run log states which one happened.

#### Can I get room types or per-site prices?

Not yet. This actor returns the search results list. If you need a field that is not listed, open an issue on the actor page.

#### How is this different from other Google Hotels scrapers?

It is priced at $0.75 per 1,000 against $1 to $5 elsewhere, returns taxes and totals as numbers rather than text, deduplicates across pages, and writes an explanatory row instead of failing when a search finds nothing.

### You might also like

- [Google Flights Scraper](https://apify.com/cirkit/google-flights-scraper): fares, schedules and routes for the same trips
- [Booking.com Search Scraper](https://apify.com/cirkit/booking-search-scraper): Booking.com prices and availability
- [Tripadvisor Hotels Scraper](https://apify.com/cirkit/tripadvisor-hotels-scraper): Tripadvisor rankings and reviews
- [Airbnb Search Scraper](https://apify.com/cirkit/airbnb-search-scraper): short-term rental prices and listings

### Changelog

- **0.1** (2026-09-25): first release. Hotels and vacation rentals, full price breakdown, review topics, amenities, nearby places, relative dates.

# Actor input Schema

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

What you would type into Google Hotels: a city, neighbourhood, landmark or hotel brand plus place. One search runs per query. Examples: 'hotels in Lisbon', 'hotels near Times Square', 'Hilton Paris'.

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

YYYY-MM-DD, or a relative offset from today such as +14d. Relative dates keep a saved input or a schedule working without editing it every month.

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

YYYY-MM-DD, or a number of nights after check-in such as +2d. Stays of up to 30 nights are supported.

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

Number of adult guests the price is quoted for.

## `propertyType` (type: `string`):

Hotels only (the default), vacation rentals only, or everything Google shows on its Hotels tab, which mixes in some rentals.

## `maxResultsPerQuery` (type: `integer`):

Stop each query after this many properties. Large cities list several hundred. Set 0 for no limit.

## `maxItems` (type: `integer`):

Hard cap on rows across all queries, so a large batch never costs more than you planned. Leave empty or 0 for no cap.

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

ISO 4217 code every price is returned in, for example USD, EUR, GBP, JPY.

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

Two-letter country code of the Google market to search from, for example us, gb, de. It changes which rates and partners Google shows.

## `language` (type: `string`):

Two-letter language code for names, descriptions and labels, for example en, fr, es.

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

Apify Proxy is on by default and the standard datacenter pool is all this actor needs.

## Actor input object example

```json
{
  "queries": [
    "hotels in Austin, TX",
    "hotels in Lisbon",
    "Marriott Chicago"
  ],
  "checkInDate": "+14d",
  "checkOutDate": "+2d",
  "adults": 2,
  "propertyType": "hotels",
  "maxResultsPerQuery": 20,
  "currency": "USD",
  "country": "us",
  "language": "en",
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `properties` (type: `string`):

Every property this run collected as the Overview table: name, nightly price, stars, rating and a link to it on Google Hotels.

## `rates` (type: `string`):

The full price breakdown per property: nightly, stay total, taxes and fees, deal badge and booking link.

## `locationAmenities` (type: `string`):

Coordinates, check-in and check-out times, amenities, website and Google Maps link per property.

## `propertiesCsv` (type: `string`):

The full result set as CSV, ready for a spreadsheet or a BI tool.

## `consoleRun` (type: `string`):

The Apify Console page for this run, including the live log.

# 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": [
        "hotels in Austin, TX"
    ],
    "checkInDate": "+14d",
    "checkOutDate": "+2d",
    "maxResultsPerQuery": 20,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("cirkit/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": ["hotels in Austin, TX"],
    "checkInDate": "+14d",
    "checkOutDate": "+2d",
    "maxResultsPerQuery": 20,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("cirkit/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": [
    "hotels in Austin, TX"
  ],
  "checkInDate": "+14d",
  "checkOutDate": "+2d",
  "maxResultsPerQuery": 20,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call cirkit/google-hotels-scraper --silent --output-dataset

```

## MCP server setup

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