# Google Hotels Scraper (`kawsar/google-hotels-scraper`) Actor
Google Hotels Scraper extracts hotel prices, ratings, exact review counts, and amenities from Google Hotels search results, so travel marketers, price analysts, and SEO teams can compare properties and track rates across any city or date.
- **URL**: https://apify.com/kawsar/google-hotels-scraper.md
- **Developed by:** [Kawsar](https://apify.com/kawsar) (community)
- **Categories:** Travel, Developer tools, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet
## Pricing
from $3.99 / 1,000 results
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: Extract Hotel Prices, Ratings, and Reviews at Scale
Google Hotels Scraper collects hotel data from Google Hotels search results and returns it as a clean, structured dataset. Give it any location or hotel search, set your check-in and check-out dates, and it pulls back hotel names, nightly prices, guest ratings, exact review counts, star class, amenities, deal badges, and thumbnails. It is a practical Google Hotels data extraction tool for anyone who tracks accommodation pricing, builds travel products, or does market research.
No API key and no proxy setup. Paste one or more searches, run it, and export the results to JSON, CSV, or Excel.
### What this actor does
Google Hotels is a JavaScript-heavy search product with no public API, so the data is hard to get at in bulk. This actor drives a real browser, opens each search the way a person would, pages through the results, and reads every hotel card into a tidy row. You get consistent fields you can sort, filter, and feed into a spreadsheet or a pricing model.
- Search by city, region, landmark, neighborhood, or a specific hotel name
- Set check-in and check-out dates and the number of adults
- Collect price, rating, exact review count, star class, amenities, and more
- Page through results up to the limit you set, with duplicates removed
- Export to JSON, CSV, Excel, or an API feed through Apify
### Use cases
- **Hotel price monitoring**: track nightly rates across cities and dates to spot pricing trends and seasonal swings
- **Competitor rate tracking**: watch how rival properties price rooms and adjust your own rates with real market data
- **Travel market research**: gather ratings, reviews, and amenities to understand what drives bookings in a region
- **SEO and content**: build hotel comparison pages, city guides, and listings backed by fresh Google Hotels data
- **Revenue management**: feed structured hotel prices into your pricing models and dashboards
- **Affiliate and OTA sites**: keep large hotel catalogs current with names, ratings, and price signals
### Input
| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `searchQueries` | array | required | Locations or hotel searches, one per line, for example "Hotels in New York". |
| `checkInDate` | string | empty | Check-in date in YYYY-MM-DD format. Leave empty to let Google pick default dates. |
| `checkOutDate` | string | empty | Check-out date in YYYY-MM-DD format. |
| `adults` | integer | 2 | Number of adult guests to price the stay for. |
| `currency` | string | USD | Preferred currency code, such as USD, EUR, or GBP. Google may still display its own currency (see notes). |
| `gl` | string | us | Two-letter country code for the Google region. |
| `hl` | string | en | Two-letter language code for result text. |
| `maxItems` | integer | 50 | Maximum hotels to collect per search query, up to 1000. |
| `timeoutSecs` | integer | 300 | Overall run time budget in seconds. |
| `requestTimeoutSecs` | integer | 60 | Page load timeout per query in seconds. |
#### Example input
```json
{
"searchQueries": ["Hotels in New York", "Beach resorts in Bali"],
"checkInDate": "2026-08-01",
"checkOutDate": "2026-08-03",
"adults": 2,
"currency": "USD",
"gl": "us",
"hl": "en",
"maxItems": 100
}
````
### What data does this actor extract?
The actor stores results in a dataset. Each entry describes one hotel:
```json
{
"searchQuery": "Hotels in New York",
"name": "The Manhattan at Times Square Hotel",
"price": 289,
"priceText": "$289",
"currency": "$",
"rating": 3,
"reviewsCount": 10109,
"hotelClass": "4-star hotel",
"hotelType": "Hotel",
"amenities": ["Breakfast ($)", "Free Wi-Fi", "Parking ($)", "Air conditioning", "Fitness center", "Restaurant"],
"dealLabel": "GREAT PRICE",
"priceNote": "22% less than usual",
"thumbnail": "https://lh3.googleusercontent.com/...",
"detailsUrl": "https://www.google.com/travel/...",
"checkInDate": "2026-08-01",
"checkOutDate": "2026-08-03",
"scrapedAt": "2026-07-09T04:32:00+00:00"
}
```
| Field | Type | Description |
|-------|------|-------------|
| `searchQuery` | string | The search query this hotel was returned for. |
| `name` | string | Hotel or property name. |
| `price` | number | Nightly price as a number. |
| `priceText` | string | Raw price text as shown on Google Hotels, including the currency symbol or code. |
| `currency` | string | Currency symbol or code Google displayed for the price. |
| `rating` | number | Average guest rating out of 5. |
| `reviewsCount` | integer | Exact number of guest reviews. |
| `hotelClass` | string | Star class of the property when Google shows one, for example "4-star hotel". |
| `hotelType` | string | Property type, Hotel or Vacation rental. |
| `amenities` | array | Amenities shown for the property, such as Free Wi-Fi, Pool, or Parking. |
| `dealLabel` | string | Deal badge such as DEAL, GREAT PRICE, or GREAT DEAL, when shown. |
| `priceNote` | string | Price context such as "22% less than usual" or "for a 4-star hotel", when shown. |
| `thumbnail` | string | URL of the property thumbnail image. |
| `detailsUrl` | string | Link to the property page on Google Hotels. |
| `checkInDate` | string | Check-in date used for the price lookup. |
| `checkOutDate` | string | Check-out date used for the price lookup. |
| `scrapedAt` | string | UTC timestamp when the record was scraped. |
### How it works
1. You provide one or more search queries, plus optional dates, guest count, and currency.
2. The actor opens each Google Hotels search in a real browser and clears the cookie consent screen.
3. It reads every hotel card on the page, then clicks through to the next page of results until it reaches your `maxItems` limit.
4. For each property it parses the name, price, exact rating and review count, star class, amenities, deal badge, and thumbnail.
5. Duplicates are removed and every hotel is saved to the dataset, ready to export.
### Tips for best results
- **Keep queries specific.** "Hotels in Lisbon" or "Boutique hotels in Rome" return cleaner sets than very broad terms.
- **Always set dates.** Prices depend on check-in and check-out. Without them Google picks its own default range, so your prices may not match what you expect.
- **Use `maxItems` to control cost.** Google paginates about 20 hotels per page. A limit of 100 loads roughly five pages. Higher limits take longer.
- **Run multiple cities in one go.** Add one query per line in `searchQueries` and the actor handles each search in turn.
- **Schedule it.** Use Apify Schedules to re-run daily or weekly and build a price history over time.
### Notes and limits
- **Currency follows the run's location.** Google shows prices in the currency tied to the request's region, so the `currency` field reports what Google actually displayed, which may differ from the `currency` you requested.
- **Some fields are only present when Google shows them.** Budget or independent listings may have no star class or amenity list. Those values come back empty or null rather than breaking the run.
- **Coordinates and full addresses are not in the search view.** Google only exposes those on individual property pages, so they are not included here.
- **Layouts change.** Google updates its markup from time to time. The actor is built to degrade gracefully and logs a clear message with a saved screenshot if a page ever stops matching.
### FAQ
**Does this scrape live Google Hotels prices?**
Yes. Each run loads Google Hotels in a browser for the dates you set, so prices reflect what Google shows at that moment.
**How many hotels can it collect per query?**
Set `maxItems`, up to 1000 per query. Google shows about 20 per page, and the actor pages through until it hits your limit.
**Do I need a proxy or an API key?**
No. The actor runs without any proxy or key. Just provide your search queries and run it.
**Can I scrape several cities at once?**
Yes. Add one query per line in `searchQueries` and each search is scraped in turn, with results tagged by `searchQuery`.
**Why is the currency not the one I picked?**
Google prices in the currency tied to the request's location. The `currency` field always reports what Google actually displayed.
**What if a field is empty?**
Google does not show every detail for every property. Missing values come back empty or null, and the rest of the record is still complete.
### Integrations
Connect Google Hotels Scraper with other apps and services using [Apify integrations](https://apify.com/integrations). You can integrate with Make, Zapier, Slack, Airbyte, GitHub, Google Sheets, Google Drive, and many more. You can also use [webhooks](https://docs.apify.com/integrations/webhooks) to trigger actions whenever results are available.
Start scraping Google Hotels today to turn live hotel prices, ratings, and reviews into data you can act on.
# Actor input Schema
## `searchQueries` (type: `array`):
Locations or hotel searches to look up on Google Hotels, one per line. For example a city, region, landmark, or specific hotel name.
## `checkInDate` (type: `string`):
Check-in date in YYYY-MM-DD format. Leave empty to let Google pick default upcoming dates.
## `checkOutDate` (type: `string`):
Check-out date in YYYY-MM-DD format. Leave empty to let Google pick default upcoming dates.
## `adults` (type: `integer`):
Number of adult guests to price the stay for.
## `currency` (type: `string`):
Currency code for prices, such as USD, EUR, or GBP.
## `gl` (type: `string`):
Two-letter country code that sets the Google region, such as us, gb, or de. Affects available hotels and pricing.
## `hl` (type: `string`):
Two-letter language code for result text, such as en, es, or fr.
## `maxItems` (type: `integer`):
Cap on how many hotels to collect for each search query. Keeps run time and cost predictable.
## `timeoutSecs` (type: `integer`):
Overall time budget for the whole run before it stops.
## `requestTimeoutSecs` (type: `integer`):
How long to wait for a single Google Hotels page to load before giving up on it.
## Actor input object example
```json
{
"searchQueries": [
"Hotels in London",
"Beach resorts in Bali"
],
"checkInDate": "2026-08-01",
"checkOutDate": "2026-08-03",
"adults": 2,
"currency": "USD",
"gl": "us",
"hl": "en",
"maxItems": 20,
"timeoutSecs": 300,
"requestTimeoutSecs": 60
}
```
# 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 '' with your token
const client = new ApifyClient({
token: '',
});
// Prepare Actor input
const input = {
"searchQueries": [
"Hotels in New York"
],
"checkInDate": "2026-08-01",
"checkOutDate": "2026-08-03",
"adults": 2,
"currency": "USD",
"gl": "us",
"hl": "en",
"maxItems": 20,
"timeoutSecs": 300,
"requestTimeoutSecs": 60
};
// Run the Actor and wait for it to finish
const run = await client.actor("kawsar/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 '' with your token.
client = ApifyClient("")
# Prepare the Actor input
run_input = {
"searchQueries": ["Hotels in New York"],
"checkInDate": "2026-08-01",
"checkOutDate": "2026-08-03",
"adults": 2,
"currency": "USD",
"gl": "us",
"hl": "en",
"maxItems": 20,
"timeoutSecs": 300,
"requestTimeoutSecs": 60,
}
# Run the Actor and wait for it to finish
run = client.actor("kawsar/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 '{
"searchQueries": [
"Hotels in New York"
],
"checkInDate": "2026-08-01",
"checkOutDate": "2026-08-03",
"adults": 2,
"currency": "USD",
"gl": "us",
"hl": "en",
"maxItems": 20,
"timeoutSecs": 300,
"requestTimeoutSecs": 60
}' |
apify call kawsar/google-hotels-scraper --silent --output-dataset
```
## MCP server setup
```json
{
"mcpServers": {
"apify": {
"command": "npx",
"args": [
"mcp-remote",
"https://mcp.apify.com/?tools=kawsar/google-hotels-scraper",
"--header",
"Authorization: Bearer "
]
}
}
}
```
## OpenAPI specification
```json
{
"openapi": "3.0.1",
"info": {
"title": "Google Hotels Scraper",
"description": "Google Hotels Scraper extracts hotel prices, ratings, exact review counts, and amenities from Google Hotels search results, so travel marketers, price analysts, and SEO teams can compare properties and track rates across any city or date.",
"version": "0.0",
"x-build-id": "Deme812rvNBh1uF58"
},
"servers": [
{
"url": "https://api.apify.com/v2"
}
],
"paths": {
"/acts/kawsar~google-hotels-scraper/run-sync-get-dataset-items": {
"post": {
"operationId": "run-sync-get-dataset-items-kawsar-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/kawsar~google-hotels-scraper/runs": {
"post": {
"operationId": "runs-sync-kawsar-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/kawsar~google-hotels-scraper/run-sync": {
"post": {
"operationId": "run-sync-kawsar-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": [
"searchQueries"
],
"properties": {
"searchQueries": {
"title": "Search queries",
"type": "array",
"description": "Locations or hotel searches to look up on Google Hotels, one per line. For example a city, region, landmark, or specific hotel name.",
"items": {
"type": "string"
}
},
"checkInDate": {
"title": "Check-in date",
"type": "string",
"description": "Check-in date in YYYY-MM-DD format. Leave empty to let Google pick default upcoming dates."
},
"checkOutDate": {
"title": "Check-out date",
"type": "string",
"description": "Check-out date in YYYY-MM-DD format. Leave empty to let Google pick default upcoming dates."
},
"adults": {
"title": "Adults",
"type": "integer",
"description": "Number of adult guests to price the stay for.",
"default": 2
},
"currency": {
"title": "Currency",
"enum": [
"USD",
"EUR",
"GBP",
"CAD",
"AUD",
"JPY",
"INR",
"BRL",
"MXN",
"SGD"
],
"type": "string",
"description": "Currency code for prices, such as USD, EUR, or GBP.",
"default": "USD"
},
"gl": {
"title": "Country (gl)",
"type": "string",
"description": "Two-letter country code that sets the Google region, such as us, gb, or de. Affects available hotels and pricing.",
"default": "us"
},
"hl": {
"title": "Language (hl)",
"type": "string",
"description": "Two-letter language code for result text, such as en, es, or fr.",
"default": "en"
},
"maxItems": {
"title": "Maximum hotels per query",
"minimum": 1,
"maximum": 1000,
"type": "integer",
"description": "Cap on how many hotels to collect for each search query. Keeps run time and cost predictable.",
"default": 20
},
"timeoutSecs": {
"title": "Run timeout (seconds)",
"minimum": 30,
"maximum": 3600,
"type": "integer",
"description": "Overall time budget for the whole run before it stops.",
"default": 300
},
"requestTimeoutSecs": {
"title": "Page load timeout (seconds)",
"minimum": 10,
"maximum": 180,
"type": "integer",
"description": "How long to wait for a single Google Hotels page to load before giving up on it.",
"default": 60
}
}
},
"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
}
}
}
}
}
}
}
}
}
}
```