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

Scrape Google Hotels data: prices, ratings, star class, amenities, coordinates, photos and booking links for any city or hotel. Compare rates by dates, guests and currency. Export to JSON, CSV or Excel.

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

## Pricing

from $1.50 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

### What is Google Hotels Scraper?

**Google Hotels Scraper** is a hotel data scraper that lets you extract hotel listings from Google Hotels for any city or place: the price Google displays, a numeric price, the usual rate when Google shows a deal, guest rating, review count, star class, coordinates, photo, and Google Maps and Google Hotels links. It's made for travel and hospitality analysts, revenue managers, travel startups and developers who need structured hotel price data without copying it by hand. Just type a place name such as `Paris` (or paste a Google Hotels search link), pick your dates and click **Start**: no coding, Google account or API key needed, and on the Apify Free plan each run returns up to 10 hotels.

What you can use it for:

- **Hotel revenue management:** check the displayed prices, ratings and star class of competing hotels nearby on the dates that matter to you.
- **Hotel rate shopping across cities and dates:** compare the one price Google displays per hotel across several cities, stay dates, guest counts or currencies in a single run.
- **Hotel price monitoring:** schedule the same search daily or weekly and compare the runs. Each run is a snapshot of what Google shows at that moment.
- **Hotel market research:** see how many hotels a place has, their star classes, price ranges and guest ratings.
- **Maps and dashboards:** every hotel comes with latitude and longitude, so you can map hotels and filter them by rating, review count or star class in a spreadsheet or BI tool.
- **AI and data pipelines:** send the structured JSON to LLMs, AI agents (MCP) or analytics pipelines.

#### What can Google Hotels Scraper do?

As a Google Hotels extractor, it reads the result pages of every search you add, page after page, until your limits or the end of the results.

- 🔍 **Scrape by place name or link:** one search per line, with as many lines as you need in one run.
- 📅 **Choose the stay:** check-in and check-out dates (1 to 30 nights), 1 to 9 adults, a three-letter currency, a language and the country Google Hotels is searched from.
- ⭐ **Ratings and class:** guest rating out of 5, review count, star class label and star number.
- ⚡ **Live output:** each hotel is saved the moment it is read, so the **Output** tab fills during the run and saved hotels are kept if the run stops early.
- 📦 **Export Google Hotels data** to JSON, CSV, Excel, XML or HTML, with five ready-made table views.
- 🔌 **Use it as a hotel data API:** start runs via the Apify API, schedule and monitor them, and connect Make, Zapier, Google Sheets and more.
- 🛡️ **Proxy handled for you:** runs start without a proxy, and the Actor can switch to Apify Proxy on its own if Google blocks requests or requests keep failing after retries.

***

### What data can Google Hotels Scraper extract?

Google Hotels Scraper lets you extract Google Hotels data for every hotel on the result pages of your search. Each hotel is one row with these fields:

| | |
|---|---|
| 🏨 Hotel name `name` | 💲 Displayed price `price` |
| 💲 Numeric price `priceValue` | 💱 Currency code `currency` |
| 🏷️ Usual rate when a deal is shown `compareRate` | ⭐ Guest rating out of 5 `rating` |
| 📝 Number of guest reviews `reviewCount` | ⭐ Star class label `hotelClass` |
| ⭐ Star class number (1 to 5) `starRating` | 📍 Latitude `latitude` |
| 📍 Longitude `longitude` | 🆔 Google place ID `placeId` |
| 📝 Short description `hotelDescription` | 📸 Main photo URL `imageUrl` |
| 🔗 Google Maps link `googleMapsUrl` | 🔗 Google Hotels link `googleHotelsUrl` |
| 📍 Search location `location` | 📅 Check-in date `checkInDate` |
| 📅 Check-out date `checkOutDate` | 🕒 Collection time in UTC `scrapedAt` |

**What the price means:** `price` is the price text Google Hotels displays for that hotel, for your dates, guests, country and currency. The output table labels it as the price per night. `priceValue` is the same figure as a number, without the currency symbol. The Actor doesn't add or remove taxes or fees, so whatever Google includes in its displayed figure is what you get. `compareRate` is the usual rate Google compares a deal against. The Actor calculates it from the deal percentage Google shows, on the same basis as `price`.

These Google Hotel prices are one displayed price per hotel, which makes this hotel price data easy to sort, chart and compare.

> **Note:** Every row has all 20 fields. `name`, `currency`, `latitude`, `longitude`, `googleHotelsUrl`, `location`, `checkInDate`, `checkOutDate` and `scrapedAt` are always filled. The other fields are `null` when Google doesn't publish them for that hotel and stay, for example no price for your dates, no star class, or no deal (then `compareRate` is empty). `googleMapsUrl` is `null` when a hotel has no place ID. The dates and currency in each row are the ones Google actually priced, which can differ from your input if Google didn't apply a setting.

#### What data can't Google Hotels Scraper extract?

- Guest review texts (you get the rating and the review count)
- Amenities
- Prices from each booking site or room-level rates: you get the one price Google displays per hotel
- The total price of the whole stay (you get the displayed price, labeled per night in the output)
- Phone numbers, emails, websites or street addresses
- Price history or price alerts: each run is a snapshot (schedule runs to build your own history)
- Details from single-hotel pages (single-hotel links are not supported)
- Flights or other travel data (for flight fares, see [Google Flights Prices API](https://apify.com/insights_data/google-flights-prices-api))

***

### How to scrape Google Hotels prices

Here's how to scrape hotel data from Google Hotels within a few minutes. This hotel price scraper runs in Apify Console, so you don't need to write code.

1. [Create a free Apify account](https://console.apify.com/sign-up) using your email.
2. Open [Google Hotels Scraper](https://apify.com/insights_data/google-hotels-scraper).
3. Fill in the input form:
   - In **Google Hotels URLs or places**, type a city or area such as `Paris`, one per line. That's all most people need.
   - Optional: paste a Google Hotels search link instead. To get one, open [Google Hotels](https://www.google.com/travel/hotels) in your browser, search for a city or area, and copy the address from your browser's address bar. Links to a single hotel don't work.
   - Set **Check-in date**, **Check-out date**, **Adults** and **Currency**.
   - Set **Country code** (`countryCode`, default `us`): the two-letter country Google Hotels is searched from, for example `gb` or `de`. Prices and availability can differ by country, so pick the country whose prices you want to see.
4. Click **Start**. Hotels appear in the **Output** tab while the run is going.
5. Download your data in JSON, CSV, Excel, XML or HTML.

Want to scrape hotel prices for several cities at once? Add one place per line. Each line becomes its own Google Hotels search with the same dates, guests and currency.

***

### How much does it cost to scrape Google Hotels?

Google Hotels Scraper uses **pay-per-event** pricing. You pay for the hotels saved to your dataset, a tiny start fee per run, and the Apify platform usage of your run.

| Event | Price |
|---|---|
| 💲 Result (one hotel saved to the dataset) | **$2.75 per 1,000 results** ($0.00275 per hotel) on the Free plan (lower on paid plans, see below) |
| 🚀 Actor start | A tiny start fee of **$0.00005 per run** at the default memory |

| Apify plan | Price per hotel | Price per 1,000 hotels |
|---|---|---|
| Free | $0.00275 | $2.75 |
| Starter | $0.00225 | $2.25 |
| Scale | $0.002 | $2.00 |
| Business and higher | $0.0015 | $1.50 |

Paid Apify plans get a lower price per hotel. The plan discount applies to that price only. The start fee is the same on every plan, and platform usage is billed at your Apify plan's own rates.

About the start fee: it's priced at $0.00005 per GB of memory the run is given. GB (gigabyte) is the amount of computer memory the run uses, and the default is 1 GB, so a run costs $0.00005 to start. You don't need to change the memory setting.

**Apify platform usage** (the computing resources your run uses) is paid by you on top of the event prices. It depends on the run, so there's no fixed number for it. You can see it on the run's detail page in Apify Console. We recommend a small test run first (one place, default `maxResults` of 10) to see the real total, then scale up.

Example result costs at the Free plan price (the start fee and platform usage come on top):

| Hotels saved | Result cost |
|---|---|
| 10 | $0.0275 |
| 40 (the input example below: 2 searches × 20 hotels; needs a paid plan, so the real cost is lower, see the plan table above) | $0.11 |
| 100 | $0.275 |
| 1,000 | $2.75 |

On paid plans, use the prices in the plan table above. See the [pricing tab](https://apify.com/insights_data/google-hotels-scraper/pricing) for the current events.

What counts as a charged result:

- Every saved hotel is charged, even when some fields are empty (for example, no price shown for your dates).
- Duplicates are removed only within one search. The same hotel can be saved and charged again when another search returns it, for example `Paris` plus a Paris link with other dates or another currency.
- Identical input lines (same place, dates, adults and currency) run only once.
- Searches that return no hotels add no result charges.

#### Is scraping Google Hotels free?

You can try it for free. The Apify Free plan includes $5 of monthly platform credit, which pays for both the event charges above and the platform usage of your runs.

Separately, the Actor itself limits Free plan runs: each run saves up to **10 hotels** in total across all searches. This cap applies per run, no matter how much credit you have left. When the cap is reached, the run stops and still finishes with a success status. The run log always shows the free plan's 10-hotel limit and how many hotels the run used. When you ask for more than 10 hotels per search (or set `maxResults` to `0`), the status message at the top of the run also adds a "Free plan: up to 10 hotels per run" note. Paid plans don't have this cap; your `maxResults`, the page limit and your spend limit still apply.

***

### Google Hotels Scraper input

To run Google Hotels Scraper, you only need **one or more place names or Google Hotels links** in `urls`. Every other field has a default, so you can start with a single line.

Here's an example that searches New York (as a Google Hotels link) and Paris (as a place name) for 2 adults from 10 to 12 December 2026, in US dollars, with up to 20 hotels per search:

```json
{
  "urls": [
    "https://www.google.com/travel/hotels/New%20York",
    "Paris"
  ],
  "checkInDate": "2026-12-10",
  "checkOutDate": "2026-12-12",
  "adults": 2,
  "currency": "USD",
  "maxResults": 20
}
```

> ⚠️ **On the Free plan, this example stops after 10 hotels overall, not 40.** The 10 hotels are shared by all searches in the run, first come, first served, so they may not be spread evenly across your places, and one place may get all of them. For a fair comparison of several cities on the Free plan, run one place per run. The run still ends with a success status; the status message and the log show that the free plan limit was reached.

See the [input tab](https://apify.com/insights_data/google-hotels-scraper/input-schema) for a full description of all fields.

| Field | What it does | Default |
|---|---|---|
| `urls` | Place names or Google Hotels city/area search links, one per line (required) | none |
| `checkInDate` | First night, `YYYY-MM-DD` | empty = today + 30 days |
| `checkOutDate` | Day you leave, `YYYY-MM-DD`; must be after check-in; stays of up to 30 nights | empty = check-in + 2 nights |
| `adults` | Adult guests the prices are quoted for (1 to 9) | `2` |
| `pastDatePolicy` | What to do when check-in is today or earlier: `shift`, `error` or `googleDefault` | `shift` |
| `currency` | Three-letter currency code | `USD` |
| `languageCode` | Language of descriptions and labels, for example `en`, `fr`, `de`, `es`, `pt-BR` | `en` |
| `countryCode` | Two-letter country Google Hotels is searched from; prices and availability can differ by country | `us` |
| `maxResults` | Max hotels per search (0 to 10,000) | `10` |
| `maxPagesPerLocation` | Max result pages read per search (1 to 200) | `10` |
| `requestTimeoutSecs` | Seconds to wait for each request (5 to 120) | `30` |
| `maxRetries` | Retries for a failed or blocked request (0 to 10) | `3` |
| `proxyConfiguration` | Optional proxy to start the run on | no proxy |

#### Google Hotels URLs or places (`urls`)

Each line is one search. You can type a place name or paste a Google Hotels search link for a city or area. To get a link, search for a city on Google Hotels and copy the address from your browser's address bar.

- ✅ Good: `Paris`, `New York`, `https://www.google.com/travel/hotels/New%20York`
- ❌ Bad: a link to a single hotel, or a link from another website. These lines are skipped with a warning in the log.

Values inside a pasted link: dates from a link are used only if the link has both a check-in and a check-out date; otherwise the form dates apply. Adults and currency in a link override the form values for that line.

The `location` field in the output shows your input place name, lightly tidied (for links, the place in the link). If Google resolves your place name to a different place, a warning is logged and the results are for the place Google picked.

> ⚠️ Identical lines (same place, dates, adults and currency) run only once. If no line is usable, the run fails.

#### Check-in and check-out dates (`checkInDate`, `checkOutDate`, `pastDatePolicy`)

If you leave the dates empty (also when you start the Actor through the API without dates), the stay is today + 30 days for 2 nights. A stay can be 1 to 30 nights, and check-out must be after check-in. Invalid form dates stop the run before any search starts; invalid dates inside a link only skip that line.

When the check-in date is today or earlier, **Past dates handling** (`pastDatePolicy`) decides what happens:

- `shift` (default): both dates move forward by one year at a time until the check-in date is in the future. The length of the stay stays the same.
- `error`: a past form date stops the run; a past date inside a link skips that line.
- `googleDefault`: Google picks its own dates, and each row shows the dates Google actually priced.

> ⚠️ **Watch out for the default `shift`.** If you enter a past date by mistake (for example, last year instead of this year), the run doesn't stop. It moves your stay forward by a year and only writes a warning in the log. Check `checkInDate` in the output rows, or set **Past dates handling** to **Stop with an error** (`error`) if you'd rather have the run refuse past dates.

A check-in date more than 330 days ahead only logs a warning, because Google may not show prices that far ahead.

- ✅ Good: `"checkInDate": "2026-12-10"` and `"checkOutDate": "2026-12-12"`
- ❌ Bad: a check-out date on or before the check-in date, or a stay longer than 30 nights

#### Max hotels per search (`maxResults`)

`maxResults` counts per search (per line), not per run. `0` means no hotel limit of your own; the page limit and the other limits still apply. A search stops at the page limit (`maxPagesPerLocation`, default 10, maximum 200; failed page loads count as pages), at the end of Google's results, at the Free plan cap, at your spend limit, when result pages keep failing to load, or when Google can't be reached.

- ✅ Good: `20` for a quick test, or `0` together with a page limit that fits your budget
- ❌ Bad: expecting `0` to return every hotel listed for a city

> ⚠️ Every saved hotel is charged. Use `maxResults` to control your spend.

#### Currency (`currency`)

Use a three-letter code such as `EUR` or `GBP`. A code Google Hotels doesn't support falls back to `USD`, and a currency inside a pasted link overrides the form value for that line. Each row's `currency` field shows the currency actually used.

- ✅ Good: `EUR`
- ❌ Bad: `EURO`

#### Proxy (`proxyConfiguration`)

You don't need a proxy to start. The Actor can switch to Apify Proxy on its own if Google blocks requests or requests keep failing after retries. Choose a proxy (Apify Proxy or your own proxy URLs) only if you want the run to start on it.

***

### Google Hotels Scraper output

Results are stored in a dataset in the **Output** or **Storage** tab. You can view them as a table or JSON, pick only the fields you need, and download them in JSON, CSV, Excel, XML or HTML. Five views help you focus: **Overview**, **Prices & deals**, **Ratings & class**, **Location & links** and **All fields** (every column). When at least one hotel is saved, the run also stores every saved hotel in one combined `OUTPUT` JSON file in the run's key-value store (the **Storage** tab), which is handy if you want a single file.

Run the same input for several places and you get a hotel pricing dataset with the same columns for every city and date.

#### JSON example

Results for the input example above. This is one hotel from the New York search. Its coordinates are on the New Jersey side of the Hudson River: Google's results for a place can include hotels just outside it, and the `location` field still shows your input place name, `New York`.

```json
[
  {
    "name": "Shefah Hotels",
    "price": "$110",
    "priceValue": 110,
    "currency": "USD",
    "compareRate": 189.72,
    "rating": 4.27,
    "reviewCount": 216,
    "hotelClass": "3-star hotel",
    "starRating": 3,
    "latitude": 40.76981910000001,
    "longitude": -74.02876069999999,
    "placeId": "0x89c25828391bcba1:0x7d256e53b0edb357",
    "hotelDescription": "Snug quarters, some with shared bathrooms, in a straightforward hotel featuring Wi-Fi.",
    "imageUrl": "https://lh3.googleusercontent.com/grass-cs/ACvplmNicSC8cLCV1Z2Ki-tovP1KQYE8AswVHA71u2EUHKIGt6w5HeBcXQPo_xrDO5z3nycxGt4Q4i5OJ4LbeLlEMzmzFT1jMC_CO2ZSmJjn1F8uf67WZu8HfAkpHfJyBovY8ZjyZvG_=s287-w287-h192-n-k-no-v1",
    "googleMapsUrl": "https://www.google.com/maps?cid=9017735134608995159&hl=en",
    "googleHotelsUrl": "https://www.google.com/travel/hotels/entity/ChkI1-a2h7vK25J9Gg0vZy8xMWdibDM3c3FxEAE?hl=en&gl=us&curr=USD…",
    "location": "New York",
    "checkInDate": "2026-12-10",
    "checkOutDate": "2026-12-12",
    "scrapedAt": "2026-10-07T18:44:47Z"
  }
]
```

`googleHotelsUrl` opens the hotel on Google Hotels with your stay, language, country and currency, so you can compare rates and book there.

***

### Google Hotels Scraper tips and advanced usage

#### How many hotels can Google Hotels Scraper return?

The number depends on how many hotels Google lists for the place and dates, your `maxResults` and `maxPagesPerLocation`, the Free plan cap of 10 hotels per run, your spend limit, and whether Google can be reached. The best way to know for your city is a quick test run with the default settings.

#### How to track hotel prices over time

Google Hotels Scraper has no built-in price history or alerts; each run is a snapshot of the prices Google shows at that moment. To track hotel prices over time, save your input as a task and [schedule it](https://docs.apify.com/platform/schedules) daily or weekly. Every run creates a new dataset with `scrapedAt`, so you can line up runs in a spreadsheet or BI tool. Used this way, the Actor works as a simple hotel price tracking tool for the cities and dates you choose.

#### How to get faster or cheaper results

To keep your Google Hotels scraping costs low:

- Start with one or two places and the default `maxResults` of 10.
- Lower `maxPagesPerLocation` to cap how many result pages each search reads.
- Avoid overlapping searches (for example `Paris` plus a Paris link with other dates), because the same hotel saved in two searches is charged twice.
- Set a maximum cost per run in the run options. When the spend limit is reached, the run stops cleanly and keeps the hotels already saved.
- Leave `proxyConfiguration` on its default unless you have a reason to start on a proxy.

#### Known issues

- The same hotel can be saved and charged more than once if two different searches return it.
- Hotels with empty fields (for example, no price for your dates) are still saved and charged.
- If Google ignores a requested setting, the rows carry the dates and currency Google actually used, and a warning is logged.
- If the network can't reach Google after many failed requests, the run stops sending requests and keeps the hotels already saved. If nothing was saved, the run fails with "Google could not be reached".
- A run that finds no hotels finishes with the status "No hotels found. Check the place names, dates and currency." instead of failing.

#### What to do if the run fails with "Google could not be reached"

1. Run it again a bit later. The problem can be temporary, and the Actor already switches to Apify Proxy on its own when Google blocks requests.
2. If you set your own proxy URLs in `proxyConfiguration`, check that they work, or switch to Apify Proxy or the default (no proxy).
3. If it keeps failing, open an issue on the [Issues tab](https://apify.com/insights_data/google-hotels-scraper/issues/open) and include your run link.

***

### Integrations and API

#### Can I use Google Hotels Scraper as a Google Hotels API?

Yes. Through the [Apify API](https://docs.apify.com/api/v2), Google Hotels Scraper works like a Google Hotels search API: you send the input as JSON, start a run, and read the hotels back from the dataset. You can call it from any language. Use the `apify-client` [NPM package](https://apify.com/insights_data/google-hotels-scraper/api/javascript) for Node.js or the `apify-client` [PyPI package](https://apify.com/insights_data/google-hotels-scraper/api/python) for Python, and see the [API tab](https://apify.com/insights_data/google-hotels-scraper/api) for ready-to-use code.

API runs that leave out `checkInDate` and `checkOutDate` use today + 30 days for 2 nights, so send the dates you want.

#### Google Hotels Python example

This short script runs the input above and prints each hotel:

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_API_TOKEN>")
run_input = {
    "urls": ["https://www.google.com/travel/hotels/New%20York", "Paris"],
    "checkInDate": "2026-12-10",
    "checkOutDate": "2026-12-12",
    "adults": 2,
    "currency": "USD",
    "maxResults": 20,
}
run = client.actor("insights_data/google-hotels-scraper").call(run_input=run_input)

for hotel in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(hotel["name"], hotel["price"], hotel["rating"])
```

If your app needs a hotel price API of its own, you can run this from your backend on a schedule and serve the saved rows to your users.

#### Can I integrate Google Hotels Scraper with other apps?

Yes. Connect Google Hotels Scraper with other apps through [Apify integrations](https://apify.com/integrations): **Make, Zapier, Slack, Google Sheets, Google Drive, Airbyte, GitHub, LangChain** and more. Use [webhooks](https://docs.apify.com/integrations/webhooks) to trigger actions when a run finishes. For example, schedule a morning run for your city and send the new rows to Google Sheets, where your team checks the day's prices.

#### Can I use Google Hotels Scraper with AI agents (MCP)?

Yes. Connect Google Hotels Scraper to Claude and other AI assistants through the Apify MCP server. Open the [MCP tab](https://apify.com/insights_data/google-hotels-scraper/api/mcp) for setup steps. The agent fills in the input and reads the hotels back as JSON.

***

### Other scrapers from Insights Data

These Actors from the same author cover Google Flights fares and other Google, price-monitoring and market-research data:

| Actor | What it does |
|---|---|
| ✈️ [Google Flights Prices API](https://apify.com/insights_data/google-flights-prices-api) | Gets live fares, schedules, stops, layovers, airlines, CO2 and booking options for one-way, round-trip and multi-city routes |
| 📢 [Google Ads Transparency Center Scraper & API](https://apify.com/insights_data/google-ads-transparency-center-scraper-api) | Extracts ads across Search, YouTube, Shopping, Maps and Play by brand, domain or advertiser ID, for competitor ad intelligence |
| 🛒 [Flipkart Product Scraper](https://apify.com/insights_data/flipkart-product-scraper) | Scrapes Flipkart products by keyword or category URL (prices, discounts, ratings, specs, sellers, offers) for price monitoring and competitive analysis |
| ⭐ [Flipkart Reviews Scraper](https://apify.com/insights_data/flipkart-reviews-scraper) | Scrapes Flipkart product reviews, star ratings, photos and rating summaries in bulk |
| 📈 [Stocktwits Scraper](https://apify.com/insights_data/stocktwits-scraper) | Scrapes Stocktwits stock and crypto messages, bullish/bearish sentiment, price targets and trending symbols |
| 🚀 [Y Combinator Scraper](https://apify.com/insights_data/y-combinator-scraper) | Extracts company profiles, founders, open roles, press and Launch YC posts from Y Combinator's public directory |
| 💼 [Welcome to the Jungle Jobs Scraper](https://apify.com/insights_data/welcome-to-the-jungle-jobs-scraper) | Scrapes Welcome to the Jungle jobs by keyword, location, salary, remote or direct URLs |

***

### Google Hotels Scraper FAQ

#### Is it legal to scrape Google Hotels?

Google Hotels Scraper only reads public search results that anyone can see without logging in. Whether scraping hotel data is allowed for your project depends on your country, the data you collect and how you use it. Respect personal data rules such as GDPR and take [Google's Terms of Service](https://policies.google.com/terms) into account. This is not legal advice; if you're unsure, ask a lawyer.

#### How does Google Hotels Scraper work?

It's a Google Hotels crawler that works like a visitor browsing Google Travel hotels, only faster. You add place names or search links and pick the stay. The Actor checks your input, turns every line into one search (skipping unusable or repeated lines), and opens the public Google Hotels results for each place with your dates, guests, currency, language and country. It reads the hotels on each results page, removes duplicates within the search, saves each hotel to the dataset right away, and moves on to the next page until your limits or the end of the results.

#### How is Google Hotels Scraper different from the Google Hotel Prices API?

They solve different problems. [Google's Hotel APIs documentation](https://developers.google.com/hotels) describes Hotel Prices as documentation for sending hotel prices to Google. Google Hotels Scraper works in the other direction: it reads the public hotel results that Google Hotels shows.

| | Google Hotels Scraper | Google's official Hotel Prices API |
|---|---|---|
| Direction | Reads public Google Hotels search results | Sends hotel prices to Google |
| What you get | Hotel rows with price, rating, star class, coordinates and links | Documented for sending hotel prices to Google |
| Who it's for | Anyone with an Apify account, no coding | Businesses that send hotel prices to Google |

If you're looking for a hotel price comparison API that returns what travelers see in search results, this Actor is the closer fit. Keep in mind that it lines up the one displayed price per hotel, not the prices from each booking site.

#### Why scrape Google Hotels data?

Web scraping hotel prices saves you from checking Google Hotels by hand, city by city:

- **Hotel price intelligence:** see what Google displays for competing hotels on the dates you sell.
- **Google Hotels price comparison:** compare the displayed price of the same hotels across dates, cities, guest counts or currencies.
- **Hotel rate comparison inside a market:** rank the hotels of one place by price, rating and star class.
- **Travel products:** fill travel sites, apps or spreadsheets with up-to-date hotel listings.
- **Research and reporting:** support market reports and hotel revenue management decisions with real listings instead of manual checks.

#### Can I use Google Hotels Scraper as a hotel price tracker?

Yes, by scheduling runs. There is no built-in history or alert, so to track hotel prices you run the same input on a schedule and compare the datasets by `scrapedAt`. Over a few weeks, these scheduled runs give you your own Google Hotels price tracker for the places you care about.

#### Does Google Hotels Scraper return prices from each booking site?

No. You get the one price Google displays per hotel (`price` and `priceValue`), plus the usual rate in `compareRate` when Google shows a deal. Per-booking-site price lists and room-level rates are not included.

#### Why am I getting fewer results than expected?

- Check `maxResults`: it is per search, and the default is 10.
- On the Free plan, a run saves at most 10 hotels, shared across all searches.
- Raise `maxPagesPerLocation` if your searches stop at the page limit.
- Check the place names and dates. Google may list fewer hotels for some places or dates, and invalid lines are skipped with a warning in the log.
- Look for a warning that Google resolved your place name to a different place.
- Check whether the run hit your spend limit.

#### Can I paste a link to a single hotel?

No. This hotel scraper works with place names or search links for a city or area. Links to a single hotel are skipped with a message in the log.

***

### Support and feedback

Found a bug or have a feature request? Please create an issue on the [Issues tab](https://apify.com/insights_data/google-hotels-scraper/issues/open) and include your run link.

Need a **custom solution**, another field or help with a travel data scraping project? Contact us at hello.insights.data@gmail.com.

Built and maintained by [Insights Data](https://apify.com/insights_data).

# Changelog

This Actor's version history is a separate document: https://apify.com/insights_data/google-hotels-scraper/changelog.md

# Actor input Schema

## `urls` (type: `array`):

One search per line. Paste a Google Hotels search link (a city or area search copied from the address bar, for example https://www.google.com/travel/hotels/Paris) or just type a place name such as Paris or New York. Links that already contain stay dates, guests or a currency use those values for that search. Links to a single hotel are not supported.

## `checkInDate` (type: `string`):

First night of the stay in YYYY-MM-DD format. Leave empty to use 30 days from today.

## `checkOutDate` (type: `string`):

Day you leave, in YYYY-MM-DD format. It must be after the check-in date. Leave empty to stay 2 nights.

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

Maximum number of hotels to return for each link or place. 0 means everything Google lists for that place. Free plan: up to 10 hotels per run in total. Paid plans have no limit.

## `maxPagesPerLocation` (type: `integer`):

Hard stop on how many result pages are read for one search, even if more hotels are available.

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

Number of adult guests the prices are quoted for (1 to 9).

## `pastDatePolicy` (type: `string`):

What to do when the check-in date is today or earlier. Shift moves the stay forward by whole years until it is in the future, Stop with an error refuses to run, and Let Google choose uses the dates Google picks itself (every row reports the dates Google actually priced).

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

Three-letter currency code prices are shown in, for example USD, EUR or GBP. Unsupported codes fall back to USD.

## `languageCode` (type: `string`):

Language of hotel descriptions and labels, for example en, fr, de or es.

## `countryCode` (type: `string`):

Two-letter country Google Hotels is searched from, for example us, gb or de. Prices and availability can differ by country.

## `requestTimeoutSecs` (type: `integer`):

How long to wait for each request before it counts as failed.

## `maxRetries` (type: `integer`):

How many times a failed or blocked request is retried. After the Actor has moved to residential proxy it always retries at least 3 times.

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

By default requests are sent without a proxy. If Google blocks a request, the Actor switches to Apify datacenter proxy, then to residential proxy, and stays on the stronger proxy for the rest of the run. Choose a proxy here only if you want to start on it.

## Actor input object example

```json
{
  "urls": [
    "https://www.google.com/travel/hotels/New%20York",
    "Paris"
  ],
  "maxResults": 10,
  "maxPagesPerLocation": 10,
  "adults": 2,
  "pastDatePolicy": "shift",
  "currency": "USD",
  "languageCode": "en",
  "countryCode": "us",
  "requestTimeoutSecs": 30,
  "maxRetries": 3,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

Photo, name, price, rating, class and stay for every hotel.

## `prices` (type: `string`):

Nightly price, price value, usual rate and currency.

## `ratings` (type: `string`):

Guest rating, review count, star class and description.

## `location` (type: `string`):

Coordinates, place ID, Google Maps and Google Hotels links.

## `all` (type: `string`):

Every field of every hotel.

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

The complete, unfiltered dataset items as JSON.

## `combined` (type: `string`):

All hotels of this run in one JSON file.

# 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 = {
    "urls": [
        "https://www.google.com/travel/hotels/New%20York",
        "Paris"
    ],
    "checkInDate": "",
    "checkOutDate": "",
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("insights_data/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 = {
    "urls": [
        "https://www.google.com/travel/hotels/New%20York",
        "Paris",
    ],
    "checkInDate": "",
    "checkOutDate": "",
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("insights_data/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 '{
  "urls": [
    "https://www.google.com/travel/hotels/New%20York",
    "Paris"
  ],
  "checkInDate": "",
  "checkOutDate": "",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call insights_data/google-hotels-scraper --silent --output-dataset

```

## MCP server setup

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