# Google Hotels Scraper: Prices, Ratings & Offers (No Browser) (`subimpact/google-hotels-scraper`) Actor

Scrape Google Hotels by destination or hotel name: nightly and total price, star and guest ratings, amenities, photos and location. Optional per-provider offers with direct booking links. Plain HTTP, no browser. From $1.50 per 1,000 hotels.

- **URL**: https://apify.com/subimpact/google-hotels-scraper.md
- **Developed by:** [subimpact network](https://apify.com/subimpact) (community)
- **Categories:** Travel, E-commerce, Lead generation
- **Features:** Limited permissions
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.20 / 1,000 hotel delivereds

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

## Google Hotels Scraper: prices, ratings and booking offers

Scrape Google Hotels by destination or hotel name and get one row per property with the nightly price, the total for the stay, taxes and fees, star and guest ratings, amenities, photos, location and nearby landmarks.

This actor reads Google's server-rendered hotel list over plain HTTP. There is no browser, no Google API key and no login. Dates, guests, currency and sort order are sent in Google's own search parameter, so the prices come back in the currency you ask for.

An optional add-on fetches each hotel's property page for per-provider offers: provider name, nightly rate, total, room and rate details, free-cancellation windows, and the direct booking URL when Google exposes one.

### What you get

- One dataset item per hotel, pushed as soon as it is parsed.
- Nightly and total price as numbers, plus Google's display text for reference.
- Price breakdown (base, taxes, fees, total), deal labels and stay dates.
- Star rating, guest score, review count, rating histogram and review topics.
- Amenities, images, coordinates, country, check-in and check-out times, website.
- Nearby landmarks with travel time.
- Optional offers with provider prices, room rates and direct booking links.
- A `status` on every row: `ok`, `no_price`, `unresolved_location`, `empty` or `error`.

Rows marked `no_price`, `unresolved_location`, `empty` or `error` are never charged. They exist so a failed query or an unresolved place is visible in the dataset instead of silently missing.

### Input example

```json
{
  "queries": [
    "hotels in Paris"
  ],
  "adults": 2,
  "currency": "USD",
  "maxResultsPerQuery": 20,
  "maxResults": 20
}
```

Leave the dates empty and the actor prices a stay starting 30 days from today for 2 nights. Set `checkInDate` and `checkOutDate` for exact dates. Add more entries to `queries` to cover several destinations or hotel names in one run.

Queries can be a destination (`hotels in Paris`, `hotels in New York`) or a property name (`Hotel d'Orsay Paris`). A property-name query returns Google's single-property page.

### Output example

Real values from the saved Paris fixture (check-in 2026-12-10, 3 adults, USD), trimmed to the most useful fields:

```json
{
  "searchQuery": "hotels in Paris",
  "resolvedLocation": { "name": "Paris", "resolved": true, "total": 13473 },
  "rank": 1,
  "propertyKind": "hotel",
  "hotelName": "ibis budget Paris La Villette 19ème",
  "latitude": 48.8845304,
  "longitude": 2.3759873,
  "countryCode": "FR",
  "hotelClassLabel": "2-star tourist hotel",
  "starRating": 2,
  "guestRating": 3.6,
  "reviewCount": 4937,
  "currency": "USD",
  "pricePerNight": 107,
  "pricePerNightExact": 106.93286,
  "pricePerNightDisplay": "$107",
  "totalPrice": 214,
  "totalPriceDisplay": "$214",
  "priceBreakdown": {
    "base": 174.96313,
    "taxes": 37.31701,
    "fees": 1.5855873,
    "total": 213.86572
  },
  "checkInDate": "2026-12-10",
  "checkOutDate": "2026-12-12",
  "nights": 2,
  "adults": 3,
  "amenityCodes": [165, 29, 17, 2, 18, 27, 11, 25],
  "amenities": ["Breakfast ($)", "Free Wi-Fi", "Parking ($)", "Air conditioning", "Pet-friendly"],
  "status": "ok"
}
```

With `includeOffers` on, the same row also gets `address`, `phone`, `mapsPlaceId`, `otherRatings`, `offers` and `lowestOffer`. An offer looks like this:

```json
{
  "provider": "Hostelworld",
  "providerId": 100372930,
  "isSponsored": false,
  "isOfficialSite": false,
  "pricePerNight": 79,
  "pricePerNightDisplay": "$79",
  "totalPrice": 158,
  "totalPriceDisplay": "$158",
  "rooms": [
    {
      "roomName": "1 Bed in a 8-12 people mixed shared room",
      "rates": [
        { "maxGuests": 3, "freeCancellation": false, "freeCancelUntil": null, "perNight": 79, "total": 158 }
      ]
    }
  ],
  "bookingUrl": "https://www.hostelworld.com/pwa/hosteldetails.php/293315?from=2026-12-10&to=2026-12-12"
}
```

`isSponsored: true` means Google served the offer as an ad. Its `bookingUrl` is Google's ad-click redirect. The actor reads that URL but never requests it, and never clicks an ad.

### Input fields

| Field | What it does |
| --- | --- |
| `queries` | Destinations or hotel names, one per line. Up to 100. |
| `checkInDate`, `checkOutDate` | Stay dates in YYYY-MM-DD. Empty means today + 30 days for 2 nights. 1 to 30 nights. |
| `adults`, `childrenAges` | Guests. 1 to 10 adults; up to 6 children aged 0 to 17. |
| `currency` | ISO 4217 code. 71 codes are accepted (`USD`, `GBP`, `EUR`, `MYR`, ...). |
| `language`, `countryCode` | Google `hl` and `gl` settings. `countryCode` also affects the provider mix. |
| `sortBy` | Relevance, lowest price, highest guest rating or most reviewed. |
| `minPrice`, `maxPrice` | Nightly price bounds in the chosen currency. |
| `minGuestRating` | 3.5, 4.0 or 4.5 and up. |
| `hotelClass` | Star ratings 2 to 5. |
| `amenityFilters` | Advanced: raw Google amenity filter IDs. This numbering is different from `amenityCodes` in the output. |
| `freeCancellationOnly`, `ecoCertifiedOnly` | Restrict the search. |
| `propertyKinds` | Keep hotels and/or vacation rentals. |
| `maxResultsPerQuery` | New hotels per query, default 20, up to 500. |
| `maxResults` | Global row cap, default 100, up to 5,000. Diagnostic error and empty rows do not use the cap. |
| `includeOffers` | Fetch each hotel's property page for provider prices and booking links. Off by default. |
| `maxOffersHotels` | Cap on property-page fetches, default 20, up to 500. |
| `proxyConfiguration` | Optional proxy. Without it the actor tries direct and falls back to Apify's datacenter proxy after a block. Property-page requests for offers follow the same path, so offers never force residential proxy. |

### Pricing

Pay per event, with Apify platform usage included:

| Event | Price | When |
| --- | --- | --- |
| `hotel` | $0.0015 per hotel ($1.50 per 1,000) | A row with a hotel name and a nightly price was pushed (`status: ok`). |
| `hotel-offers` | $0.0025 per hotel ($2.50 per 1,000) | A pushed row contains at least one provider offer from the property page. |
| `apify-actor-start` | $0.00005 | Charged once by the platform when a run starts. |

The default run (1 query, first page, 20 hotels) costs about $0.03. A hotel with offers costs $0.004 in total, or $4.00 per 1,000.

Nothing is charged for `no_price`, `unresolved_location`, `empty` or `error` rows. When the buyer's charge limit is reached, the actor stops pushing and charging from every source, so rows past the limit are not left unpaid in the dataset.

### How this compares

Prices below are the published list prices on 2026-11-20. This actor includes platform usage in its price. For competitors' platform usage terms, see each listing.

| Actor | Price per 1,000 hotels | Notes |
| --- | --- | --- |
| This actor | $1.50 | $4.00 with offers. Taxes and fees, price breakdown, room rates, address, phone, direct booking links, multi-query. |
| zerobreak/google-hotels-scraper | $4.99 Free plan, $4.32 Starter, $3.66 Scale, $2.99 Business | 679 total users and 467 monthly active users on 2026-11-20, rating 5.0 from 7 reviews. Its `totalRate` "may not always be present"; our fixtures had a total price on all 40 list rows. |
| kaix/google-hotels-scraper | $0.06 | Advertised floor price. Not comparable on fields. |

This actor is not the cheapest option on the Store. It is priced for the fields the leader does not return and for a documented, tested parser: the 40 list rows in the saved fixtures all carry a total price, and the property page adds per-provider rates and direct OTA links.

### Limits and things to know

- A Google search page carries about 18 to 20 new hotels. More results mean more page requests; `maxResultsPerQuery` stops paging.
- Pages can overlap by about 2 properties. Duplicate property tokens are dropped, also across queries in the same run.
- Results are Google's ranking. `sortBy: lowest_price` is honoured by Google and visible in the fixture where the London prices ascend from 50.
- `resolvedLocation.resolved` is false when Google could not match the place and fell back to a country. Those rows are marked `unresolved_location` and are not charged, because the results are not for the place you asked for.
- The direct connection inherits the server's egress country. Display strings and the provider mix can reflect it (for example `Expedia.de`). Use `proxyConfiguration` with the country you want if that matters.
- `amenities` maps only the amenity codes confirmed so far: air conditioning, free breakfast, parking, free parking, paid parking, pet-friendly, free Wi-Fi and breakfast for a fee. Every other code stays in `amenityCodes`; this is not a complete amenity list.
- Google does not put its full amenity names in the server render, and the property page used for offers does not either.
- The optional filters (amenity IDs, hotel class, price range, minimum rating, free cancellation, eco) are encoded in Google's search parameter from its published schema. Dates, guests, currency and sort are verified against real responses; the optional filter combination is best-effort.
- Obfuscated page layout can change without notice. When no hotel record can be parsed, the row is an uncharged `error` and the run continues. When every query fails, the run fails with an explanation.
- Only one property is shown when a query names a single hotel, so `maxResultsPerQuery` has no effect there.

### Responsible use

This actor sends ordinary HTTP requests to Google's public travel pages, with the same consent cookies a browser sends. It does not log in, does not solve CAPTCHAs, does not click ads and does not fetch ad-click URLs. Keep run sizes reasonable, respect Google's terms and the law where you operate, and do not use the data to build a competing copy of Google's index. Hotel prices change; treat each row's `scrapedAt` as the observation time.

# Actor input Schema

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

Destinations or hotel names to search on Google Hotels, one query per line. Examples: hotels in Paris, hotels in New York, Hotel d'Orsay Paris. Each query returns the first page of results, and more pages up to maxResultsPerQuery. Maximum 100 queries.

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

First night of the stay in YYYY-MM-DD format. Leave empty to use today + 30 days. It must not be in the past and must be within 330 days of today.

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

Check-out date in YYYY-MM-DD format. Leave empty to use check-in + 2 nights. A stay can be from 1 to 30 nights.

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

Number of adults on the booking (1-10).

## `childrenAges` (type: `array`):

Ages of children staying, as a JSON array of integers 0-17, for example \[8, 12]. Up to 6 children. Google uses the ages to price family rooms.

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

Three-letter currency code for all prices, e.g. USD, GBP, EUR, MYR. Google Hotels accepts 71 codes; an unsupported code fails the run before any request. The code sets the numeric prices; display text is kept as Google renders it.

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

Google interface language, e.g. en, de or en-GB. It controls labels such as the hotel class text.

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

Two-letter Google country setting, e.g. us, gb, fr. It affects which booking providers Google shows. With the default direct connection Google may also include providers for the server's own country; set this plus a proxy in the desired country for a local provider mix.

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

How Google orders the results.

## `minPrice` (type: `integer`):

Optional lower bound per night in the chosen currency. Leave empty for no minimum.

## `maxPrice` (type: `integer`):

Optional upper bound per night in the chosen currency. Leave empty for no maximum.

## `minGuestRating` (type: `string`):

Optional minimum guest review score. Leave empty for any rating.

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

Optional star ratings to include, as a JSON array such as \[4, 5]. Allowed values are 2, 3, 4 and 5. Leave empty for all classes.

## `amenityFilters` (type: `array`):

Advanced: Google amenity filter IDs as a JSON array of integers. These IDs use a different numbering from the amenityCodes in the output, so there is no friendly list yet. Leave empty unless you know the IDs you need.

## `freeCancellationOnly` (type: `boolean`):

Only show stays with free cancellation.

## `ecoCertifiedOnly` (type: `boolean`):

Only show hotels Google marks as eco-certified.

## `propertyKinds` (type: `array`):

Restrict rows to hotels and/or vacation rentals. Allowed values: hotel, vacation_rental. Leave empty for both.

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

Upper bound on new hotels delivered for each query. Google returns about 18-20 new properties per page, and the run stops paging at this number.

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

Global cost ceiling: the run stops after this many hotel rows across all queries. At $0.0015 per hotel, 100 rows cost about $0.15. Error and empty diagnostic rows do not count.

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

Fetch each hotel's property page for provider prices, room rates and the direct booking link. Costs one extra request per hotel and an extra $0.0025 per hotel with at least one offer. Off by default.

## `maxOffersHotels` (type: `integer`):

Cap on property-page fetches per run when includeOffers is on. Hotels over the cap are delivered without offers and are not charged the offers event.

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

Optional. Without it the actor tries a direct connection first and switches to the Apify datacenter proxy after a block. Set a residential proxy in the same country as countryCode if Google blocks datacenter IPs or you need the local booking-provider mix. Offers never force residential proxy; they follow this same setting.

## Actor input object example

```json
{
  "queries": [
    "hotels in Paris"
  ],
  "checkInDate": "",
  "checkOutDate": "",
  "adults": 2,
  "childrenAges": [],
  "currency": "USD",
  "language": "en",
  "countryCode": "us",
  "sortBy": "relevance",
  "freeCancellationOnly": false,
  "ecoCertifiedOnly": false,
  "maxResultsPerQuery": 20,
  "maxResults": 100,
  "includeOffers": false,
  "maxOffersHotels": 20
}
```

# Actor output Schema

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

Dataset items: search query, hotel name, price per night, total price, currency, ratings, amenities, images, offers and status.

# 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 Paris"
    ],
    "checkInDate": "",
    "checkOutDate": "",
    "adults": 2,
    "childrenAges": [],
    "currency": "USD",
    "language": "en",
    "countryCode": "us",
    "sortBy": "relevance",
    "freeCancellationOnly": false,
    "ecoCertifiedOnly": false,
    "maxResultsPerQuery": 20,
    "maxResults": 100,
    "includeOffers": false,
    "maxOffersHotels": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("subimpact/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 Paris"],
    "checkInDate": "",
    "checkOutDate": "",
    "adults": 2,
    "childrenAges": [],
    "currency": "USD",
    "language": "en",
    "countryCode": "us",
    "sortBy": "relevance",
    "freeCancellationOnly": False,
    "ecoCertifiedOnly": False,
    "maxResultsPerQuery": 20,
    "maxResults": 100,
    "includeOffers": False,
    "maxOffersHotels": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("subimpact/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 '{
  "queries": [
    "hotels in Paris"
  ],
  "checkInDate": "",
  "checkOutDate": "",
  "adults": 2,
  "childrenAges": [],
  "currency": "USD",
  "language": "en",
  "countryCode": "us",
  "sortBy": "relevance",
  "freeCancellationOnly": false,
  "ecoCertifiedOnly": false,
  "maxResultsPerQuery": 20,
  "maxResults": 100,
  "includeOffers": false,
  "maxOffersHotels": 20
}' |
apify call subimpact/google-hotels-scraper --silent --output-dataset

```

## MCP server setup

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