# Google Hotels Scraper 🏨 (rates by date, no key) (`tagadanar/google-hotels-scraper`) Actor

Pull live hotel rates off Google Hotels for the dates and occupancy you care about: nightly price, star class, Google rating and review count, amenities, coordinates and the property own website. Set check-in, check-out and guests. No API key, one flat price per property, platform usage included.

- **URL**: https://apify.com/tagadanar/google-hotels-scraper.md
- **Developed by:** [Tagada Data](https://apify.com/tagadanar) (community)
- **Categories:** Travel, Automation, E-commerce
- **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 returneds

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/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 🏨

Get the nightly rate every hotel in a destination is asking for **your** dates, not
some cached average. Give it a city and a check-in/check-out pair, and you get back
one row per property: the price Google is quoting, the star class, the Google rating
and review count, the review score breakdown, the amenity list, the neighbourhood,
the coordinates and a link to the property's own website.

No API key, no Google account, no monthly subscription. One flat price per property,
platform usage included, so the bill is the row count times the rate and nothing else.

### What you get

One record per property.

| Field | What it is |
| --- | --- |
| `name` | Property name as Google lists it |
| `price` / `priceLabel` | Lowest nightly rate for the stay you asked for, as a number and as shown |
| `currency` | Currency you selected |
| `checkIn` / `checkOut` / `nights` / `adults` | The stay the price applies to |
| `hotelClass` / `propertyType` | Star class 1 to 5, and Google's own wording. Null for apartments and short lets |
| `rating` / `reviewCount` | Google guest rating out of 5, and how many reviews back it |
| `ratingBreakdown` | Share of reviews at each star level (stars, percent, count) |
| `reviewTopics` | What reviewers keep bringing up: Cleanliness, Sleep, Location, Noise |
| `amenities` | Amenity labels as shown, with the ($) marker kept when the amenity is paid |
| `neighborhood` / `areaPath` | The district, plus the full area hierarchy above it |
| `latitude` / `longitude` / `country` | Coordinates for mapping and distance work |
| `officialWebsite` | The property's own booking site, useful for direct-rate comparisons |
| `checkInTime` / `checkOutTime` | Arrival and departure times |
| `description` / `thumbnailUrl` | Google's one-line summary and a photo |
| `entityId` / `placeId` / `hotelUrl` | Stable ids so you can re-price the same property later, and the Google page |
| `searchQuery` / `sourceUrl` / `scrapedAt` | Where the row came from and when |

Fields are null when Google genuinely has no value. Nothing is guessed or filled in.

### Who uses it

**Revenue managers and hoteliers.** Pull your compset every morning for the next 30
check-in dates and see who moved their rate before you did. `entityId` stays stable,
so you can track the same eight competitors day after day without re-matching names.

**Travel agencies and tour operators.** Price a block of destinations for a fixed
date range in one run, in your own currency, and hand the client a rate sheet instead
of forty browser tabs.

**Price comparison and affiliate sites.** Seed a hotel database with names,
coordinates, star class, ratings, amenities and the property's own website, then
refresh the price column on whatever cadence you need.

**Market researchers and investors.** Measure what a market charges: average rate by
star class and neighbourhood, ratings distribution, how the amenity mix differs
between the 3-star and 4-star tier in the same district.

### Input

Only six fields, all optional except the destination.

```json
{
  "destinations": ["Paris", "Barcelona"],
  "checkIn": "2026-09-10",
  "checkOut": "2026-09-12",
  "adults": 2,
  "currency": "EUR",
  "maxResults": 60
}
```

Quick look at one destination, tonight's default rate, in dollars:

```json
{
  "destinations": ["Lisbon"],
  "maxResults": 20
}
```

Neighbourhood-level search, longer stay, family of four:

```json
{
  "destinations": ["hotels in Shibuya Tokyo", "hotels near Gatwick Airport"],
  "checkIn": "2026-11-02",
  "checkOut": "2026-11-06",
  "adults": 4,
  "currency": "GBP",
  "maxResults": 120
}
```

You can also paste a Google Hotels search URL into `destinations` and it will be used
as-is.

### Output sample

```json
{
  "name": "SO/ PARIS",
  "hotelClass": 5,
  "propertyType": "5-star tourist hotel",
  "rating": 4.5,
  "reviewCount": 1381,
  "price": 383.61,
  "priceLabel": "€384",
  "currency": "EUR",
  "checkIn": "2026-08-11",
  "checkOut": "2026-08-12",
  "nights": 1,
  "adults": 2,
  "amenities": ["Breakfast ($)", "Free Wi-Fi", "Parking ($)", "Air conditioning", "Pet-friendly", "Fitness center", "Spa", "Bar"],
  "reviewTopics": ["Bar", "Fitness", "Dining", "Nightlife", "Service", "Wellness"],
  "ratingBreakdown": [
    { "stars": 5, "percent": 80, "count": 1079 },
    { "stars": 4, "percent": 8, "count": 124 },
    { "stars": 3, "percent": 3, "count": 44 },
    { "stars": 2, "percent": 3, "count": 46 },
    { "stars": 1, "percent": 6, "count": 88 }
  ],
  "description": null,
  "officialWebsite": "https://so-hotels.com/en/paris/",
  "checkInTime": "3:00 PM",
  "checkOutTime": "12:00 PM",
  "neighborhood": "Arsenal",
  "areaPath": ["Paris Metropolitan Area", "Paris", "Arsenal"],
  "country": "FR",
  "latitude": 48.8500072,
  "longitude": 2.3624566,
  "thumbnailUrl": "https://lh5.googleusercontent.com/proxy/QmRL3Yh5fw9heJKDWVVU...",
  "entityId": "ChoIp7Pum_KXjO6zARoNL2cvMTFyam4yYzN0bhAB",
  "placeId": "0x47e671710a88ef17:0xb3dc30bf237b99a7",
  "hotelUrl": "https://www.google.com/travel/hotels/entity/ChoIp7Pum_KXjO6zARoNL2cvMTFyam4yYzN0bhAB",
  "searchQuery": "Paris",
  "sourceUrl": "https://www.google.com/travel/search?q=hotels+in+Paris&ucbcb=1",
  "scrapedAt": "2026-08-06T09:14:02.117Z"
}
```

### Pricing

Pay per event, with platform usage included in the price:

| Event | Price |
| --- | --- |
| Actor start | $0.001 per run |
| Property returned | $0.005 per property |

You are charged for properties you actually receive. A destination that returns
nothing costs you the start fee and nothing more, and duplicates across passes are
never billed twice. Bronze, Silver and Gold plan discounts all apply.

### FAQ

**Can I set the check-in and check-out dates?**
Yes, that is the point of the actor. `checkIn` and `checkOut` take YYYY-MM-DD dates
and the prices you get back are for exactly that stay. Leave them empty and Google
prices the next available night.

**How many properties do I get per destination?**
Google shows about 20 properties at a time and rotates which ones, so the actor makes
extra passes over the same destination to widen coverage and stops as soon as nothing
new comes back. In practice a single city settles around 50 to 60 distinct properties.
Raise `maxResults` and add more specific destinations (a neighbourhood, a district, an
airport) if you need deeper coverage of one city.

**Is the price per night or for the whole stay?**
`price` is the lowest nightly rate Google quotes for the stay, and `nights` tells you
how many nights that stay is.

**Does it include vacation rentals and apartments?**
Whatever Google lists for the destination, which usually mixes hotels, aparthotels and
some short lets. Those show up with `hotelClass` null, so you can filter them out in
one step if you only want classified hotels.

**Which currencies are supported?**
Eighteen of the common ones including USD, EUR, GBP, CAD, AUD, CHF, JPY and INR. The
prices are converted by Google, not by us.

**Do I need a Google API key or a Places API bill?**
No. There is nothing to set up and no key to rotate.

**Can I track the same hotels over time?**
Yes. `entityId` is stable per property, so schedule the run daily and join on it. The
`placeId` is the standard Google Maps id if you want to line the data up with a Maps
dataset you already have.

**What happens if Google rate-limits the scraper?**
The actor recognises Google's block page, rotates its exit IP and browser fingerprint,
escalates to a different proxy class, and if that is blocked too it stops the run and
keeps what it collected rather than burning your budget on retries. You are never
charged for properties that did not come back.

### Related actors

If you are building a travel or local-market dataset, these pair well with this one:

- [Airbnb Scraper](https://apify.com/tagadanar/airbnb-scraper) for short-let supply and calendars in the same city
- [Airbnb Occupancy, ADR & Market Report](https://apify.com/tagadanar/airbnb-str-yield) to turn that supply into revenue estimates
- [Google Trends Scraper](https://apify.com/tagadanar/google-trends-scraper) for demand seasonality on the destination itself

***

Keywords: google hotels scraper, hotel price scraper, hotel rate shopping, hotel rate
comparison, compset monitoring, revenue management data, hotel prices by date, google
travel scraper, hotel ratings and reviews data, hotel amenities dataset, travel price
monitoring, hotel API alternative, serpapi google hotels alternative.

# Actor input Schema

## `destinations` (type: `array`):

Where to look for hotels. A city, an area, a landmark or a neighbourhood works: Paris, Lisbon, Manhattan, near Gatwick Airport. You can also paste a Google Hotels search URL. One line per destination.

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

First night of the stay, as YYYY-MM-DD (for example 2026-09-10). Leave empty and Google prices the next available night.

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

Departure day, as YYYY-MM-DD. Leave empty for a one-night stay starting on the check-in date.

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

How many adults share the room. Prices are quoted for this occupancy.

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

Currency the nightly prices are quoted in.

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

Stop after this many properties across all destinations. Google shows about 20 per pass and rotates the selection, so the actor makes extra passes to widen coverage and stops when nothing new comes back.

## Actor input object example

```json
{
  "destinations": [
    "Paris",
    "Barcelona"
  ],
  "checkIn": "2026-09-10",
  "checkOut": "2026-09-12",
  "adults": 2,
  "currency": "USD",
  "maxResults": 20
}
```

# Actor output Schema

## `hotels` (type: `string`):

One item per property in the default dataset.

# 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 = {
    "destinations": [
        "Lisbon"
    ],
    "maxResults": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("tagadanar/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 = {
    "destinations": ["Lisbon"],
    "maxResults": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("tagadanar/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 '{
  "destinations": [
    "Lisbon"
  ],
  "maxResults": 20
}' |
apify call tagadanar/google-hotels-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/gQWgv3PmDOEhAwScK/builds/6MzzqLAQ880M1WjW2/openapi.json