# Google Hotels Scraper (`uber_byte/google-hotels-scraper`) Actor

Scrape Google Hotels search results: hotel name, address, coordinates, star class, rating, reviews, nightly and total prices, per-provider prices (Booking.com, Expedia, official site...), amenities and photos. Any dates, guests, currency and filters.

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

## Pricing

from $2.00 / 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.

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

Export Google Hotels search results for any city, neighborhood or landmark, with hotel names, coordinates, star class, guest ratings, nightly and total prices, and each booking site's price (Booking.com, Expedia, Hotels.com, Agoda, the hotel's official site and more). Revenue managers use it for rate parity checks and price monitoring, and travel researchers use it to size up a destination. You choose the dates, guests, currency, language and country, and you need no Google account or API key.

### What you get

One row per hotel with:

- Name, Google hotel ID, Google Hotels URL, one-line description and website
- Latitude and longitude, plus the Google Maps feature ID
- Star class, guest rating and review count
- Lowest nightly price, nightly price with taxes and fees, total for the stay with and without fees, and the currency
- Check-in and check-out dates for the search, and check-in and check-out times when Google lists them
- Amenities (in the language you pick) and photo URLs
- With **Include per-provider prices** on (the default): full address, phone number and the offer list from the hotel's Prices tab, with each provider's name, official-site flag, nightly price, price with fees, total for the stay and booking link

### Use cases

- **Rate parity checks:** compare the hotel's official price with Booking.com, Expedia and other OTAs for the same stay.
- **Price monitoring:** schedule runs for fixed dates and track how rates move as the stay gets closer.
- **Destination research:** measure hotel supply, star mix and average rates in a city.
- **Hotel lists:** build lists with coordinates, websites and phone numbers for maps, lead generation or data enrichment.

### How to use the Google Hotels scraper

1. Open the Actor in Apify Console.
2. Enter one or more searches, as you'd type them into Google Hotels, for example `hotels in Lisbon` or `hotels near Eiffel Tower`.
3. Set check-in and check-out dates, adults and children, and the currency. Leave the dates empty to use Google's default dates.
4. Add filters if you want them: star class, minimum and maximum nightly price, and minimum guest rating. Set **Max hotels per query**.
5. Click **Start**, then download the results as JSON, CSV, Excel or HTML, or read them through the Apify API.

### Input example

```json
{
  "queries": ["hotels in Lisbon"],
  "checkIn": "2026-11-10",
  "checkOut": "2026-11-13",
  "adults": 2,
  "currency": "EUR",
  "hotelClass": ["4", "5"],
  "minRating": "4",
  "maxItems": 100,
  "includeProviders": true
}
```

Other fields: `children` (sent to Google as 10 years old), `hl` and `gl` for Google's language and country (default `en` and `us`), and `minPrice` and `maxPrice` for the nightly price range in your currency.

### Output example

```json
{
  "name": "Patio São Vicente Guest Houses",
  "hotelId": "ChkIn4CU6sjxgJ1YGg0vZy8xMWY0XzdqenhqEAE",
  "url": "https://www.google.com/travel/hotels/entity/ChkIn4CU6sjxgJ1YGg0vZy8xMWY0XzdqenhqEAE",
  "address": "Telheiro de S. Vicente 10A, 1100-594 Lisboa, Portugal",
  "phone": "+351 965 404 627",
  "website": "https://www.patiosaovicente.com/",
  "latitude": 38.7155846,
  "longitude": -9.1280593,
  "hotelClass": 4,
  "hotelClassText": "4-star hotel",
  "rating": 4.9,
  "reviewCount": 347,
  "currency": "EUR",
  "lowestPrice": 118.24,
  "lowestPriceWithFees": 133,
  "totalPrice": 355,
  "totalPriceWithFees": 400,
  "checkInDate": "2026-11-10",
  "checkOutDate": "2026-11-13",
  "checkInTime": "3:00 PM",
  "checkOutTime": "11:00 AM",
  "amenities": ["Free Wi-Fi", "Air conditioning", "Breakfast", "Parking", "Airport shuttle"],
  "images": ["https://lh3.googleusercontent.com/..."],
  "providers": [
    { "name": "Expedia.com", "isOfficialSite": false, "price": 118.24, "priceWithFees": 133.35, "totalPrice": 354.71, "totalPriceWithFees": 400.04, "url": "https://www.google.com/travel/lodging/clk?..." }
  ],
  "query": "hotels in Lisbon"
}
```

- `lowestPrice` is the lowest nightly price Google shows. `totalPrice` covers the whole stay. The `...WithFees` fields include taxes and fees as Google reports them.
- Provider `url` values are Google's redirect links to the booking site, as they appear on Google.
- `address`, `phone` and `providers` are `null` when **Include per-provider prices** is off.
- `checkInTime` and `checkOutTime` appear only when Google lists them for the property (about 2 in 3 hotels in our tests).

### Pricing

You pay per hotel saved, with no monthly rental. A hotel saved with provider prices and address counts as a `hotel-with-prices` result, and one saved without them counts as a `hotel` result. Hotels your filters remove aren't charged. Set a maximum spend per run and the Actor stops once it reaches the limit.

### FAQ

**Is it legal to scrape Google Hotels?**
The Actor reads the same public pages anyone sees at google.com/travel/hotels, without logging in. Google's terms govern automated access and reuse of its results, so review them and ask a lawyer about your use case, especially before you republish prices.

**Do I need a Google account?**
No.

**Will Google block it? Which proxy should I use?**
Google rate-limits datacenter IPs, so the default is Apify residential proxy in the US. The Actor spots "unusual traffic" and consent pages, switches to a new session and retries, up to six times per page.

**Does it use a browser?**
No. It reads the structured data Google embeds in the page, which keeps runs fast.

**How do the filters work?**
Google applies star class, maximum price and the 3.5+, 4.0+ and 4.5+ rating filters itself. The Actor applies the minimum price afterwards, so strict filters may make it read several pages to find enough matches.

**Can I scrape a single hotel?**
Search for its name, for example `Four Seasons Ritz Lisbon`. The hotel is usually the first result.

**Does it work in other languages and currencies?**
Yes. Set `hl`, `gl` and `currency`. It has been tested with `fr`/`fr`/`JPY` and `en`/`us`/`EUR`.

**What are the limits?**

- Google shows about 18 to 20 hotels per results page. The Actor follows pagination until it reaches **Max hotels per query** or Google runs out of results.
- Prices, providers and availability are what Google shows at scrape time for your dates and guests. Some properties only show "Contact this property" and have no providers.
- If a hotel's Prices page still fails after retries, that hotel is left out of the results.
- Google changes its internal data layout from time to time. The parser matches records by their shape rather than fixed keys to survive small changes, but a large change can break it until the Actor is updated.

# Actor input Schema

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

What you would type into Google Hotels, e.g. "hotels in Lisbon", "hotels near Times Square", "Paris 4 star hotels".

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

YYYY-MM-DD. Leave empty (together with check-out) to use Google's default dates.

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

YYYY-MM-DD.

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

Adults.

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

Children are sent to Google as 10 years old.

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

ISO code, e.g. USD, EUR, GBP, JPY.

## `hl` (type: `string`):

Language (hl).

## `gl` (type: `string`):

Country (gl).

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

In the chosen currency.

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

In the chosen currency.

## `hotelClass` (type: `array`):

Only hotels with these star ratings.

## `minRating` (type: `string`):

Min guest rating.

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

Maximum number of results to return. See the README for whether this applies per search or to the whole run.

## `includeProviders` (type: `boolean`):

Opens each hotel's prices page to add every booking site's price (Booking.com, Expedia, official site...), full address and phone. One extra request per hotel.

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

Google rate-limits datacenter IPs. Residential (US) is the default and recommended.

## Actor input object example

```json
{
  "queries": [
    "hotels in Lisbon"
  ],
  "adults": 2,
  "children": 0,
  "currency": "USD",
  "hl": "en",
  "gl": "us",
  "maxItems": 50,
  "includeProviders": true,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}
```

# Actor output Schema

## `results` (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": [
        "hotels in Lisbon"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("uber_byte/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 Lisbon"] }

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

```

## MCP server setup

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