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

\[💰 $1 / 1K] Extract hotel and vacation rental listings from Google Hotels — nightly and total rates, star class, guest ratings, amenities, images, GPS, and Google Place IDs. Filter by stars, 19 amenities, 12 property types and 10 rental types across 43 countries, 19 languages and 21 currencies.

- **URL**: https://apify.com/solidcode/google-hotels-scraper.md
- **Developed by:** [SolidCode](https://apify.com/solidcode) (community)
- **Categories:** Travel, Automation, Developer tools
- **Stats:** 42 total users, 5 monthly users, 85.9% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 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.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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

Pull structured hotel and vacation-rental data straight out of Google Hotels: property names, nightly and total rates, star class, guest ratings and review counts, amenity lists, GPS coordinates, image galleries, and stable Google identifiers you can join on. Built for revenue managers, travel affiliates and market analysts who need a live view of a destination's inventory without babysitting a browser or stitching together a dozen hotel-brand sites.

### Why This Scraper?

- **Two modes in one actor** — search a location ("hotels in Paris") for browsable inventory, or feed property tokens back in to pull each property's own check-in and check-out times, which the search cards never carry
- **Filters Google actually honours** — 19 amenities, 12 hotel property types, 10 vacation-rental types and 5 star levels, all picked by name from dropdowns. Every one was checked against what Google says it applied, so a "Resorts" search returns resorts and not the whole city
- **Amenity lists on roughly 9 of every 10 first-page results** — and they stay correct in German, Portuguese and Indonesian, not just English (measured across four market and language combinations)
- **Vacation rentals mode** — flip one toggle to search villas, houses, cabins, cottages, chalets, bungalows, gîtes, holiday villages and houseboats, complete with the capacity facts Google shows on the card ("Entire villa", "Sleeps 6", "3 bedrooms")
- **Occupancy that moves the price** — up to 50 adults and 50 children with a per-child age list. Rates come back quoted for the party you asked for instead of Google's silent default of two adults
- **Localization that reaches the currency** — 43 countries, 19 languages and 21 currencies, and every `link` in the output carries the same country and language, so the page you open is the same market you searched
- **Clean numeric pricing** — `ratePerNight` and `totalRate` arrive as `{ extracted, currency, formatted }` objects, ready to sort, average and drop into a spreadsheet without stripping currency symbols
- **Stable join keys on every row** — `propertyToken`, `googlePlaceId` and a numeric `propertyId`, so you can track the same hotel across weeks of runs and match it to your own records
- **From $1 per 1,000 results** — you pay per result row, not per page, so a query that runs out of inventory costs you nothing extra

### Use Cases

**Revenue Management & Compset Analysis**

- Pull competitor nightly rates for an identical check-in/check-out window and party size
- Re-run the same query weekly and track how a compset's pricing moves into a season
- Compare your property's amenity coverage against every neighbour on page one

**Travel & Hospitality Market Research**

- Measure how a destination's inventory splits across 1- to 5-star classes
- Size the boutique, hostel, resort or bed-and-breakfast segment in any city
- Watch rate spreads across neighbourhoods by running one query per district

**Travel Content & Affiliate Sites**

- Populate "Best hotels in…" and "Top vacation rentals in…" pages with fresh rates and ratings
- Keep review counts, star classes and amenity lists current on destination guides
- Localize the same guide for 19 languages and 21 currencies from a single input set

**Lead Generation & Prospecting**

- Build lists of independent properties by filtering out chains on star class and property type
- Match prospects to your CRM using Google Place IDs and GPS coordinates
- Feed tokens back through the actor for each property's check-in and check-out times

**Vacation Rental Intelligence**

- Survey villas, cabins and cottages with the capacity facts Google lists on each card ("Sleeps 6", "3 bedrooms")
- Track nightly rates for short-term rental competitors in a resort market
- Build destination-specific rental inventories that refresh on a schedule

### Getting Started

#### Simple Search

Enter a location and let the defaults handle the rest (2 adults, check-in 14 days out, US / English / USD):

```json
{
    "searchQueries": ["hotels in Paris"]
}
```

#### Search with Dates & Guests

Target a specific stay window and party size:

```json
{
    "searchQueries": ["hotels in Tokyo", "ryokan in Kyoto"],
    "checkInDate": "2026-05-12",
    "checkOutDate": "2026-05-18",
    "adults": 2,
    "children": 1,
    "childrenAges": "7",
    "language": "en",
    "currency": "JPY",
    "country": "jp"
}
```

#### Filtered Search

Narrow by star rating, required amenities and property type:

```json
{
    "searchQueries": ["hotels in Barcelona"],
    "checkInDate": "2026-06-10",
    "checkOutDate": "2026-06-14",
    "stars": ["4", "5"],
    "amenities": ["free_wifi", "pool", "air_conditioned"],
    "propertyTypes": ["boutique_hotels", "resorts"]
}
```

#### Vacation Rentals

Search houses, villas and apartments instead of hotels:

```json
{
    "searchQueries": ["vacation rentals in Malibu"],
    "vacationRentals": true,
    "rentalTypes": ["villas", "houses"],
    "checkInDate": "2026-07-15",
    "checkOutDate": "2026-07-22",
    "adults": 4
}
```

#### Property Details by Token

Already have property tokens from an earlier run? Pull the detail record for each one:

```json
{
    "propertyTokens": ["ChYIhJvEzt34sfmCARoJL20vMDMzYnhzEAE"],
    "checkInDate": "2026-08-01",
    "checkOutDate": "2026-08-05"
}
```

### Input Reference

#### Search

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `searchQueries` | string\[] | `["hotels in Paris"]` | Location-based search queries such as "hotels in Paris" or "Bali resorts". Each query produces its own set of results. |
| `propertyTokens` | string\[] | `[]` | Google Hotels property tokens (from earlier search results) to pull a detail record for specific properties. |

Provide at least one of the two. You can also combine them in a single run.

#### Dates & Guests

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `checkInDate` | string (YYYY-MM-DD) | 14 days from today | Check-in date. Must be today or a future date. |
| `checkOutDate` | string (YYYY-MM-DD) | day after check-in | Check-out date. Must be after check-in. |
| `adults` | integer | `2` | Number of adult guests (1–50). |
| `children` | integer | `0` | Number of child guests (0–50). |
| `childrenAges` | string | `""` | Comma-separated ages (e.g. "5,8,12"). Required when children > 0. Each age 0–17. |

Anything other than the default 2 adults with no children returns the first page of results only, because Google applies your party size to that page and quotes its standard two-guest rate on everything after it.

#### Filters

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `stars` | string\[] | `[]` | Only include hotels with these star ratings. Options: `"1"` – `"5"`. |
| `amenities` | string\[] | `[]` | Only include properties that offer all of these amenities. 19 options: Free parking, Parking, Indoor pool, Outdoor pool, Pool, Fitness center, Restaurant, Free breakfast, Spa, Beach access, Child-friendly, Bar, Pet-friendly, Room service, Free Wi-Fi, Air-conditioned, All-inclusive available, Wheelchair accessible, EV charger. |
| `propertyTypes` | string\[] | `[]` | Only include these hotel property types. 12 options: Beach hotels, Boutique hotels, Hostels, Inns, Motels, Resorts, Spa hotels, Bed and breakfasts, Apartment hotels, Minshuku, Japanese-style business hotels, Ryokan. Ignored when Vacation Rentals mode is enabled. |

An amenity, property-type or rental-type filter also returns the first page only. Google applies those three to the opening result block and then stops, so later pages would hand you properties that ignore your filter. Star filters keep paginating, and rows that contradict the star filter are dropped rather than billed.

#### Vacation Rentals

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `vacationRentals` | boolean | `false` | Search vacation rentals (houses, villas, apartments) instead of hotels. |
| `rentalTypes` | string\[] | `[]` | Rental types to include. 10 options: Apartments, Bungalows, Cabins, Chalets, Cottages, Gîtes, Holiday villages, Houses, Houseboats, Villas. |

#### Localization

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `country` | string | `"us"` | Country code for localizing results (ISO 3166-1 alpha-2). 43 countries supported. |
| `language` | string | `"en"` | Language for result text (ISO 639-1). 19 languages supported. |
| `currency` | string | `"USD"` | Currency for prices (ISO 4217). 21 currencies supported. |

#### Advanced

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `maxPages` | integer | `1` | How far to keep going past the first page. Page 1 is Google's opening result block, typically 18–20 properties. Each page after that comes from Google's "nearby properties" expansion and adds roughly 6–17 new properties once duplicates are removed, so `3` usually returns 40–50 properties in total on an unfiltered query. Set `0` to keep expanding until Google stops offering new properties. Ignored (first page only) when an amenity, property-type or rental-type filter is set, or when the party is not the default 2 adults — expect 18–20 results from those searches whatever you set here. You are billed per result, never per page. |

### Output

A search query produces one **search metadata** record plus one **property** record per result. A property token produces one **property detail** record. Every row carries a `recordType` field so you can split them apart.

#### Property record (`recordType: "property"`)

```json
{
    "recordType": "property",
    "query": "pet friendly hotels in Denver",
    "pageNumber": 1,
    "type": "Hotel",
    "name": "Hilton Denver City Center",
    "description": "Chic rooms & suites in a polished downtown hotel featuring a stylish restaurant & bar.",
    "link": "https://www.google.com/travel/hotels/entity/ChYIxI-O36v-qpcpGgovbS8wbXZuc2Z0EAE?hl=en&gl=us",
    "propertyToken": "ChYIxI-O36v-qpcpGgovbS8wbXZuc2Z0EAE",
    "googlePlaceId": "0x876c78d75b3f3101:0x292eabf2bbe387c4",
    "propertyId": "18387054143944481453",
    "gpsCoordinates": { "latitude": 39.7469942, "longitude": -104.9901771 },
    "hotelClass": "4-star hotel",
    "extractedHotelClass": 4,
    "images": [
        "https://lh3.googleusercontent.com/...",
        "https://lh3.googleusercontent.com/..."
    ],
    "overallRating": 4.2,
    "reviews": 4060,
    "amenities": [
        "Breakfast ($)",
        "Free Wi-Fi",
        "Parking ($)",
        "Air conditioning",
        "Pet-friendly",
        "Fitness center",
        "Bar",
        "Restaurant"
    ],
    "ratePerNight": { "extracted": 157.37, "currency": "USD", "formatted": "$157" }
}
```

| Field | Type | Description |
|-------|------|-------------|
| `recordType` | string | Always `"property"` for search results |
| `query` | string | The search query this result came from |
| `pageNumber` | integer | 1-indexed page number |
| `type` | string | `"Hotel"` or `"Vacation rental"` |
| `name` | string | Property name |
| `description` | string | Google's editorial one-liner. First-page hotel results only; vacation rentals never have one |
| `link` | string | Google Hotels URL, carrying the same country and language as your run |
| `propertyToken` | string | Token you can pass back in `propertyTokens` |
| `googlePlaceId` | string | Google Place ID for cross-referencing |
| `propertyId` | string | Numeric Google property identifier, stable across runs |
| `gpsCoordinates` | object | `{ latitude, longitude }` |
| `hotelClass` | string | Class label, localized (`"4-star hotel"`, `"4-Sterne-Hotel"`, `"Entire villa"`) |
| `extractedHotelClass` | integer | Numeric star class 1–5, hotels only |
| `images` | string\[] | Image URLs |
| `overallRating` | number | Overall guest rating 0.0–5.0 |
| `reviews` | integer | Total review count |
| `amenities` | string\[] | Amenity labels Google lists for the property. First-page results only |
| `ratePerNight` | object | `{ extracted, currency, formatted }` for the check-in and check-out dates you asked for |
| `totalRate` | object | `{ extracted, currency, formatted }` for the check-in and check-out dates you asked for |

Fields Google does not publish for a given property are left out of that row rather than filled with nulls.

Both rate fields are omitted whenever Google only quotes that property for some other set of dates, so a number you see is always a number for the stay you searched. The rest of the listing still comes back, so you keep the property, its link, its location, its rating and its amenities even when there is no quote for your dates.

#### Property detail record (`recordType: "propertyDetail"`)

Returned for each entry in `propertyTokens`. It adds the property's own check-in and check-out times and its address, neither of which appears on a search card, and omits pricing, which Google does not publish on the property page.

```json
{
    "recordType": "propertyDetail",
    "type": "Hotel",
    "name": "Bellagio Hotel & Casino",
    "link": "https://www.google.com/travel/hotels/entity/ChYIhJvE...?hl=en&gl=us",
    "propertyToken": "ChYIhJvEzt34sfmCARoJL20vMDMzYnhzEAE",
    "googlePlaceId": "0x80c8c430cb5147bd:0x82f2c7c5d9d10d84",
    "propertyId": "18415970343024881596",
    "address": "3600 S Las Vegas Blvd, Las Vegas, NV 89109",
    "gpsCoordinates": { "latitude": 36.1129455, "longitude": -115.1765067 },
    "checkInTime": "3:00 PM",
    "checkOutTime": "11:00 AM",
    "hotelClass": "5-star hotel",
    "extractedHotelClass": 5,
    "images": ["https://lh3.googleusercontent.com/..."],
    "overallRating": 4.7,
    "reviews": 143119
}
```

| Field | Type | Description |
|-------|------|-------------|
| `recordType` | string | Always `"propertyDetail"` |
| `type` | string | `"Hotel"` or `"Vacation rental"` |
| `name` | string | Property name |
| `link` | string | Google Hotels URL for the property |
| `propertyToken` | string | The token you supplied |
| `googlePlaceId` | string | Google Place ID |
| `propertyId` | string | Numeric Google property identifier |
| `address` | string | Address as printed on the property page |
| `gpsCoordinates` | object | `{ latitude, longitude }` |
| `checkInTime` | string | Check-in time shown on the property page (e.g. `"3:00 PM"`) |
| `checkOutTime` | string | Check-out time shown on the property page |
| `hotelClass` | string | Class label |
| `extractedHotelClass` | integer | Numeric star class 1–5 |
| `images` | string\[] | Image URLs |
| `overallRating` | number | Overall guest rating 0.0–5.0 |
| `reviews` | integer | Total review count |
| `excludedAmenities` | string\[] | Amenities the property page explicitly marks as not offered |

#### Search metadata record (`recordType: "searchMetadata"`)

One per query, pushed before that query's results.

```json
{
    "recordType": "searchMetadata",
    "query": "hotels in Las Vegas",
    "estimatedTotalResults": 7998,
    "searchTimestamp": "2026-08-10T14:14:48Z",
    "language": "en",
    "country": "us",
    "currency": "USD"
}
```

| Field | Type | Description |
|-------|------|-------------|
| `recordType` | string | Always `"searchMetadata"` |
| `query` | string | The search query |
| `estimatedTotalResults` | integer | Google's own rough count for the page it served. Useful for seeing whether a filter narrowed things, but it shifts between runs and regions, so don't read it as a market size |
| `searchTimestamp` | string | ISO 8601 timestamp of when the search ran |
| `language` | string | Language the results were requested in |
| `country` | string | Country the results were localized to |
| `currency` | string | Currency the prices are quoted in |

### Tips for Best Results

- **Always set dates** — rates and availability only appear when check-in and check-out are provided, and they drive Google's own price ordering
- **Go narrow, not deep** — three neighbourhood queries ("hotels in Le Marais", "hotels in Saint-Germain", "hotels in Montmartre") return far more distinct properties than one city-wide query with a high `maxPages`, because each query gets its own fresh first page
- **Amenity, property-type and rental-type filters stop at page one** — so does any party other than 2 adults. That is Google's behaviour, not a limit we chose: it applies those to the opening result block and nothing after it. Expect 18–20 rows from those searches and split the market across several queries if you need more. Star filters are the exception and keep paginating
- **Match currency to destination** — prices in the native currency avoid FX rounding artifacts. Use `EUR` for European hotels, `JPY` for Japan
- **Stack filters carefully** — combining stars, amenities and property type can over-constrain a small market down to a handful of properties. Start broad, then add one filter at a time
- **Amenities and descriptions come from page one** — if those two fields matter to your analysis, run more queries at `maxPages: 1` rather than fewer queries at `maxPages: 5`
- **Hotels and rentals are two different searches** — Google keeps them in separate modes, so run two jobs if you need both
- **Children need ages** — when `children > 0`, list one age per child in `childrenAges`, or Google prices the room for a different party than you asked for

### Pricing

**From $1 per 1,000 results** — a flat pay-per-result rate. Bronze, Silver and Gold subscribers pay progressively less; the table below shows total cost at each discount tier.

| Results | No discount | Bronze | Silver | Gold |
|---------|-------------|--------|--------|------|
| 100 | $0.120 | $0.113 | $0.106 | $0.100 |
| 1,000 | $1.20 | $1.13 | $1.06 | $1.00 |
| 10,000 | $12.00 | $11.30 | $10.60 | $10.00 |
| 100,000 | $120.00 | $113.00 | $106.00 | $100.00 |

A "result" is any row in your dataset — one per property, plus one metadata row per query. There are no compute or time-based charges; you pay per result, plus a small fixed per-run start fee. Storage and other platform fees depend on your Apify plan.

### Integrations

Export data in JSON, CSV, Excel, XML, or RSS. Connect to 1,500+ apps via:

- **Zapier** / **Make** / **n8n** — Workflow automation
- **Google Sheets** — Direct spreadsheet export
- **Slack** / **Email** — Notifications on new results
- **Webhooks** — Custom API integrations
- **Apify API** — Full programmatic access to runs and datasets

### Legal & Ethical Use

This actor is designed for legitimate travel market research, competitive intelligence, rate tracking, and content enrichment. Users are responsible for complying with applicable laws and Google's Terms of Service. Do not use extracted data for spam, harassment, misrepresentation, or any illegal purpose. The actor collects only publicly visible property information — no personal user data.

# Actor input Schema

## `searchQueries` (type: `array`):

Location-based search queries such as 'hotels in Paris' or 'Bali resorts'. Each query produces its own set of results. Leave empty if using property tokens.

## `propertyTokens` (type: `array`):

Google Hotels property tokens for specific properties (obtained from earlier search results). Use these to fetch full property details.

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

Check-in date in YYYY-MM-DD format. Must be today or a future date.

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

Check-out date in YYYY-MM-DD format. Must be after check-in.

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

Number of adult guests.

## `children` (type: `integer`):

Number of child guests.

## `childrenAges` (type: `string`):

Comma-separated ages of children (e.g., '5,8,12'). Required when Children is greater than 0. Each age must be between 0 and 17.

## `stars` (type: `array`):

Only include hotels with these star ratings.

## `amenities` (type: `array`):

Only include properties that offer all of these amenities.

## `propertyTypes` (type: `array`):

Only include these hotel property types. Ignored when Vacation Rentals mode is enabled.

## `vacationRentals` (type: `boolean`):

Search vacation rentals (houses, villas, apartments) instead of hotels. Note: you cannot mix hotels and vacation rentals in one search — run two separate searches if needed.

## `rentalTypes` (type: `array`):

Only include these rental types. Applies when Vacation Rentals is enabled.

## `country` (type: `string`):

Country code (gl) for localizing results. Use ISO 3166-1 alpha-2 (e.g., 'us', 'uk', 'fr').

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

Language code (hl) for result text. Use ISO 639-1 (e.g., 'en', 'fr', 'de').

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

Currency code for prices (ISO 4217).

## `maxPages` (type: `integer`):

How far to keep going past the first page. Page 1 is Google's opening result block, typically 18-20 properties. Each page after that comes from Google's 'nearby properties' expansion and adds roughly 6-17 new properties once duplicates are removed, so 3 usually returns 40-50 properties in total on an unfiltered query. Set 0 to keep expanding until Google stops offering new properties. Ignored (first page only) when an amenity, property type or rental type filter is set, or when the party is not the default 2 adults — Google applies those to the first page and nothing after it, so expect 18-20 results from those searches whatever you set here. You are billed per result, never per page.

## Actor input object example

```json
{
  "searchQueries": [
    "hotels in Paris"
  ],
  "propertyTokens": [],
  "adults": 2,
  "children": 0,
  "stars": [],
  "amenities": [],
  "propertyTypes": [],
  "vacationRentals": false,
  "rentalTypes": [],
  "country": "us",
  "language": "en",
  "currency": "USD",
  "maxPages": 1
}
```

# Actor output Schema

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

Every property found, with class, guest rating, nightly rate, and amenities.

## `details` (type: `string`):

All search-result columns, including description, total stay rate, coordinates, images, and the tokens and Place IDs you can join on.

## `propertyDetails` (type: `string`):

Rows returned for property tokens, with the street address and the property's own check-in and check-out times.

# 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 = {
    "searchQueries": [
        "hotels in Paris"
    ],
    "propertyTokens": [],
    "checkInDate": "",
    "checkOutDate": "",
    "adults": 2,
    "children": 0,
    "stars": [],
    "amenities": [],
    "propertyTypes": [],
    "vacationRentals": false,
    "rentalTypes": [],
    "country": "us",
    "language": "en",
    "currency": "USD",
    "maxPages": 1
};

// Run the Actor and wait for it to finish
const run = await client.actor("solidcode/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 = {
    "searchQueries": ["hotels in Paris"],
    "propertyTokens": [],
    "checkInDate": "",
    "checkOutDate": "",
    "adults": 2,
    "children": 0,
    "stars": [],
    "amenities": [],
    "propertyTypes": [],
    "vacationRentals": False,
    "rentalTypes": [],
    "country": "us",
    "language": "en",
    "currency": "USD",
    "maxPages": 1,
}

# Run the Actor and wait for it to finish
run = client.actor("solidcode/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 '{
  "searchQueries": [
    "hotels in Paris"
  ],
  "propertyTokens": [],
  "checkInDate": "",
  "checkOutDate": "",
  "adults": 2,
  "children": 0,
  "stars": [],
  "amenities": [],
  "propertyTypes": [],
  "vacationRentals": false,
  "rentalTypes": [],
  "country": "us",
  "language": "en",
  "currency": "USD",
  "maxPages": 1
}' |
apify call solidcode/google-hotels-scraper --silent --output-dataset

```

## MCP server setup

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