# Google Hotels Scraper - Prices, Rates & Availability (`lagenuina_agency/google-hotels-scraper`) Actor

Scrape Google Hotels prices, rates and availability for any city or hotel and dates: nightly price, taxes, every booking site's rate (Booking.com, Expedia, official site…), rating, reviews, stars, amenities. Rate-parity and price-change monitoring built in.

- **URL**: https://apify.com/lagenuina_agency/google-hotels-scraper.md
- **Developed by:** [Quelli di Carne Genuina](https://apify.com/lagenuina_agency) (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.39 / 1,000 hotel results

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

Learn more: https://docs.apify.com/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, Rates & Availability

Get **hotel prices from Google Hotels** for any city, neighborhood or list of hotels and any dates: nightly rate, total stay price, taxes and fees, **the price on every booking site** (official hotel website, Booking.com, Expedia, Hotels.com, Agoda, Trip.com and more), guest rating, reviews, star class, amenities and coordinates. Built-in **rate parity** check and **price-change monitoring**. No Google account, no browser, no cookies to manage.

> Independent tool, not affiliated with Google LLC. It reads the public prices shown on google.com/travel/hotels.

### What you get

One row per hotel and stay, with every booking site's price (real result, shortened):

```json
{
  "hotelName": "River Palace Hotel",
  "pricePerNight": 136.02,
  "totalRate": 272.04,
  "currency": "EUR",
  "lowestPriceVendor": "Super.com",
  "officialSitePrice": 202.73,
  "cheaperThanOfficialSite": ["Hotelsnest.com", "Super.com", "Amimir.com", "trivago DEALS"],
  "bookingSources": [{ "vendorName": "Super.com", "ratePerNight": 136.02, "totalRate": 272.05, "bookingUrl": "https://www.google.com/travel/lodging/clk?pc=…" }],
  "starRating": 4,
  "overallRating": 4.4,
  "reviewCount": 767,
  "checkInDate": "2026-11-20",
  "checkOutDate": "2026-11-22"
}
```

**Try it in 1 click: the prefilled example runs in under a minute.** Press *Start* with the prefilled input ("hotels in Rome", check-in in 30 days, 2 nights): in our test today it finished in 22 seconds at 512 MB and returns up to 20 hotels, so it costs at most $0.08 on the Apify Free plan (less on paid plans).

**Price:** from $3.99 per 1,000 hotels on the Apify Free plan down to $2.39 on Gold and above, booking-site prices included, no start fee.

### Why this Google Hotels scraper

- **20% cheaper on every Apify plan** than the most used Google Hotels actor (e.g. $3.99 vs $4.99 per 1,000 hotels on Free, $2.39 vs $2.99 on Gold and above; see the price table below), and every booking site's price is **included** in the per-hotel price.
- **Built for reliability**: each request is retried on a fresh IP, one failing city or hotel never fails the run, and a `RUN_SUMMARY` record tells you what happened for each target. You always get the hotels that were collected.
- **Drop-in compatible**: `locations`, `checkInDate`, `checkOutDate`, `adults`, `currency`, `languageCode`, `countryCode`, `maxResults`, `requestTimeoutSecs` work exactly as in the popular Google Hotels actors (aliases `searchQuery`, `maxItems`, `language`, `country` accepted too).
- **Rate parity out of the box**: official-site price, cheapest site, and which sites undercut the official rate.
- **Monitoring**: relative dates (`"30 days"`) for schedules, previous price and % change on every row, optional output of changes only.

### Who uses it

- **Hotel revenue managers**: track your property and your competitive set every day, across every channel Google shows.
- **Rate parity / distribution teams**: catch OTAs selling below the official website.
- **Travel agencies, tour operators, travel startups**: hotel inventory and prices for any destination, by date and occupancy.
- **Market research and AI agents**: "What does a 4-star hotel in Lisbon cost in December?" answered with fresh data.

### Input

```json
{
  "locations": ["hotels in Rome"],
  "hotels": ["Hotel Artemide Rome"],
  "checkInDate": "30 days",
  "checkOutDate": "32 days",
  "adults": 2,
  "childrenAges": [7],
  "currency": "EUR",
  "countryCode": "it",
  "maxResults": 50,
  "hotelClass": ["4", "5"],
  "minRating": "4.0",
  "includeBookingSources": true
}
```

| Field | What it does |
|---|---|
| `locations` | Searches as typed in Google Hotels: "hotels in Rome", "Paris", "hotels near Times Square". |
| `hotels` | Specific properties: Google Hotels URL, entity ID (`entityId` from a previous run) or just the hotel name. |
| `checkInDate` / `checkOutDate` | `YYYY-MM-DD` or days from today (`"30 days"`). Defaults: 30 days from today, 1 night. |
| `adults` / `childrenAges` | Occupancy of one room, e.g. 2 adults and `[5, 9]`. |
| `currency`, `languageCode`, `countryCode` | Any ISO currency, Google language (hl) and market (gl). |
| `maxResults` | Hotels per location (pagination is automatic). |
| `includeBookingSources` | Price of every booking site with links (default on, no extra cost). |
| `minPrice`, `maxPrice`, `minRating`, `hotelClass` | Filters; hotels filtered out are not charged. |
| `onlyPriceChanges`, `monitorStoreName` | Monitoring mode: output only new hotels or changed prices. |

### Output

One item per hotel and stay (real result, shortened):

```json
{
  "hotelName": "River Palace Hotel",
  "entityId": "ChcItbiE_4Lfs4JqGgsvZy8xdGh2X2RtdBAB",
  "googleHotelsUrl": "https://www.google.com/travel/hotels/entity/ChcItbiE_4Lfs4JqGgsvZy8xdGh2X2RtdBAB",
  "pricePerNight": 136.02,
  "pricePerNightDisplay": "€136",
  "totalRate": 272.04,
  "currency": "EUR",
  "lowestPriceVendor": "Super.com",
  "officialSitePrice": 202.73,
  "cheaperThanOfficialSite": [
    "Hotelsnest.com",
    "Super.com",
    "Amimir.com",
    "trivago DEALS"
  ],
  "bookingSources": [
    {
      "vendorName": "Hotelsnest.com",
      "isOfficialSite": false,
      "ratePerNight": 147.88,
      "totalRate": 295.76,
      "bookingUrl": "https://www.google.com/travel/lodging/clk?pc=AA80OswF_an21Ni..."
    },
    {
      "vendorName": "Super.com",
      "isOfficialSite": false,
      "ratePerNight": 136.02,
      "totalRate": 272.05,
      "bookingUrl": "https://www.google.com/travel/lodging/clk?pc=AA80OsxGrOpYyAu..."
    }
  ],
  "hotelClass": "4-star hotel",
  "starRating": 4,
  "overallRating": 4.4,
  "reviewCount": 767,
  "gpsLatitude": 41.9133381,
  "gpsLongitude": 12.4749991,
  "checkInTime": "2:00 PM",
  "checkOutTime": "11:30 AM",
  "website": "https://www.riverpalacehotel.it/?utm_source=gbp&utm_medium=organic",
  "ratingsBreakdown": [
    {
      "stars": 5,
      "percent": 67,
      "count": 488
    },
    {
      "stars": 4,
      "percent": 22,
      "count": 175
    }
  ],
  "reviewsBreakdown": [
    {
      "name": "Breakfast",
      "sentiment": 0.67,
      "totalMentioned": 97,
      "positive": 81,
      "negative": 9
    }
  ],
  "nearbyPlaces": [
    {
      "name": "Piazza del Popolo",
      "transportations": [
        {
          "type": 2,
          "duration": "4 min"
        }
      ]
    }
  ],
  "images": [
    "https://lh3.googleusercontent.com/grass-cs/AABkmLc..."
  ],
  "location": "hotels in Rome",
  "rank": 2,
  "checkInDate": "2026-11-20",
  "checkOutDate": "2026-11-22",
  "nights": 2,
  "adults": 2,
  "previousPricePerNight": 141.5,
  "priceChangePct": -3.9,
  "scrapedAt": "2026-10-16T19:51:17.462Z"
}
```

`pricePerNight` is the nightly price Google shows for the stay (taxes included where Google includes them); `totalRate` is the stay total. `RUN_SUMMARY` in the key-value store lists, for each location or hotel, how many hotels were saved and any error.

### Pricing

Pay per result, with every booking site's price included. The price per hotel depends on your Apify plan:

| Apify plan | Per hotel | Per 1,000 hotels |
|---|---|---|
| Free | $0.00399 | $3.99 |
| Bronze | $0.00346 | $3.46 |
| Silver | $0.00293 | $2.93 |
| Gold, Platinum, Diamond | $0.00239 | $2.39 |

No start fee. Hotels removed by your filters, and unchanged hotels in `onlyPriceChanges` mode, are not charged. Set a maximum charge per run to cap spending: the scraper stops cleanly when it is reached.

### Migrating from zerobreak/google-hotels-scraper

All of zerobreak's input fields are accepted with the same names, so an existing input usually works after changing the actor ID to `lagenuina_agency/google-hotels-scraper`.

| zerobreak input | This actor | Notes |
|---|---|---|
| `locations` | `locations` | zerobreak searches "Hotels in <location>"; here the text is searched as typed, so write `"hotels in Paris"` to get the same search. |
| `checkInDate` / `checkOutDate` | `checkInDate` / `checkOutDate` | Same `YYYY-MM-DD`; relative dates like `"30 days"` also work, and both are optional here (default: 30 days from today, 1 night). |
| `adults` | `adults` | Same. Children: add `childrenAges`. |
| `currency` | `currency` | Same. |
| `languageCode` | `languageCode` | Same (hl). |
| `countryCode` | `countryCode` | Same (gl). |
| `maxResults` | `maxResults` | Same meaning; maximum here is 500 per location (zerobreak allows up to 1,000). |
| `requestTimeoutSecs` | `requestTimeoutSecs` | Same. |
| `proxyConfiguration` | `proxyConfiguration` | Same; the default Apify Proxy is enough. |
| (not available) | `hotels`, `minPrice`, `maxPrice`, `minRating`, `hotelClass`, `onlyPriceChanges` | Extra: price specific hotels by name, URL or entity ID, filters, price-change monitoring. |

**Output:** the core fields keep the names shown in zerobreak's README example (`hotelName`, `hotelDescription`, `gpsLatitude`, `gpsLongitude`, `hotelClass`, `starRating`, `overallRating`, `reviewCount`, `checkInTime`, `checkOutTime`, `pricePerNight`, `pricePerNightDisplay`, `totalRate`, `currency`, `amenityCodes`, `ratingsBreakdown`, `reviewsBreakdown`, `nearbyPlaces`, `bookingSources`, `checkInDate`, `checkOutDate`, `scrapedAt`). Differences: `reviewsBreakdown` uses `totalMentioned` instead of `total_mentioned`; booking sources have `isOfficialSite` and `totalRate` instead of `isSponsored` and `numGuests`; there is no `propertyType` or top-level `totalRateDisplay`. Added here: `entityId`, `googleHotelsUrl`, `website`, `images`, `lowestPriceVendor`, `officialSitePrice`, `cheaperThanOfficialSite`, `rank`, `nights`, `previousPricePerNight`, `priceChangePct`.

**Price per 1,000 hotels** (public Apify Store prices, checked on 17 October 2026; both actors price by Apify plan):

| Apify plan | zerobreak | This actor |
|---|---|---|
| Free | $4.99 | $3.99 (-20%) |
| Bronze | $4.32 | $3.46 (-20%) |
| Silver | $3.66 | $2.93 (-20%) |
| Gold and above | $2.99 | $2.39 (-20%) |

Speed and completeness: we have not benchmarked the two actors side by side. Run the same input on both and compare your own runs.

### Limits / not supported

- One room per search: `adults` (up to 12) plus `childrenAges`. Multi-room bookings are not supported.
- Up to 500 hotels per location, and never more than Google itself lists for that search.
- Prices are the ones Google shows for the chosen market (`countryCode`) and currency; whether taxes are included follows Google's display for that market.
- No room types, rate plans, cancellation policies or review texts: you get the nightly and total price per booking site, ratings and review statistics.
- No Google-side sorting, amenity or free-cancellation filters. `minPrice`, `maxPrice`, `minRating` and `hotelClass` are applied by the actor after reading the results (filtered hotels are not charged).
- A hotel given by name is matched to Google's first result for that name: check `matchedHotel`, or use the Google Hotels URL / entity ID for an exact property.
- If the booking-site prices of one hotel cannot be loaded, the hotel is still returned with `bookingSources: null` and `bookingSourcesError`.

### Monitor hotel prices and rate parity

1. Put your hotel and competitors in `hotels` (names or Google Hotels URLs).
2. Use relative dates, e.g. `checkInDate: "14 days"`, so each scheduled run looks the same distance ahead.
3. Schedule the actor daily in Apify and connect Slack, email, Google Sheets, Make, n8n or Zapier.
4. Alert on `cheaperThanOfficialSite` (parity breach) or on `priceChangePct`.

### Use it from AI agents (MCP)

Any MCP client (Claude, ChatGPT, Cursor, custom agents) can call this scraper through the Apify MCP server:

```json
{
  "mcpServers": {
    "apify": { "url": "https://mcp.apify.com/?actors=lagenuina_agency/google-hotels-scraper" }
  }
}
```

Ask things like *"Find 4-star hotels in Lisbon under €150 for 12-14 December"* or *"Is Booking.com cheaper than the official site of Hotel Artemide next weekend?"*: the inputs map directly to destination, dates, guests, currency and filters, and results come back as clean JSON.

### Integrations and API

Call it from your code with the official Apify clients:

```python
## pip install apify-client
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("lagenuina_agency/google-hotels-scraper").call(run_input={"locations": ["hotels in Rome"], "checkInDate": "30 days", "checkOutDate": "32 days", "maxResults": 20})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)
```

```js
// npm i apify-client
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('lagenuina_agency/google-hotels-scraper').call({"locations": ["hotels in Rome"], "checkInDate": "30 days", "checkOutDate": "32 days", "maxResults": 20});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
```

No-code: use the Apify app in **n8n**, **Make** or **Zapier** (action "Run Actor", pick `lagenuina_agency/google-hotels-scraper`), or the `langchain-apify` / CrewAI `ApifyActorsTool` integrations for AI agents. Results can also be pushed to Google Sheets, Slack, webhooks or any S3 bucket via Apify integrations.

### More tools from Quelli di Carne Genuina

**Ad intelligence**

- [Google Ads Transparency Scraper](https://apify.com/lagenuina_agency/google-ads-transparency-scraper): every ad a brand or domain runs on Google Search, YouTube, Shopping, Maps and Play.
- [Meta Ad Library Scraper](https://apify.com/lagenuina_agency/meta-ad-library-scraper): Facebook and Instagram ads by page, keyword or Ad Library URL, with creatives and landing pages.
- [TikTok Top Ads Scraper](https://apify.com/lagenuina_agency/tiktok-top-ads-scraper): top-performing TikTok ads from the Creative Center with CTR, likes and MP4 video URLs.
- [LinkedIn Ad Library Scraper](https://apify.com/lagenuina_agency/linkedin-ad-library-scraper): B2B ads of any company from the public LinkedIn Ad Library, with targeting and impressions.

**Competitor & SEO research**

- [Similarweb Website Traffic Scraper](https://apify.com/lagenuina_agency/similarweb-scraper): monthly visits, ranks, traffic sources and top countries for any list of domains.
- [Google Trends Scraper](https://apify.com/lagenuina_agency/google-trends-scraper): interest over time, by region, related queries and Trending Now.
- [Google Play Store Scraper](https://apify.com/lagenuina_agency/google-play-scraper): app search, details, top charts and reviews from Google Play, any country.

**Travel prices**

- [Google Flights Scraper](https://apify.com/lagenuina_agency/google-flights-scraper): fares for the same trip, with airlines, stops, price level and price calendar.

**Retail prices**

- [Woolworths AU Product Scraper](https://apify.com/lagenuina_agency/woolworths-scraper): Woolworths Australia grocery prices, specials, unit prices and barcodes.
- [Coles AU Product Scraper](https://apify.com/lagenuina_agency/coles-scraper): Coles Australia grocery prices, half-price specials, unit prices and barcodes.

**Content & social data**

- [YouTube Transcript Scraper](https://apify.com/lagenuina_agency/youtube-transcript-scraper): transcripts of videos, Shorts, playlists and channels as text, SRT or VTT.
- [Medium Scraper](https://apify.com/lagenuina_agency/medium-scraper): Medium articles by tag, author or search, with full text as Markdown.
- [Likee Scraper](https://apify.com/lagenuina_agency/likee-scraper): Likee videos, profiles and creator engagement analytics.

### FAQ

**How do I get hotel prices from Google Hotels for specific dates?**
Set `locations` (or `hotels`), `checkInDate` and `checkOutDate`. Each hotel comes back with the nightly and total price for that stay.

**Can I see the price on Booking.com, Expedia and the hotel's own website?**
Yes, `bookingSources` lists every booking site Google shows for the stay, with nightly and total price and the booking link. `officialSitePrice` and `cheaperThanOfficialSite` summarize rate parity.

**Is there a Google Hotels API?** Google does not offer a public Google Hotels API (its Hotel APIs are for hotels and partners sending their own prices). This actor gives you the public prices as JSON through the Apify API, from Python, JavaScript, n8n, Make, Zapier or MCP.

**Does it include taxes?**
`pricePerNight` is the nightly price as Google displays it for your market, and each booking source has its own nightly and total price.

**Which currencies, languages and countries are supported?**
Any currency Google Hotels supports (USD, EUR, GBP, JPY, CHF…), any Google language (`languageCode`) and market (`countryCode`).

**How many hotels can I get per city?**
Up to `maxResults` per location (default 20, up to 500); the scraper pages through Google's results.

**How do I track hotel prices over time?**
Schedule the actor with relative dates. Each row carries `previousPricePerNight` and `priceChangePct`; turn on `onlyPriceChanges` to receive only changes.

**Do I need proxies or a Google account?**
No account. The default Apify Proxy works; failed requests are retried automatically on a new IP.

**Something broke?**
Open an issue on the Issues tab: we answer within 24 hours.

# Actor input Schema

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

Cities, neighborhoods or free searches exactly as typed in Google Hotels, e.g. "hotels in Rome", "Paris", "hotels near Times Square".

## `hotels` (type: `array`):

Hotels to price directly: Google Hotels URLs (…/travel/hotels/entity/ChkI…), entity IDs from a previous run, or plain hotel names ("Hotel Artemide Rome"). Ideal for rate parity and competitor sets.

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

YYYY-MM-DD, or days from today such as "30 days" (handy for scheduled runs). Default: 30 days from today.

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

YYYY-MM-DD or days from today ("32 days"). Default: one night after check-in.

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

Adult guests (one room).

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

Ages of children in the room, e.g. \[5, 9].

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

ISO currency code for all prices: USD, EUR, GBP, JPY…

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

Google interface language (hl), e.g. en, it, de, fr.

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

Google market (gl), e.g. us, gb, it. Available booking sites and prices can differ by market.

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

Upper limit of hotels saved per location. The scraper pages through Google's results automatically.

## `includeBookingSources` (type: `boolean`):

Adds the rate of each booking site (official site, Booking.com, Expedia, Hotels.com, Agoda, Trip.com…) with booking links and a rate-parity check. Included in the per-hotel price, no extra charge.

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

Skip hotels cheaper than this (in the chosen currency). Skipped hotels are not charged.

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

Skip hotels more expensive than this. Skipped hotels are not charged.

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

Keep only hotels rated at least this (out of 5).

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

Keep only these star classes. Empty = all.

## `onlyPriceChanges` (type: `boolean`):

Remember prices between runs and output only hotels that are new or whose price changed. Every item also carries previousPricePerNight and priceChangePct.

## `monitorStoreName` (type: `string`):

Named key-value store with the last prices. Use a different name per monitored set.

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

Timeout of each request to Google; failed requests are retried on a fresh IP.

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

Apify datacenter proxy works for Google Hotels; keep the default.

## Actor input object example

```json
{
  "locations": [
    "hotels in Rome"
  ],
  "checkInDate": "30 days",
  "checkOutDate": "32 days",
  "adults": 2,
  "childrenAges": [],
  "currency": "USD",
  "languageCode": "en",
  "countryCode": "us",
  "maxResults": 20,
  "includeBookingSources": true,
  "hotelClass": [],
  "onlyPriceChanges": false,
  "monitorStoreName": "google-hotels-monitor",
  "requestTimeoutSecs": 30,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

No description

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

No description

# 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": [
        "hotels in Rome"
    ],
    "checkInDate": "30 days",
    "checkOutDate": "32 days",
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("lagenuina_agency/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 = {
    "locations": ["hotels in Rome"],
    "checkInDate": "30 days",
    "checkOutDate": "32 days",
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("lagenuina_agency/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 '{
  "locations": [
    "hotels in Rome"
  ],
  "checkInDate": "30 days",
  "checkOutDate": "32 days",
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call lagenuina_agency/google-hotels-scraper --silent --output-dataset

```

## MCP server setup

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