# Hotel Price Scraper — hotel prices for any city & dates (`lergassy/hotel-price-scraper`) Actor

\[$3/1K hotels] Hotel price scraper: for any city and dates get every hotel's nightly price, stay total and total with taxes for your exact stay, with rating, reviews, star class and a link to the cheapest booking site. Optional per-site offers. No login, no browser.

- **URL**: https://apify.com/lergassy/hotel-price-scraper.md
- **Developed by:** [Matvey](https://apify.com/lergassy) (community)
- **Categories:** Travel, E-commerce, Agents
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.10 / 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/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

**Hotel Price Scraper** returns hotel prices for any city and any dates: for every hotel, the **nightly price, the stay total and the total with taxes and fees** for the exact stay you search, with the guest **rating and review count**, star class, property type, amenities, coordinates, photos and a **booking link to the cheapest site** Google found. The prices come from **Google Hotels**, which compares Booking.com, Expedia, Agoda, Hotels.com, Trip.com, the hotels' own sites and many smaller sellers. **No login, no browser, no API key.**

It runs on the same engine as our [Google Hotels Scraper](https://apify.com/lergassy/google-hotels-scraper) and is set up for one job: a price list for a place and a stay, fast and cheap. A run with an empty input lists 20 hotels in Paris for a stay a month out, so you can see the output before you type anything.

### What you get per hotel

| Field | Example | Notes |
|---|---|---|
| `name` | H10 Marina Barcelona hotel | |
| `pricePerNight` | 102.34 | the cheapest rate Google found for your dates, per night |
| `totalPrice`, `totalWithTaxes` | 205, 280.59 | the whole stay; `totalWithTaxes` is the all-in total |
| `priceBeforeTaxes`, `taxesAndFees` | 204.69, 75.91 | when Google itemises them |
| `currency` | EUR | any code Google supports |
| `checkIn`, `checkOut`, `nights`, `adults` | 2026-12-04, 2026-12-06, 2, 3 | what the price was quoted for |
| `hotelClass`, `propertyType` | 4, hotel | |
| `rating`, `reviewCount` | 4.3, 4495 | Google's aggregate, 5-point scale |
| `amenities` | \["Free Wi-Fi", "Outdoor pool", "Spa", …] | |
| `address`, `latitude`, `longitude` | | |
| `bookingUrl`, `hotelUrl` | | the booking link goes to the cheapest seller for your stay |
| `location`, `searchRank` | Barcelona, Spain, 1 | the place you searched and the row's position |
| `datesNote` | no checkIn given — searched 2026-11-09 | only when the dates were filled in or corrected for you |

A field Google did not show for a hotel is left empty, never guessed.

### How to use it

1. Type one or more places in **Where to search** — a city (`Lisbon, Portugal`), a district (`Shibuya, Tokyo`) or a landmark (`hotels near Eiffel Tower`).
2. Set **Check-in** and **Check-out** (`YYYY-MM-DD`). Leave them empty and a stay 30 days ahead is searched; a date in the past is moved forward and the row says so.
3. Optional filters: adults, currency, sort order (lowest price, highest rating, most reviewed), star class, minimum rating, maximum price per night, pool only.
4. Click **Start** and download JSON, CSV or Excel, or pull the rows through the Apify API into Google Sheets, n8n, Make, Zapier or an AI agent.

Google shows 20 hotels per page. This Actor also walks Google's own sort orders, star classes and price bands and removes duplicates, so one city can return well over a hundred hotels: on 10 October 2026 a run for Tokyo returned **120 different hotels in 26 seconds**.

#### Input example

```json
{
  "locations": ["Barcelona, Spain"],
  "checkIn": "2026-12-04",
  "checkOut": "2026-12-06",
  "adults": 3,
  "currency": "EUR",
  "sortBy": "lowest_price",
  "hotelClass": ["4", "5"],
  "minRating": "4",
  "maxPricePerNight": 300,
  "maxHotelsPerLocation": 15
}
```

On 10 October 2026 this returned 15 four-star hotels rated 4.0 or higher, all under €300 a night, cheapest first, in 4 seconds.

### Per-site offers (optional add-on)

Turn on **read each hotel's page** to add, for each hotel, the list of booking sites with their price and a deep link (Booking.com, Expedia, Agoda, Trip.com, the hotel's own site …), plus the full amenity list, address, phone and review scores per source.

Be aware of one limit before you rely on it: **Google prices that list for the stay it picks itself, not for your dates** (on 10 October 2026 it was usually the next night). Each row carries `offersCheckIn` and `offersCheckOut` so you can see which stay the offers are for. The price for your own dates is always in `pricePerNight` and `totalWithTaxes`. If you need every site's price for your exact dates, this add-on does not give it.

### How much does it cost?

Priced **per hotel row**, with **no start fee**. Error rows and empty answers are never charged.

| Event | Free plan | Gold plan |
|---|---|---|
| Hotel | **$3.00 per 1,000** | $2.10 per 1,000 |
| Hotel page read (add-on) | $8.00 per 1,000 | $5.60 per 1,000 |

A city of 100 hotels costs $0.30. The Apify free plan's $5 monthly credit covers about 1,600 hotel rows.

### Limits

- Prices are what Google Hotels shows at the moment of the run for the given market (`market`, default US) and currency. Sellers change rates often; schedule the Actor if you want a price history.
- A place name Google cannot resolve is not guessed: you get one free error row asking for a fuller name (for example `Springfield, Illinois`).
- Vacation rentals appear when Google lists them; their price is the cheapest offer Google shows for them.

### Related Actors

- [Google Hotels Scraper](https://apify.com/lergassy/google-hotels-scraper) — the same engine with every option and the full field list, including guest reviews.
- [Booking.com Hotel Search Scraper](https://apify.com/lergassy/booking-hotels-scraper) — hotels and prices straight from Booking.com.
- [Trip.com Scraper](https://apify.com/lergassy/tripcom-scraper) — hotels and prices from Trip.com.

### FAQ

**Is there an official Google Hotels API?** No public one. This Actor reads the same data the Google Hotels page loads in your browser.

**Can I run it from code or an AI agent?** Yes. Call it through the Apify API with any of the fields above; an empty call returns a sample of 20 Paris hotels.

**Something does not work?** Open an issue on the Actor's Issues tab with the run link and we will look at it.

# Changelog

This Actor's version history is a separate document: https://apify.com/lergassy/hotel-price-scraper/changelog.md

# Actor input Schema

## `locations` (type: `array`):

Required unless you give `hotelUrls`. One place per line, the way you would type it into Google Hotels: a city (<code>Lisbon</code>), a neighbourhood (<code>Shibuya, Tokyo</code>), a region or a landmark (<code>hotels near Eiffel Tower</code>). Each place is searched separately.

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

Format <code>YYYY-MM-DD</code>. Leave empty and the Actor searches a stay 30 days from today, so a saved task never runs on a date that has passed.

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

Format <code>YYYY-MM-DD</code>. Leave empty for a two-night stay. Prices are the total for the whole stay and the average per night.

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

Number of adult guests in one room, 1–8. Google prices the room for this many people.

## `maxHotelsPerLocation` (type: `integer`):

Google shows 20 hotels per page and stops there. This Actor keeps going through sort orders, star classes and price bands and de-duplicates by hotel, so it can collect well over a hundred hotels for one city. Set how many you want per place.

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

Three-letter code for every price in the output: <code>USD</code>, <code>EUR</code>, <code>GBP</code>, <code>IDR</code> …

## `sortBy` (type: `string`):

Which of Google's orders to read first. The deep search visits the other orders anyway; this one decides the first page and the <code>searchRank</code> numbering.

## `hotelClass` (type: `array`):

Keep only these hotel classes, e.g. <code>4</code> and <code>5</code>. Unrated properties are dropped when this is set.

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

Drop hotels rated below this, on Google's 5-point scale. Hotels without a rating are dropped too.

## `maxPricePerNight` (type: `integer`):

In the output currency. Hotels whose average nightly price is above this are not returned.

## `poolOnly` (type: `boolean`):

Only hotels with a pool.

## `includeOffers` (type: `boolean`):

For each hotel, also open its Google Hotels page and return every booking site with its price and deep link (Booking.com, Expedia, Agoda, the hotel's own site …), the full amenity list, the full address and phone, and review scores per source. One extra request per hotel, charged as a hotel page read. The offers on that page are for the stay Google picks by default, not your dates (on 10 Oct 2026 that was the next night) — the row's <code>offersCheckIn</code>/<code>offersCheckOut</code> say which — the searched dates' price is in <code>pricePerNight</code>.

## `maxOfferLookups` (type: `integer`):

Cap on the add-on above, so a wide search does not open every page.

## `includeReviews` (type: `boolean`):

Include the reviews Google shows on the hotel page (text, rating, date, source such as Tripadvisor or Trip.com). Needs the hotel page, so it works together with the add-on above or with hotel URLs.

## `maxReviews` (type: `integer`):

Up to what Google renders on the page — typically 10 to 20.

## `hotelUrls` (type: `array`):

Google Hotels page URLs (<code>https://www.google.com/travel/hotels/entity/…</code>) or entity ids from an earlier run. Each becomes one row with offers, reviews and the full amenity list — no search needed.

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

Two-letter code for names, descriptions and amenity labels, e.g. <code>en</code>, <code>de</code>, <code>es</code>.

## `market` (type: `string`):

Two-letter country code Google prices for, e.g. <code>US</code>, <code>GB</code>, <code>DE</code>. Sellers and rates differ per market.

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

Google answers this Actor's requests from ordinary datacenter IPs; the default Apify proxy is enough. Switch to residential only if a run reports consent pages or empty answers.

## `maxRequestRetries` (type: `integer`):

Each retry uses a new IP.

## Actor input object example

```json
{
  "locations": [
    "Paris, France"
  ],
  "adults": 2,
  "maxHotelsPerLocation": 20,
  "currency": "USD",
  "sortBy": "relevance",
  "poolOnly": false,
  "includeOffers": false,
  "maxOfferLookups": 20,
  "includeReviews": false,
  "maxReviews": 10,
  "language": "en",
  "market": "us",
  "proxyConfiguration": {
    "useApifyProxy": true
  },
  "maxRequestRetries": 3
}
```

# Actor output Schema

## `hotels` (type: `string`):

One row per hotel: name, star class, guest rating and review count, nightly and total price with taxes for the searched stay, amenities, coordinates, address, photos, check-in times, Google Hotels page and booking link — plus per-site offers, review sources and guest reviews when the hotel page is read.

## `summary` (type: `string`):

Counts of locations, hotels, hotel pages read, requests and errors, with the searched dates.

# 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 = {
    "locations": [
        "Paris, France"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("lergassy/hotel-price-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 = { "locations": ["Paris, France"] }

# Run the Actor and wait for it to finish
run = client.actor("lergassy/hotel-price-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 '{
  "locations": [
    "Paris, France"
  ]
}' |
apify call lergassy/hotel-price-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,lergassy/hotel-price-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/AmQK3Kw3dWu9xrOmn/builds/156xlv4CgyMJXVF7i/openapi.json