# Google Hotels Scraper - Prices, Ratings & Hotel Results (`thirdwatch/google-hotels-scraper`) Actor

Scrape Google Hotels search results by destination, dates, guests, currency, and language. Get names, displayed prices, ratings, review counts, hotel class, images, details, and Google Travel URLs.

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

## Pricing

from $1.20 / 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.
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 a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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 — Prices, Ratings & Hotel Search Results

> Scrape Google Hotels search results by destination, landmark, neighborhood, or hotel name and export displayed prices, ratings, review counts, hotel class, images, and Google Travel URLs.

### What you get from the Google Hotels Scraper

Convert Google Hotels search results into structured hotel records for travel research, market mapping, lead generation, and price monitoring. Search several destinations in one run, add stay dates and guest details when needed, and export the dataset as JSON, CSV, Excel, XML, RSS, or HTML.

The Actor is optimized for fast hotel discovery. It captures the information displayed in search results without requiring you to open and copy each property page.

#### Quick start

1. Add a city, neighborhood, landmark, or hotel name to `queries`.
2. Optionally enter check-in and check-out dates.
3. Choose the number of adults, currency, language, and result limit.
4. Click **Start** and open the resulting hotel dataset.

### Google Hotels output fields

| Field | Description |
|---|---|
| `query` | Search query that produced the hotel |
| `name` | Hotel or accommodation name |
| `price` | Price displayed by Google for the selected search context, when available |
| `currency` | Requested three-letter display currency |
| `rating` | Public Google rating from 1 to 5, when available |
| `reviews_count` | Number of public reviews shown in the result, when available |
| `hotel_class` | Hotel class in stars, when available |
| `details` | Short result details such as hotel class or displayed card information |
| `image_url` | Hotel image URL shown in the search result, when available |
| `url` | Google Travel URL for the hotel or a matching hotel search |

Availability varies by destination, dates, language, and the information Google displays for each property.

### Example Google Hotels output

```json
{
  "query": "hotels near Tower Bridge London",
  "name": "The Tower Hotel, London",
  "price": "$189",
  "currency": "USD",
  "rating": 4.1,
  "reviews_count": 6421,
  "hotel_class": 4,
  "details": "4-star hotel",
  "image_url": "https://lh3.googleusercontent.com/example",
  "url": "https://www.google.com/travel/search?q=The+Tower+Hotel%2C+London"
}
````

### Google Hotels Scraper input parameters

| Parameter | Required | Default | Description |
|---|---:|---|---|
| `queries` | Yes | `hotels in London` | Cities, neighborhoods, landmarks, property names, or descriptive hotel searches. |
| `checkIn` | No | — | Check-in date in `YYYY-MM-DD` format. |
| `checkOut` | No | — | Check-out date in `YYYY-MM-DD` format. |
| `adults` | No | `2` | Number of adult guests, from 1 to 20. |
| `currency` | No | `USD` | Three-letter display currency such as `USD`, `EUR`, `GBP`, or `INR`. |
| `language` | No | `en` | Two-letter result language code such as `en`, `de`, `es`, or `fr`. |
| `maxResultsPerQuery` | No | `20` | Maximum hotel records returned for each query, from 1 to 200. |

#### Example input

```json
{
  "queries": [
    "hotels near Tower Bridge London",
    "family hotels in Edinburgh"
  ],
  "checkIn": "2026-09-14",
  "checkOut": "2026-09-17",
  "adults": 2,
  "currency": "GBP",
  "language": "en",
  "maxResultsPerQuery": 50
}
```

### Google Hotels data use cases

- **Travel agencies and destination teams:** Build inventories of accommodation options around destinations and attractions.
- **Revenue and market analysts:** Compare displayed hotel prices across dates, currencies, neighborhoods, and search segments.
- **Hotel operators:** Monitor how properties and competitors appear in Google Hotels searches.
- **Lead-generation teams:** Create property lists for hospitality partnerships and outreach enrichment.
- **Developers and data teams:** Feed hotel search results into dashboards, maps, alerts, and scheduled pipelines.

### Google Hotels Scraper limitations

- Prices are the values displayed by Google for the selected query, dates, guests, currency, and location context. They are not a booking quote and can change quickly.
- Some properties do not display a price, rating, review count, class, or image in every search.
- The Actor focuses on hotel search results. It does not currently collect room-level offers, amenities, contact details, full reviews, or booking-provider inventories.
- Broad queries can overlap. Use specific neighborhoods, landmarks, star classes, or hotel names to expand coverage with less duplication.
- Google can vary result order and availability by region and time.

### Compared to other Google Hotels scrapers

- Compared with `scrapapi/google-hotels-scraper`, this Actor is designed for lean search-result collection rather than fetching multiple property subpages and deep amenity records.
- Compared with `scrapesage/google-hotels-scraper`, this Actor keeps the input and output focused on hotel discovery, displayed prices, ratings, and links instead of optional review and room-offer expansion.
- Choose this Actor when you want a simple, scalable hotel-search dataset. Choose a deep property crawler when room offers, amenities, reviews, or booking-provider links are mandatory.

### Google Hotels Scraper FAQ

#### Can I search several destinations in one run?

Yes. Add multiple entries to `queries`. The result row retains its originating query so datasets remain easy to segment.

#### Can I search for a specific hotel?

Yes. Use the property name, optionally with its city or neighborhood, as a query.

#### Are the prices live booking prices?

They are prices publicly displayed by Google for the selected search context. Always verify the final rate, taxes, availability, and conditions with the booking provider.

#### Can I choose another currency or language?

Yes. Set `currency` to a three-letter code and `language` to a two-letter language code.

#### Does it return hotel reviews or amenities?

It returns the search-result rating and review count when displayed. It does not currently fetch full review text or a complete amenity inventory.

#### Can I automate hotel price monitoring?

Yes. Run the Actor on an Apify schedule, keep dates consistent or roll them forward, and send each dataset to your database, webhook, spreadsheet, or alerting workflow.

### Related Thirdwatch Actors

- [Booking.com Hotel Scraper](https://apify.com/thirdwatch/booking-hotel-scraper) — hotel listings and booking-focused data
- [Tripadvisor Scraper](https://apify.com/thirdwatch/tripadvisor-scraper) — travel listings, ratings, and reviews
- [Google Maps Scraper](https://apify.com/thirdwatch/google-maps-scraper) — business discovery, addresses, websites, and local data

Explore more travel and business data tools from [Thirdwatch](https://thirdwatch.dev/).

**Last verified: 2026-07**

# Actor input Schema

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

Cities, neighborhoods, landmarks, or hotel names to search.

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

Optional check-in date in YYYY-MM-DD format.

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

Optional check-out date in YYYY-MM-DD format.

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

Number of adult guests used for availability and pricing.

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

Three-letter display currency, for example USD, EUR, GBP, or INR.

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

Two-letter result language code.

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

Maximum hotel records returned for each query.

## Actor input object example

```json
{
  "queries": [
    "hotels in London"
  ],
  "adults": 2,
  "currency": "USD",
  "language": "en",
  "maxResultsPerQuery": 20
}
```

# 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 London"
    ]
};

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

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Google Hotels Scraper - Prices, Ratings & Hotel Results",
        "description": "Scrape Google Hotels search results by destination, dates, guests, currency, and language. Get names, displayed prices, ratings, review counts, hotel class, images, details, and Google Travel URLs.",
        "version": "1.1",
        "x-build-id": "g9yl2gySkY6GgPDjt"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/thirdwatch~google-hotels-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-thirdwatch-google-hotels-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/thirdwatch~google-hotels-scraper/runs": {
            "post": {
                "operationId": "runs-sync-thirdwatch-google-hotels-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/thirdwatch~google-hotels-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-thirdwatch-google-hotels-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "queries"
                ],
                "properties": {
                    "queries": {
                        "title": "Destinations or Hotel Queries",
                        "type": "array",
                        "description": "Cities, neighborhoods, landmarks, or hotel names to search.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "checkIn": {
                        "title": "Check-in Date",
                        "type": "string",
                        "description": "Optional check-in date in YYYY-MM-DD format."
                    },
                    "checkOut": {
                        "title": "Check-out Date",
                        "type": "string",
                        "description": "Optional check-out date in YYYY-MM-DD format."
                    },
                    "adults": {
                        "title": "Adults",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "Number of adult guests used for availability and pricing.",
                        "default": 2
                    },
                    "currency": {
                        "title": "Currency",
                        "type": "string",
                        "description": "Three-letter display currency, for example USD, EUR, GBP, or INR.",
                        "default": "USD"
                    },
                    "language": {
                        "title": "Language",
                        "type": "string",
                        "description": "Two-letter result language code.",
                        "default": "en"
                    },
                    "maxResultsPerQuery": {
                        "title": "Maximum Hotels per Query",
                        "minimum": 1,
                        "maximum": 200,
                        "type": "integer",
                        "description": "Maximum hotel records returned for each query.",
                        "default": 20
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
