Skip to main content
Glama

Google Hotels MCP

New blog post: Add Google Hotels to Claude Desktop as an MCP server — 2-minute install walk-through for Claude Desktop and Claude Code.

Glama MCP server

A Model Context Protocol (MCP) server that lets Claude, Cursor, Windsurf and any other MCP client fetch live Google Hotels and Google Vacation Rentals prices with the rate every booking site is charging (Booking.com, Expedia, Agoda, Vrbo, Airbnb, Hotels.com, …), plus a 3-month daily price calendar for any single property. Everything comes back as JSON — no Google account, no scraping on your laptop, no Puppeteer.

Backed by three open-source actors on the Apify Store. You bring your own Apify token; the actors are pay-as-you-go on the Apify Free plan at $0.002 / hotel, $0.0015 / daily price and $0.002 / vacation rental. Apify ships $5 of free compute every month and no card is required to start.

Tools

Tool

What it does

search_hotels

Google Hotels search for a destination + dates. Returns name, rating, review count, nightly and total price, hotel class, address, coordinates, amenities, hero photo, Google URL, and (optionally) the price every OTA is charging.

hotel_price_calendar

3-month daily rate calendar for one hotel URL. One row per date with price, currency, available.

search_vacation_rentals

Google Vacation Rentals search (Airbnb / Vrbo / Booking.com). Same shape as hotels plus bedrooms/bathrooms.

Related MCP server: Booking MCP Server

Quick start

1. Get an Apify token

Create a free account at https://console.apify.com/account/integrations and copy your Personal API token. Pay-as-you-go, no card to start.

2. Add the server to your MCP client

Note: this server is new and not yet on PyPI. Until it is, install directly from the GitHub repo with uvx --from "git+https://github.com/huynhtanan/google-hotels-mcp.git@v0.1.2" google-hotels-mcp. Pinned to the tagged release so later main-branch changes do not break existing users. Once google-hotels-mcp lands on PyPI you can drop the --from prefix.

Claude Desktop — edit claude_desktop_config.json:

{
  "mcpServers": {
    "google-hotels": {
      "command": "uvx",
      "args": ["--from", "git+https://github.com/huynhtanan/google-hotels-mcp.git@v0.1.2", "google-hotels-mcp"],
      "env": { "APIFY_TOKEN": "apify_api_..." }
    }
  }
}

Claude Code:

claude mcp add google-hotels -- uvx --from "git+https://github.com/huynhtanan/google-hotels-mcp.git@v0.1.2" google-hotels-mcp --env APIFY_TOKEN=apify_api_...

Cline — in VS Code: open the Cline MCP Servers panel → Add server → Command, paste the same uvx --from git+... command and set APIFY_TOKEN in env.

Cursor — Settings → MCP → Add Server, same uvx --from git+... command with APIFY_TOKEN in env.

If you prefer pipx or pip, install from GitHub with pipx install git+https://github.com/huynhtanan/google-hotels-mcp.git (or pip install git+...) and run google-hotels-mcp.

Example prompts

"Find hotels in Paris for 3 nights from 2026-12-20, two adults, in EUR, with the Booking.com and Expedia rate for each one."

"Pull a 3-month daily price calendar for the Hoxton Paris — I want to see which dates are under €200."

"Compare vacation rentals in Lisbon vs Porto, 2 adults, 2026-11-15 to 2026-11-22, 3+ bedrooms, with the Airbnb vs Vrbo rate for each."

Sample response

search_hotels(query="hotels in Lisbon", check_in="2026-11-10", check_out="2026-11-13", adults=2, currency="EUR") — one of 40 items (trimmed):

{
  "name": "Patio São Vicente Guest Houses",
  "position": 1,
  "rating": 4.9,
  "reviewsCount": 349,
  "ratingDistribution": {"1": 0, "2": 0, "3": 3, "4": 16, "5": 330},
  "hotelClass": 4,
  "hotelClassText": "4-star hotel",
  "pricePerNight": 109,
  "pricePerNightText": "€109",
  "totalPrice": 372.1,
  "totalBeforeTaxes": 328.48,
  "currency": "EUR",
  "checkIn": "2026-11-10",
  "checkOut": "2026-11-13",
  "nights": 3,
  "checkInTime": "3:00 PM",
  "checkOutTime": "11:00 AM",
  "latitude": 38.7155846,
  "longitude": -9.1280593,
  "nearbyPlaces": [
    {"name": "National Pantheon", "travelTime": "6 min"},
    {"name": "Voz Operário", "travelTime": "2 min"}
  ],
  "reviewTopics": [
    {"topic": "Location", "mentions": 88, "positive": 84, "negative": 2, "positiveShare": 0.977}
  ],
  "amenityIds": [29, 2, 54, 15, 12, 1, 11, 25],
  "website": "https://www.patiosaovicente.com/",
  "mapsUrl": "https://www.google.com/maps?cid=1945275941691630548",
  "googleHotelsUrl": "https://www.google.com/travel/hotels/entity/ChkIn4CU6sjxgJ1YGg0vZy8xMWY0XzdqenhqEAE?hl=en&gl=us"
}

Set include_provider_prices=true and the hotel also gets a providers array with the price Booking.com, Expedia, Agoda, Hotels.com, Vrbo and 10+ other OTAs are each charging for the same stay.

Pricing

Call

Cost

1 hotel in search_hotels

$0.002

1 hotel with per-provider rates

$0.004 ($0.002 result + $0.002 provider enrich)

1 date in hotel_price_calendar

$0.0015

1 vacation rental in search_vacation_rentals

$0.002

A full-city hotel search (20 hotels with provider rates) is around $0.08. The Apify Free plan ships $5 of credit every month — about 60 full-city searches — before you need to upgrade.

How it compares

google-hotels-mcp

HasData google-hotels-mcp

Scraping yourself

Open source

✅ MIT

❌

depends

MCP tools

3 (hotels, calendar, rentals)

1 (hotels)

0

Daily price calendar

✅

❌

hard

Vacation rentals

✅ Airbnb + Vrbo + Booking.com

❌

hard

Per-provider rates

✅ 15+ OTAs

✅

hard

Pricing

$0.002 / hotel pay-as-you-go

10 credits / search

your time

Free tier

$5 / month Apify credit

1,000 credits / month

n/a

FAQ

Do I need an Apify paid plan? No. The free plan is enough for a few thousand hotel results per month.

Is this official from Google? No, it is an unofficial server that calls the same /travel/hotels endpoints a browser does, via three open actors.

Why three actors instead of one? Google serves calendars and vacation rentals on separate pages, each with its own ranking signals. Keeping them as separate tools keeps costs honest — you only pay for what the agent actually fetches.

What about rate limits? Each actor retries transient failures and respects Google's rate limits. For heavy workloads use the Apify Scheduler (one line in the console) instead of running the MCP tool in a tight loop.

License

MIT.

Examples

Runnable, self-contained scripts that use this MCP server (and the underlying Apify actors) for real workflows.

  • examples/rate_parity — Daily OTA rate-parity watcher: snapshots per-OTA prices into SQLite and prints hotels where Booking/Expedia/Agoda disagree by ≥ 3% on the same stay date.

  • examples/cheapest_week — Find the cheapest 7-night window for one hotel in the next 60 days by pulling the Google Hotels price calendar and sorting every rolling window by total price.

Tutorials

Deep-dive write-up on dev.to:

Full series (all four actors): Apify + Python: scrapers, trackers, and Claude Desktop.

Available Tools

3 tools
hotel_price_calendarA

Return a daily rate calendar for one Google Hotels property.

By default this returns 90 forward dates (roughly three months), one row per date. Each item has date, price, currency and available.

Args: hotel_url: a Google /travel/hotels/entity/<token> URL. start_date: ISO date YYYY-MM-DD where the calendar starts. number_of_dates: how many forward dates to price (default 90 = 3 months). nights: stay length to price per date (1 = per-night rate). currency: ISO 4217 code. hl: Google interface language. gl: Google country code. adults: number of adults for the stay. children: number of children. rooms: number of rooms.

NameRequiredDescriptionDefault
glNous
hlNoen
roomsNo
adultsNo
nightsNo
childrenNo
currencyNoUSD
hotel_urlYes
start_dateYes
number_of_datesNo

Output Schema

NameRequiredDescription
resultYes

TDQS

A3.8/5.0
Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the full behavioral burden. It does usefully disclose the default window (90 forward dates ≈ 3 months, one row per date) and the per-item fields, but says nothing about latency, rate limits, authentication, caching, or how unavailable dates are represented beyond the 'available' field name.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Front-loaded with the one-line purpose, then an output-shape sentence, then a compact Args list. Efficient overall, with only minor redundancy (the 90-date default is stated in both the prose and the Args entry).

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a 10-parameter, annotation-free tool, the description covers every argument and the default output window. Since an output schema exists it need not enumerate return values, making the item-field sentence mild redundancy rather than a gap.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters5/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 0%, so the description must compensate, and it does: hotel_url format, ISO date format for start_date, number_of_dates default and meaning, nights semantics (1 = per-night rate), ISO 4217 currency, and what gl/hl control. All ten parameters get meaningful clarification rather than restatement.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

States a specific verb and resource: returns a daily rate calendar for one Google Hotels property. The singular 'one property' and the daily-calendar framing distinguish it from the sibling search tools, though it never names them explicitly.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines3/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Usage is only implied: the hotel_url argument being a Google /travel/hotels/entity/<token> URL hints that the property must first be found via search_hotels, and the pricing semantics (nights=1 per-night rate) suggest the pricing use case. No explicit when-to-use, when-not-to-use, or named alternative appears.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

search_hotelsA

Search Google Hotels for a destination between two dates.

Returns a JSON array of hotels with name, rating, review count, price per night, total price, hotel class, address, coordinates, amenities, hero photo and the Google /travel/hotels/entity URL. When include_provider_prices is true each hotel also gets a providers list with the rate every booking site (Booking.com, Expedia, Agoda, Vrbo, Hotels.com, ...) is charging for the stay (one extra Apify provider-prices call per hotel, billed per-hotel).

Args: query: destination, e.g. "hotels in Paris" or "Hilton near Louvre". check_in: ISO date YYYY-MM-DD. check_out: ISO date YYYY-MM-DD. adults: number of adults. children: number of children. rooms: number of rooms. currency: ISO 4217 code (USD, EUR, GBP, ...). hl: Google interface language (en, fr, de, ...). gl: Google country code (us, gb, fr, ...). max_results: upper bound on hotels returned. min_rating: filter to hotels at or above this guest rating (0-5). min_hotel_class: filter to hotels at or above this class (2-5). include_provider_prices: fetch per-provider rates. Each hotel priced this way adds one provider-prices call to the Apify bill. Defaults to false to keep costs predictable.

NameRequiredDescriptionDefault
glNous
hlNoen
queryYes
roomsNo
adultsNo
check_inYes
childrenNo
currencyNoUSD
check_outYes
min_ratingNo
max_resultsNo
min_hotel_classNo
include_provider_pricesNo

Output Schema

NameRequiredDescription
resultYes

TDQS

A4/5.0
Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the full burden and does disclose meaningful behavior: the return payload shape, and critically that include_provider_prices triggers one extra billed Apify provider-prices call per hotel, defaulting to false for cost predictability. It omits auth requirements, rate limits, and pagination behavior, which keeps it short of a 5.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Front-loaded with purpose and return contents, then a clearly delimited Args block. The Args list is long but each entry earns its place because the underlying schema has no descriptions. Slight redundancy between the prose about provider prices and the include_provider_prices entry is the only waste.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a 13-parameter, no-annotation tool with an output schema, the description covers purpose, inputs, filtering semantics, return shape, and the cost trade-off of the expensive optional flag. The main remaining gap is guidance on choosing this tool versus its two siblings.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters5/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 0%, so the description must compensate fully, and it does: all 13 parameters are documented with concrete formats (ISO 'YYYY-MM-DD' dates, ISO 4217 currency codes, Google hl/gl language and country codes) and the semantics of the two filter params (min_rating 0-5, min_hotel_class 2-5) plus the cost implication of include_provider_prices.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description opens with a specific verb and resource ('Search Google Hotels for a destination between two dates'), which immediately distinguishes it from search_vacation_rentals and hotel_price_calendar by domain. It does not explicitly name or contrast the siblings, so the differentiation is implicit rather than stated.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines3/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Usage is implied by the request shape (destination + date range) and there is a conditional note about when to set include_provider_prices. However, nothing tells the agent when to prefer this tool over hotel_price_calendar or search_vacation_rentals, and no exclusions are given.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

search_vacation_rentalsA

Search Google Vacation Rentals (Airbnb / Vrbo / Booking.com) for a stay.

Returns a JSON array of rentals with title, nightly price, total price, rating, review count, bedrooms, bathrooms, amenities, hero photo and the Google /travel/vacation-rentals/entity URL. When include_provider_prices is true each rental also gets a providers list with the price every listing site (Airbnb, Vrbo, Booking.com) is charging (one extra provider-prices call per rental, billed per-rental).

Args: query: destination, e.g. "vacation rentals in Lisbon". check_in: ISO date YYYY-MM-DD. check_out: ISO date YYYY-MM-DD. adults: number of adults. children: number of children. currency: ISO 4217 code. hl: Google interface language. gl: Google country code. max_results: upper bound on rentals returned. include_provider_prices: fetch per-provider rates. Each rental priced this way adds one provider-prices call to the Apify bill. Defaults to false to keep costs predictable.

NameRequiredDescriptionDefault
glNous
hlNoen
queryYes
adultsNo
check_inYes
childrenNo
currencyNoUSD
check_outYes
max_resultsNo
include_provider_pricesNo

Output Schema

NameRequiredDescription
resultYes

TDQS

A4.1/5.0
Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries the full burden and does so well: it discloses the return structure (array with title, prices, rating, amenities, hero photo, entity URL) and, critically, the billing behavior of include_provider_prices (one extra provider-prices call per rental, billed per-rental, default false for cost predictability). It does not mention rate limits or pagination, but cost and output behavior are unusually well surfaced.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The tool purpose and return shape are front-loaded before the Args block, which is the right order for an agent. The args list is complete but verges on verbose for parameters like adults/children that need no explanation, though nothing is egregiously padded.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a 10-parameter search tool with no annotations, the definition covers purpose, output fields, all parameter formats, and the cost/behavioral tradeoff of the one non-obvious flag. An output schema exists, yet the description's summary of return fields is complementary rather than redundant, and nothing needed to call it correctly appears missing.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters5/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 0%, so the description must compensate, and it documents every one of the 10 parameters. It adds format and meaning beyond the bare schema: ISO YYYY-MM-DD for dates, ISO 4217 for currency, example query text, and the semantics of hl/gl as interface language and country code, plus the cost consequence of include_provider_prices.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description opens with a specific verb+resource ("Search Google Vacation Rentals") and names the underlying sources (Airbnb / Vrbo / Booking.com), so the agent knows exactly what is being searched. It does not explicitly differentiate itself from the sibling search_hotels, though the rental-vs-hotel distinction is implicit in the resource name.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines3/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

There is no explicit statement of when to choose this over search_hotels or hotel_price_calendar, so routing between siblings is left to inference from the resource name. It does give a clear conditional for one parameter ("When include_provider_prices is true..."), which is useful but limited to a single option rather than overall tool selection.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

  1. 3 tool updatesv0.1.2
    • First observedhotel_price_calendar
    • First observedsearch_hotels
    • First observedsearch_vacation_rentals

TDQS

A3.8/5.0

Scored across 3 tools

Disambiguation4/5

search_hotels and search_vacation_rentals are distinguished by resource type (hotels vs vacation rentals), which descriptions make clear, but the boundary could be blurry for a query like 'apartments in Lisbon'. hotel_price_calendar is clearly distinct as a per-property pricing tool.

Naming Consistency4/5

Two tools follow a clean verb_noun pattern (search_hotels, search_vacation_rentals) and all names are snake_case, but hotel_price_calendar deviates to a noun-phrase form, slightly breaking the search_* symmetry an agent might expect.

Tool Count3/5

Three tools is thin for a travel-search server, though each covers a distinct capability. A property-details or reviews tool would round out the surface, so the count sits at the borderline rather than being well-scoped.

Completeness3/5

The set covers hotel search, per-property pricing, and vacation rentals, but there is no tool to fetch full details or reviews for a single hotel, and no equivalent calendar for rentals. Agents can work around this via search results, but notable gaps remain.

Maintenance

ActivityMaintained
ResponsivenessNo issues

Related MCP Connectors

Related MCP Servers