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

Hotel search results from Google Hotels for any place and dates: nightly and total price in your currency, rating, review count, star class, amenities, deal tags and coordinates. Built for rate monitoring, travel research and AI agents.

- **URL**: https://apify.com/clearrun/google-hotels.md
- **Developed by:** [Clearrun Data](https://apify.com/clearrun) (community)
- **Categories:** Travel, Agents, MCP servers
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$2.00 / 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?

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

Search Google Hotels for any place and dates and get every result as structured JSON: nightly and total price in
the currency you choose, guest rating and review count, star class, amenities, deal tags ("20% less than usual"),
coordinates and the Google Hotels page of each property. Runs over plain HTTP, so a 50-hotel search takes seconds.

Typical uses: hotel rate monitoring and price benchmarking, travel research, market sizing for a destination, and
feeding live hotel data to AI agents ("find me a 4-star hotel in Lisbon under 150 EUR next weekend").

### What you get

```json
{
  "query": "hotels in Glasgow",
  "checkIn": "2026-10-16",
  "checkOut": "2026-10-18",
  "nights": 2,
  "adults": 2,
  "page": 1,
  "position": 2,
  "hotelId": "ChkIr8q45O36wuapARoML2cvMTFoMGM4Z3BrEAE",
  "name": "citizenM Glasgow",
  "price": 74,
  "currency": "GBP",
  "totalPrice": 179,
  "priceNote": "2 nights with taxes + fees",
  "includesTaxes": true,
  "dealTag": "DEAL",
  "dealText": "18% less than usual",
  "rating": 4.4,
  "reviewCount": 2560,
  "hotelClass": 4,
  "propertyType": "hotel",
  "amenities": ["Breakfast ($)", "Free Wi-Fi", "Air conditioning", "Parking", "Bar", "Restaurant", "Accessible"],
  "locationSummary": "Excellent location",
  "mentions": ["Property", "Service", "Bar"],
  "latitude": 55.8655679,
  "longitude": -4.2563978,
  "sponsored": false,
  "image": "https://lh3.googleusercontent.com/...",
  "url": "https://www.google.com/travel/hotels/entity/ChkIr8q45O36wuapARoML2cvMTFoMGM4Z3BrEAE",
  "searchUrl": "https://www.google.com/travel/search?q=hotels+in+Glasgow&hl=en&gl=us&ts=...",
  "scrapedAt": "2026-09-09T07:51:43.889Z"
}
```

| Field | Meaning |
|---|---|
| `price` / `currency` | Lowest nightly rate Google shows for the dates, as a number, in the requested currency. `null` when the property has no rate for those dates. |
| `totalPrice` | Price for the whole stay when Google shows it; `priceNote` says whether taxes and fees are included. |
| `dealTag` / `dealText` | Google's deal badge (`DEAL`, `GREAT DEAL`, `GREAT PRICE`) and the explanation ("20% less than usual"). |
| `rating` / `reviewCount` | Guest rating out of 5 and the exact number of reviews. |
| `hotelClass` / `propertyType` | Star class (1–5) and what the property is (hotel, apartment, hostel...). |
| `amenities` | The amenity highlights on the card, in the interface language. |
| `locationSummary`, `mentions` | Google's location verdict and the topics reviewers mention most. |
| `latitude` / `longitude` | Property coordinates. |
| `url` | The property's Google Hotels page. `hotelId` is the stable Google entity id. |

A `STATS` record in the run's key-value store holds the count and min, median, mean and max nightly price per search.

### Input

| Field | Default | Notes |
|---|---|---|
| `queries` | — | One search per line: "hotels in Glasgow", "Lisbon", "hotels near Times Square" |
| `checkIn` / `checkOut` | next Friday, 2 nights | `YYYY-MM-DD` |
| `adults` | `2` | 1–20 |
| `currency` | `USD` | Any ISO code Google supports (EUR, GBP, AUD, JPY...) |
| `maxResults` | `50` | Per search; pages of ~18 are fetched until reached |
| `minRating` | — | Keep only hotels rated at least this (0–5) |
| `minPrice` / `maxPrice` | — | Nightly price bounds in the selected currency |
| `language` / `country` | `en` / `us` | Google `hl` and `gl`; amenity names follow the language |
| `proxyConfiguration` | Apify datacenter proxy | Switch to `RESIDENTIAL` if runs start hitting captcha pages |

`minRating`, `minPrice` and `maxPrice` are applied to the results Google returns for the search, so a strict filter
may need a higher `maxResults` to fill up. Hotels with no rate for the dates are delivered with `price: null`.

### Pricing

Pay per hotel result delivered. Duplicates within a run are never charged; a search that returns nothing costs nothing.

#### Speed & cost

100 hotel results cost about $0.20. This actor runs over plain HTTP (no browser), so platform usage is small —
typically $0.01–0.05 for 100 results, leaving healthy margin under the $0.20 charged.

### Use from an AI agent

Available through the Apify MCP server: "Use google-hotels to list 4-star hotels in Lisbon for 10–12 October, 2
adults, in EUR, and tell me the three cheapest with a rating above 4.3."

Direct API call:

```bash
curl -X POST "https://api.apify.com/v2/acts/clearrun~google-hotels/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"queries":["hotels in Lisbon"],"checkIn":"2026-10-10","checkOut":"2026-10-12","currency":"EUR","maxResults":30}'
```

### Support

Open an issue on the Issues tab with the search, dates and run ID. Issues are answered within one working day.

# Actor input Schema

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

One search per line, as you would type it into Google Hotels: a place ("hotels in Glasgow", "Lisbon"), an area ("hotels near Times Square") or a property name.

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

YYYY-MM-DD. Leave empty for the next Friday.

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

YYYY-MM-DD. Leave empty for two nights after check-in.

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

Number of adult guests (1–20).

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

ISO 4217 code for the prices, e.g. USD, EUR, GBP, AUD.

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

Stop after this many hotels for each search. Google shows about 18 per page.

## `minRating` (type: `number`):

Only keep hotels rated at least this (0–5). Applied to the results Google returns.

## `minPrice` (type: `number`):

Only keep hotels with a nightly price at or above this, in the selected currency.

## `maxPrice` (type: `number`):

Only keep hotels with a nightly price at or below this, in the selected currency.

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

Google interface language (hl), e.g. en, de, fr, es. Amenity names follow this language.

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

Google market (gl), a two-letter country code such as us, gb, de.

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

Apify datacenter proxies work for Google Travel. Switch to RESIDENTIAL if runs start hitting captcha pages.

## Actor input object example

```json
{
  "queries": [
    "hotels in Glasgow"
  ],
  "adults": 2,
  "currency": "USD",
  "maxResults": 50,
  "language": "en",
  "country": "us",
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `results` (type: `string`):

One record per hotel result with price, rating and amenities

## `stats` (type: `string`):

Count and min, median, mean and max nightly price per search

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

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

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

```

## MCP server setup

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

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/HU1I4pdCb1B0pb0iM/builds/sWB05uglztNcCJdOY/openapi.json