# Google Hotels Prices: Rates, Ratings & Booking-Site Prices (`onibaku/google-hotels-prices`) Actor

Hotel prices from Google Hotels for any city or hotel name and your dates: lowest nightly rate, stay total with taxes, star class, rating, reviews, amenities and coordinates. Optionally every booking site's price (Booking.com, Expedia, the hotel's own site...) for rate parity checks.

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

## Pricing

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

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 Prices (rates, ratings and every booking site's price)

Get **hotel prices from Google Hotels** for any city, area or hotel name and the dates you choose. One clean row per
hotel: **lowest nightly rate, stay total with taxes and fees**, star class, guest rating, review count, amenities,
coordinates and website. Turn on booking-site prices and each row also lists **what Booking.com, Expedia, Agoda,
Hotels.com, the hotel's own website and every other booking site charge** for the same stay, with links.

It reads the public Google Hotels results anyone can see without logging in, so the prices are the ones travellers
see on Google for that market and currency.

### What it's for

- **Rate parity checks for hotels:** see whether OTAs undercut your own website for the dates that matter, every
  day. `isOfficialSite` marks your direct rate.
- **Competitor rate shopping:** track the prices of the five hotels down the road, by date and length of stay.
- **Travel startups and price alerts:** feed hotel prices for a destination into an app, a newsletter or a deals bot.
- **Analysts:** average nightly rates by city, star class and date, for events, seasonality or market reports.
- **AI agents:** one call answers "what does a 4-star in Lisbon cost next weekend?" (see MCP below).

### Input

| Field | What it does |
| --- | --- |
| `queries` | What you'd type into Google Hotels: `hotels in Edinburgh`, `hotels near Heathrow`, `4 star hotels in Lisbon`. |
| `hotelNames` | Specific hotels, best with the town: `The Balmoral, Edinburgh`. One row each. |
| `checkIn` | `YYYY-MM-DD`, or days from today (`30`), which keeps scheduled runs looking ahead. Empty means 30 days from today. |
| `checkOut` / `nights` | A check-out date, or a number of nights (default 1). Up to 30 nights. |
| `adults` | 1 to 6 (default 2). |
| `currency`, `language`, `country` | e.g. `GBP`, `en-GB`, `uk`. Defaults `USD`, `en`, `us`. Prices and booking sites can differ by market. |
| `minRating`, `maxPrice`, `starClass` | Keep hotels rated at least 3, 3.5, 4 or 4.5; under a nightly price; of chosen star classes. |
| `includeVacationRentals` | Google mixes apartments and holiday lets into searches. Off by default. |
| `includeProviderPrices` | Every booking site's price for each hotel, plus address and phone. Charged separately. |
| `maxResults` | Hotels per search (default 50). Google shows about 20 per page; the actor pages through. |
| `proxyConfiguration` | Apify Proxy by default. Switch to the RESIDENTIAL group if runs get blocked. |

**Cheapest 4 and 5-star hotels in Edinburgh, a month ahead:**

```json
{
    "queries": ["hotels in Edinburgh"],
    "starClass": ["4", "5"],
    "currency": "GBP",
    "country": "uk",
    "maxResults": 100
}
```

**Daily rate parity check for your hotel and two competitors, three weeks out, two nights (run on a schedule):**

```json
{
    "hotelNames": ["The Balmoral, Edinburgh", "The Caledonian, Edinburgh", "Kimpton Charlotte Square, Edinburgh"],
    "checkIn": "21",
    "nights": 2,
    "currency": "GBP",
    "country": "uk",
    "includeProviderPrices": true
}
```

### Output

One row per hotel:

```json
{
    "query": "The Balmoral, Edinburgh",
    "name": "The Balmoral, a Rocco Forte hotel",
    "type": "hotel",
    "googleHotelId": "ChUIl9v0gNTcqZQSGgkvbS8wN3NkenAQAQ",
    "placeId": "ChIJmb1xW1bHh0gRly0dQOWmKBI",
    "address": "1 Princes St., Edinburgh EH2 2EQ",
    "phone": "0131 556 2414",
    "latitude": 55.9530355,
    "longitude": -3.1895371,
    "starClass": 5,
    "rating": 4.7,
    "reviewCount": 3342,
    "lowestPrice": 535.5,
    "totalPrice": 1071,
    "totalBeforeTaxes": 892.5,
    "taxesAndFees": 178.5,
    "currency": "GBP",
    "checkIn": "2026-11-24",
    "checkOut": "2026-11-26",
    "nights": 2,
    "adults": 2,
    "cheapestProvider": "Evendo",
    "providerPrices": [
        { "provider": "The Balmoral Hotel", "pricePerNight": 584.56, "totalPrice": 1169.13, "isOfficialSite": true, "url": "https://..." },
        { "provider": "Evendo", "pricePerNight": 535.5, "totalPrice": 1071, "isOfficialSite": false, "url": "https://evendo.com/stays/..." },
        { "provider": "Booking.com", "pricePerNight": 603.75, "totalPrice": 1207.5, "isOfficialSite": false, "url": "https://www.google.com/travel/lodging/clk?..." }
    ],
    "amenities": ["Restaurant", "Bar", "Room service", "Indoor pool", "Fitness centre", "Spa", "Pet-friendly"],
    "website": "https://www.roccofortehotels.com/hotels-and-resorts/the-balmoral-hotel/",
    "hotelUrl": "https://www.google.com/travel/hotels/entity/ChUIl9v0gNTcqZQSGgkvbS8wN3NkenAQAQ?hl=en-GB&gl=uk&curr=GBP&ts=...",
    "searchUrl": "https://www.google.com/travel/search?q=The%20Balmoral%2C%20Edinburgh&hl=en-GB&gl=uk&curr=GBP&ts=...",
    "scrapedAt": "2026-10-25T23:40:12.000Z"
}
```

`lowestPrice` is the nightly price Google shows, with taxes and fees in; `totalPrice` is the whole stay. Without
`includeProviderPrices`, `providerPrices`, `cheapestProvider`, `address`, `phone` and `placeId` are `null` (for hotel
names, address and phone are usually filled anyway). `hotelUrl` opens the hotel on Google Hotels for the same dates
and guests.

### Pricing

**$0.0008 per hotel returned**, plus **$0.002 per hotel with booking-site prices** (`includeProviderPrices`), plus a
token $0.00005 per run. 1,000 hotels cost about $0.80; 1,000 hotels with every booking site's price about $2.80.
Hotels your filters drop, sold-out hotels and failed searches cost nothing.

### Good to know

- Prices are live: each run asks Google for your exact dates, guests, currency and market.
- Sold-out or unpriced hotels are left out of searches. A hotel you name is always returned, priced or not.
- Google doesn't list every booking site for every hotel, and which sites appear depends on `country`.
- Some booking-site links go straight to the site; others go through Google's own booking link. Paid-ad click links
  are left out.
- Amenities are the ones Google lists for the hotel. A few rarer amenities aren't named yet.
- Google limits how often one IP can search. The actor goes gently, and if Google asks to check for "unusual traffic"
  it retries on a fresh proxy IP a few times, then stops with a clear message. It never tries to solve those checks.
  If that happens often, use the RESIDENTIAL proxy group.

### Use it from Claude, ChatGPT or Cursor (MCP)

AI assistants can call this actor as a tool through Apify's MCP server. Add this server URL to your MCP client and
sign in with your Apify account when prompted:

```
https://mcp.apify.com?tools=onibaku/google-hotels-prices
```

### Data source

Google Hotels (google.com/travel), the public, logged-out results anyone can see. Prices come from the booking sites
and hotels that list on Google. Every row's `hotelUrl` links back to the hotel on Google Hotels. Not affiliated with
Google.

Questions or feature requests? Open an issue on the actor's Issues tab or email admin@onibaku.co.uk.

# Actor input Schema

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

What you'd type into Google Hotels, e.g. "hotels in Edinburgh", "hotels near Heathrow", "4 star hotels in Lisbon". Google understands words like star rating and area.

## `hotelNames` (type: `array`):

Hotel names, best with the town, e.g. "The Balmoral, Edinburgh". One row per hotel, with every booking site's price when "Include booking-site prices" is on.

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

YYYY-MM-DD, or a number of days from today (e.g. 30), which keeps scheduled runs looking ahead. Leave empty for 30 days from today.

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

YYYY-MM-DD or days from today. Leave empty to use "Nights".

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

Length of stay when no check-out date is given.

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

Number of adult guests per room (1 to 6).

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

Three-letter code, e.g. USD, GBP, EUR.

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

Google's language code, e.g. en, en-GB, de, fr. Affects names and amenity text.

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

Two-letter country Google prices for, e.g. us, uk, de. Booking sites and prices shown can differ by market.

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

Out of 5, like Google's own filter. Leave empty for any.

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

In your currency, taxes and fees included. Leave empty for any.

## `starClass` (type: `array`):

Only hotels with these star ratings. Leave empty for all.

## `includeVacationRentals` (type: `boolean`):

Google mixes apartments and holiday lets into searches. Off keeps hotels only.

## `includeProviderPrices` (type: `boolean`):

Every booking site's price for each hotel (Booking.com, Expedia, Agoda, the hotel's own site...), plus address and phone. One extra request per hotel, charged separately.

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

Google shows about 20 per page; we page through until we have this many.

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

Google limits busy IPs. Apify Proxy is the default; switch to the RESIDENTIAL group if runs get blocked.

## Actor input object example

```json
{
  "queries": [
    "hotels in Edinburgh"
  ],
  "nights": 1,
  "adults": 2,
  "currency": "USD",
  "language": "en",
  "country": "us",
  "includeVacationRentals": false,
  "includeProviderPrices": false,
  "maxResults": 50,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

## `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 Edinburgh"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("onibaku/google-hotels-prices").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 Edinburgh"],
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("onibaku/google-hotels-prices").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 Edinburgh"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call onibaku/google-hotels-prices --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,onibaku/google-hotels-prices"
        }
    }
}
```

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/CJ2yF2pUbSTxHGTth/builds/ggsumPTsV7MZvNAeL/openapi.json