# Google Hotels Scraper: Prices & OTA Offers (`cylindrical_lighthouse/google-hotels`) Actor

Scrape Google Hotels by city or hotel: prices from every provider (Booking.com, Expedia, Agoda, official site), ratings, amenities, price calendar and alerts.

- **URL**: https://apify.com/cylindrical\_lighthouse/google-hotels.md
- **Developed by:** [Lighthouse Data](https://apify.com/cylindrical_lighthouse) (community)
- **Categories:** Travel, E-commerce, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

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

## Google Hotels Scraper: Prices & OTA Offers

Get hotel prices from **Google Hotels** for any destination and dates, with **every booking provider's price side by side** (Booking.com, Expedia, Agoda, Hotels.com, Trip.com, the hotel's official site and 20–40 more). You also get ratings, star class, amenities and coordinates. Add a **price calendar** for the next 90 check-in dates, or **schedule it to alert you when prices change**. Export to JSON, CSV or Excel, or use the API.

### What does Google Hotels Scraper do?

- **Searches Google Hotels by destination** ("Prague", "Lisbon, Portugal", "hotels near Eiffel Tower") for your check-in date, nights, adults, children's ages and currency, in Google's ranking order, up to 500 hotels per destination.
- **Looks up specific hotels** by name, Google Hotels URL or hotel ID. This suits a competitive set or a first-pass rate-parity screen.
- **Returns each provider's offer:** nightly price, total for the stay, price including taxes and fees, free cancellation, and whether it is the hotel's own site.
- **Returns hotel details:** rating, number of reviews and their star distribution, star class, property type, address, phone, website, coordinates, Google Maps link, amenities, check-in/out times and a photo.
- **Price calendar:** the lowest price and cheapest provider for up to 90 consecutive check-in dates.
- **Price-change monitoring:** remembers the last price per hotel, stay and provider, and reports what went up, went down, appeared or disappeared since the previous run.
- **72 currencies**, any Google language and country.

### Why use it?

- **Built for reliability.** It reads the same structured data the Google Hotels page loads, over plain HTTP. There is no headless browser to break and no HTML guessing. Blocks are retried on a fresh IP, with automatic fallback to residential proxies. In our tests, 1,368 of 1,368 requests succeeded.
- **Fails loudly, never silently.** Google quietly swaps an unknown destination for "United States" and past dates for tomorrow. This Actor detects both and tells you, instead of handing you the wrong hotels or the wrong dates.
- **One flat price per hotel, however many offers it has.** A hotel with 30 provider offers costs the same as one with 3.
- **Made for scheduled monitoring.** The change-detection mode, the calendar and the stable hotel IDs are designed for daily runs.
- **Friendly to AI agents and MCP.** Every input and output field is documented with types and examples.

### Use cases

- **Hotel revenue management:** a daily rate shop of your hotel and your competitive set across every OTA for the next 30–90 nights.
- **Rate-parity screening:** spot booking sites that show a lower price than your official site on Google (`isOfficialSite` vs. everyone else), then verify the room type, cancellation terms and inclusions on the booking site.
- **Travel agencies and TMCs:** watch quoted or booked stays and act when the price drops.
- **OTAs, metasearch and travel startups:** price benchmarks and coverage by city, and seed data for new markets.
- **Analysts and researchers:** city price indices, seasonality, and event-driven price spikes.
- **AI travel agents:** "the cheapest 4-star hotel near the venue on these dates, and where to book it".

### How to use it

1. Click **Try for free**.
2. Enter one or more **Destinations** (e.g. `Prague`), or **Specific hotels** by name or Google Hotels URL.
3. Set the **Check-in date** (e.g. `2026-11-10`, or `+14 days` for scheduled runs), **Nights**, **Adults** and **Currency**.
4. Turn on **Include every provider's price** for the per-OTA price ladder.
5. Click **Start**. Download the results as JSON, CSV or Excel, or read them through the API. Use the **Offers by provider**, **Price calendar** and **Price changes** tabs for one row per offer, date or change.

**Input example** (the prefilled input: 5 hotels in Prague with all offers, about $0.013):

```json
{
  "destinations": ["Prague"],
  "checkIn": "2026-11-10",
  "nights": 2,
  "adults": 2,
  "currency": "EUR",
  "maxHotelsPerDestination": 5,
  "includeOffers": true
}
```

#### Scheduled price monitoring (recommended for revenue managers)

Watch your competitive set every morning and receive only what changed:

```json
{
  "hotels": [
    "Hotel NH Collection Prague Carlo IV",
    "Hilton Prague Old Town",
    "https://www.google.com/travel/hotels/entity/ChgI9pq7z4m4m4KvARoLL2cvMXYwbGpoNGIQAQ"
  ],
  "checkIn": "+1 day",
  "nights": 1,
  "calendarDays": 30,
  "currency": "EUR",
  "monitorPrices": true,
  "monitorStoreName": "prague-comp-set",
  "minChangePercent": 2
}
```

1. Save this as a **task**, then add a **schedule** (for example daily at 07:00) in Apify Console under *Schedules*.
2. Each run checks the next 30 check-in dates for the three hotels, with every provider on the first date.
3. The **Price changes** tab lists every move of 2% or more since the previous run: previous price, current price, delta and percent.
4. Connect an **integration** (Slack, email, Google Sheets, Zapier, Make or a webhook) to get the changes pushed to you.

This costs about **$0.23 per day** (3 hotels × ($0.0025 + 30 × $0.0025)), or roughly $7 a month.

The relative check-in date (`+1 day`) moves forward with every run. Changes are compared for the **same stay dates**, so with a calendar each date is tracked day after day until it passes. Use a separate `monitorStoreName` for each independent watch list.

#### API

```bash
curl -X POST "https://api.apify.com/v2/acts/<username>~google-hotels/run-sync-get-dataset-items?token=<YOUR_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"destinations":["Lisbon"],"checkIn":"+30 days","nights":2,"maxHotelsPerDestination":10,"includeOffers":true}'
```

### Input

| Field | Type | Description | Example |
|---|---|---|---|
| `destinations` | array of strings | Places to search, as typed into Google Hotels. Unknown places fail with a clear message | `["Prague", "hotels near Eiffel Tower"]` |
| `hotels` | array of strings | Hotel names (with the city), Google Hotels URLs or hotel IDs. Always include offers | `["Hilton Prague Old Town"]` |
| `checkIn` | string | `YYYY-MM-DD`, or relative (`+14 days`, `+2 weeks`, `tomorrow`). Empty = 14 days from today. At most 365 days ahead | `"2026-11-10"` |
| `nights` | integer | 1–30 (default 1) | `2` |
| `adults` | integer | 1–12 (default 2) | `2` |
| `childrenAges` | array of integers | One age (0–17) per child, up to 6 | `[5, 8]` |
| `maxHotelsPerDestination` | integer | 1–500 (default 20) | `20` |
| `includeOffers` | boolean | Add every provider's price, address, phone and full amenities for destination results (default false) | `true` |
| `calendarDays` | integer | 0 = off; otherwise the number of consecutive check-in dates to price (up to 90) | `30` |
| `monitorPrices` | boolean | Report changes since the previous run (default false) | `true` |
| `monitorStoreName` | string | Key-value store that keeps the last prices | `"prague-comp-set"` |
| `minChangePercent` | integer | Ignore smaller moves (default 0) | `2` |
| `onlyChangedHotels` | boolean | With monitoring, save only hotels with a change | `false` |
| `currency` | string | ISO 4217 code, 72 supported (default USD) | `"EUR"` |
| `language` | string | Google language (`hl`, default `en`) | `"de"` |
| `country` | string | Searcher's country (`gl`, default `us`) | `"gb"` |
| `proxyConfiguration` | object | Default: Apify datacenter proxy | `{ "useApifyProxy": true }` |
| `residentialFallback` | boolean | Switch to residential proxy after repeated blocks (default true, no extra charge) | `true` |
| `maxConcurrency` | integer | Parallel requests, 1–20 (default 5) | `5` |

With an empty input, the Actor searches the example destination "Prague".

### Output

Each hotel is one record. Offers, the calendar and changes are nested arrays; the dataset tabs **Offers by provider**, **Price calendar** and **Price changes** flatten them into one row each. A `SUMMARY` record in the key-value store lists per-destination counts, any inputs that failed and why, and the request statistics.

```json
{
  "hotelId": "ChcIrK78kOba8qxYGgsvZy8xdmZwMmJwdxAB",
  "name": "Czech Inn, Prague",
  "url": "https://www.google.com/travel/hotels/entity/ChcIrK78kOba8qxYGgsvZy8xdmZwMmJwdxAB/prices?hl=en&gl=us&curr=USD&ts=…",
  "googleMapsUrl": "https://maps.google.com/?cid=11139706250922420949",
  "propertyType": "hostel",
  "hotelClass": null,
  "rating": 4.4,
  "reviewCount": 2354,
  "ratingDistribution": { "1": 87, "2": 64, "3": 160, "4": 533, "5": 1510 },
  "latitude": 50.0718358,
  "longitude": 14.4464348,
  "address": "Francouzská 240/76, 101 00 Praha 10-Vršovice, Czechia",
  "phone": "+420 210 011 100",
  "website": "http://www.czechinn.com/",
  "description": "Stylish dorms & rooms in a comfortable hostel offering a shared kitchen & a cool basement bar.",
  "amenities": ["Wi-Fi (free)", "Bar", "Breakfast (extra charge)", "Smoke-free property", "Front desk (24 hour)"],
  "checkInTime": "15:00",
  "checkOutTime": "12:00",
  "thumbnailUrl": "https://lh3.googleusercontent.com/…",
  "searchQuery": "Prague",
  "resolvedLocation": "Prague",
  "position": 2,
  "checkIn": "2026-10-13",
  "checkOut": "2026-10-15",
  "nights": 2,
  "adults": 2,
  "childrenAges": [],
  "currency": "USD",
  "lowestPricePerNight": 20.43,
  "lowestPricePerNightWithTaxes": 27.52,
  "lowestTotalPrice": 40.85,
  "lowestTotalPriceWithTaxes": 55.04,
  "cheapestProvider": "Booking.com",
  "offersCount": 4,
  "offers": [
    {
      "provider": "Booking.com",
      "isOfficialSite": false,
      "pricePerNight": 20.43,
      "pricePerNightWithTaxes": 27.52,
      "totalPrice": 40.85,
      "totalPriceWithTaxes": 55.04,
      "freeCancellation": false,
      "bookingUrl": "https://www.google.com/travel/lodging/clk?pc=…"
    }
  ],
  "priceCalendar": null,
  "priceChanges": null,
  "scrapedAt": "2026-09-29T22:04:38.912Z"
}
```

A price-change entry (monitoring mode):

```json
{ "scope": "provider", "provider": "Booking.com", "checkIn": "2026-10-29", "checkOut": "2026-10-31", "status": "changed",
  "previousPrice": 379.55, "currentPrice": 354.55, "priceDelta": -25, "priceDeltaPercent": -6.59, "previousScrapedAt": "2026-09-28T06:00:00.000Z" }
```

**Field notes**

- All prices are numbers in `currency`. "Per night" is Google's nightly average before taxes. The totals are the nightly price × nights, which is how Google shows its totals; the `…WithTaxes` fields include taxes and fees when the provider reports them.
- A missing value is `null`, never `0` or `""`. `null` prices mean Google shows no price (sold out, or dates too far ahead).
- `hotelId` is stable. Pass it back in `hotels` for fast, exact lookups.
- Hotels are saved as they finish, in parallel; sort by `position` for Google's ranking order.

### Pricing

Pay per event: you pay only for results. Prices below are the FREE-tier prices; paid Apify plans get lower per-event prices (shown on the **Pricing** tab).

| Event | Price | When |
|---|---|---|
| Actor start | $0.00005 | Once per run (per GB of memory) |
| Hotel | $0.001 | Each hotel saved |
| Hotel offers | $0.0015 | Each hotel with every provider's price (destination results with offers on; all direct hotel lookups) |
| Calendar date | $0.0025 | Each hotel × check-in date in price-calendar mode |

**Examples**

- 100 hotels in a city, listing only: **$0.10**.
- 100 hotels with every provider's offer: **$0.25**.
- A daily rate shop of 5 hotels × 30 nights: 5 × ($0.0025 + 30 × $0.0025) = **$0.39 per day**.
- The prefilled input (5 hotels with offers): about **$0.013**.

Higher Apify subscription plans get tiered discounts on these prices automatically. Set a **maximum cost per run** in the run options, and the Actor stops cleanly when it reaches it, keeping what it has already scraped. Proxy costs are included; you pay nothing extra for them.

### FAQ

**Is it legal to scrape Google Hotels?** This Actor extracts only publicly available data: hotel listings, prices and aggregate ratings that anyone can see without logging in. It does not collect individual reviews or reviewers' names, and it solves no CAPTCHAs. Automated access may conflict with Google's Terms of Service, so use the data responsibly. Your results could in principle contain personal data (for example, a phone number of a private vacation rental host), which is protected by GDPR and other regulations. Do not process personal data unless you have a legitimate reason. If you are unsure, consult your lawyers.

**Are the prices exact?** They are the prices Google shows at the moment of the run, provided by the booking sites. Hotel prices change constantly and depend on the searcher's country (`country`), so treat them as indicative and confirm on the booking site.

**Why do some hotels have no price?** Google shows no price when a hotel is sold out for your dates, or when the dates are too far ahead (usually beyond about 11 months). The record is still saved, with `null` prices.

**Why is `hotelClass` often null?** Google shows an official star class for only some hotels. We never guess it.

**What happens with a typo in the destination?** Google silently falls back to a whole country. This Actor detects that and fails that destination with a message, while your other destinations still run.

**Can I get more than 20 hotels?** Yes, up to 500 per destination; the Actor pages through Google's results. Google itself lists only its most relevant hotels for very large cities.

**Do you support vacation rentals?** When Google lists them in hotel results, yes. They have `propertyType: null` and usually a single offer.

**How do I use it from an AI agent?** Call it through the Apify MCP server or API. Use `hotels` for exact lookups and `destinations` for discovery; `hotelId` values round-trip between runs.

### Limitations

- Prices come from Google's metasearch and can differ slightly from the booking site's final checkout price.
- Each provider's price is the lowest one Google displays for that stay. Room type, cancellation terms and inclusions (such as breakfast) can differ between providers, so a lower price is not always a like-for-like rate. Room-level rates are not included.
- Room-level rates (for example "Deluxe King, non-refundable") are not included in v1; offers are per provider.
- Check-in must be within 365 days, stays 1–30 nights, at most 12 adults and 6 children.
- Amenity labels are in English whatever the `language`.
- The price calendar makes one request per date per hotel, so large calendars take longer (about 1 s per date per hotel, 3 in parallel).
- Individual reviews are out of scope; only aggregate ratings are provided.

### Changelog

See the [Changelog](./CHANGELOG.md) tab.

### Support

Found a bug or need a field? Open an issue on the **Issues** tab. We reply within 48 hours. When Google changes its pages, our daily health check usually catches it before you do.

# Changelog

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

# Actor input Schema

## `destinations` (type: `array`):

Places to search, written as you would type them into Google Hotels. Each entry returns up to 'Max hotels per destination' hotels, in Google's ranking order. Examples: "Prague", "Lisbon, Portugal", "hotels near Eiffel Tower", "Shinjuku, Tokyo", "Miami Beach". An unknown place fails with a clear message instead of returning unrelated hotels.

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

Hotels to look up directly: a hotel name (with the city, for accuracy), a Google Hotels URL, or a hotel ID from a previous run's 'hotelId' field. Each hotel always includes every provider's offer. Examples: "Hilton Prague Old Town", "https://www.google.com/travel/hotels/entity/ChcI0pn7x-CIitUxGgsvZy8xdGxzMWtkXxAB", "ChcI0pn7x-CIitUxGgsvZy8xdGxzMWtkXxAB". Use this for a competitive set or rate-parity checks.

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

Check-in date, either absolute (YYYY-MM-DD, e.g. "2026-11-10") or relative to the day of the run (e.g. "+14 days", "+2 weeks", "tomorrow"). Relative dates suit scheduled runs. Must be today or later and at most 365 days ahead. Leave empty for 14 days from today.

## `nights` (type: `integer`):

Length of stay in nights (1–30). Check-out = check-in + nights. Example: 2.

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

Number of adult guests (1–12). Prices depend on occupancy. Example: 2.

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

Age of each child at check-in, one number per child (0–17), at most 6 children. Leave empty for no children. Example: \[5, 8] for two children aged 5 and 8.

## `maxHotelsPerDestination` (type: `integer`):

Stop after this many hotels for each destination (1–500). Google returns about 20 hotels per page, so higher numbers take more requests. Example: 20.

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

For destination results, also fetch each hotel's page with every booking provider's offer (Booking.com, Expedia, Agoda, the official site and 20–40 others), the address, phone, website and full amenities. Charged as an extra 'hotel-offers' event per hotel. Hotels listed under 'Specific hotels' always include offers. Example: true.

## `calendarDays` (type: `integer`):

0 = off. Otherwise, for every hotel, also check the lowest price for this many consecutive check-in dates starting at the check-in date, with the same number of nights, and add them as 'priceCalendar'. Each date is one 'calendar-price' event per hotel. Example: 30 for the next 30 check-in dates.

## `monitorPrices` (type: `boolean`):

Remember each price (per hotel, stay dates, guests, currency and provider) in a named key-value store and report what changed since the previous run in 'priceChanges'. Schedule the Actor (e.g. daily) with the same input to track rates over time. The first run records a baseline and reports no changes. No extra charge. Example: true.

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

Name of the key-value store that keeps the last seen prices. Use a different name for each independent watch list. Letters, digits and hyphens only. Example: "prague-comp-set".

## `minChangePercent` (type: `integer`):

Ignore price moves smaller than this percentage (0–100). 0 reports every change. Example: 2.

## `onlyChangedHotels` (type: `boolean`):

With monitoring on, save only hotels that have at least one price change (or a new or removed provider). All hotels are still checked and charged. Example: false.

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

ISO 4217 currency code for all prices. Example: "EUR".

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

Google interface language code (the 'hl' parameter). It affects hotel names, descriptions and amenity labels where Google translates them. Examples: "en", "de", "es", "ja", "en-GB".

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

Two-letter country code of the searcher (the 'gl' parameter). Google shows the offers available to users in that country. Examples: "us", "gb", "de", "jp".

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

Proxy settings. The default (Apify datacenter proxy) worked for 100% of requests in our tests. Only change it if you know you need to.

## `residentialFallback` (type: `boolean`):

If Google blocks several requests in a row on the datacenter proxy, switch to Apify residential proxy for the rest of the run. No extra charge to you. Only applies when the Apify proxy is used. Example: true.

## `maxConcurrency` (type: `integer`):

Maximum number of parallel requests to Google (1–20). Lower it if you see blocks. Example: 5.

## Actor input object example

```json
{
  "destinations": [
    "Prague",
    "hotels near Eiffel Tower"
  ],
  "hotels": [
    "Hilton Prague Old Town",
    "ChcI0pn7x-CIitUxGgsvZy8xdGxzMWtkXxAB"
  ],
  "checkIn": "2026-11-10",
  "nights": 2,
  "adults": 2,
  "childrenAges": [
    5,
    8
  ],
  "maxHotelsPerDestination": 20,
  "includeOffers": true,
  "calendarDays": 30,
  "monitorPrices": true,
  "monitorStoreName": "prague-comp-set",
  "minChangePercent": 2,
  "onlyChangedHotels": false,
  "currency": "EUR",
  "language": "en",
  "country": "us",
  "proxyConfiguration": {
    "useApifyProxy": true
  },
  "residentialFallback": true,
  "maxConcurrency": 5
}
```

# Actor output Schema

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

One record per hotel: rating, reviews, class, amenities, coordinates, lowest price and, when requested, every provider's offer, the price calendar and price changes.

## `offers` (type: `string`):

One row per hotel and booking provider (Booking.com, Expedia, the official site…) with nightly and total prices, taxes and free cancellation.

## `priceCalendar` (type: `string`):

One row per hotel and check-in date with the lowest nightly price and the cheapest provider (price calendar mode).

## `priceChanges` (type: `string`):

One row per price change since the previous monitored run: before, now, delta and percent (price monitoring mode).

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

Counts per destination, inputs that failed and why, request statistics, monitoring totals and whether the budget limit stopped the run.

# 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 = {
    "destinations": [
        "Prague"
    ],
    "nights": 2,
    "maxHotelsPerDestination": 5,
    "includeOffers": true,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("cylindrical_lighthouse/google-hotels").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 = {
    "destinations": ["Prague"],
    "nights": 2,
    "maxHotelsPerDestination": 5,
    "includeOffers": True,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("cylindrical_lighthouse/google-hotels").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 '{
  "destinations": [
    "Prague"
  ],
  "nights": 2,
  "maxHotelsPerDestination": 5,
  "includeOffers": true,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call cylindrical_lighthouse/google-hotels --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,cylindrical_lighthouse/google-hotels"
        }
    }
}
```

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/M58jHIZhEd3BJapV1/builds/7JBxbQrOCAIeKpCTg/openapi.json