# Google Hotels Scraper: Prices by Date & Site (`cleanpull/google-hotels-scraper`) Actor Google Hotels prices for any city, hotel and dates: rates from every booking site with links, taxes, ratings, amenities and photos, plus price calendars and changes-only price monitoring. Hotel price comparison from $3 per 1,000 hotels; compact JSON for AI agents. - **URL**: https://apify.com/cleanpull/google-hotels-scraper.md - **Developed by:** [CleanPull](https://apify.com/cleanpull) (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 $2.40 / 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 by Date & Site Get Google Hotels prices for any city, area or hotel and any dates: the nightly and total price with and without taxes, **every booking site** (Booking.com, Expedia, Agoda, Hotels.com, the hotel's own site and more) with booking links, **room-level rates** with free-cancellation deadlines, ratings, review breakdowns, amenities, location and photos. Price whole calendars of dates in one run, and **monitor prices with a changes-only mode** that returns just what moved since the last run. Fast, reliable HTTP requests (no browser), from **$3 per 1,000 hotels**. ### What you can do with it - **Compare hotel prices for a trip**: "Hotels in Lisbon for 10–13 November, 2 adults, 4 stars and up, under €200 a night, sorted by price." - **Price a whole calendar**: "Cheapest night to stay in Rome in December" — price every check-in date in a range, for one or several lengths of stay, in one run. - **Watch your competitors' rates (revenue management)**: list your hotel and your competitive set by name, schedule the run daily with `+30` (30 days ahead), and get only the price changes. - **Check rate parity**: every booking site's price for a hotel next to the hotel's own site, flagged with `isOfficial`, plus `cheapestSource` and `officialSiteRatePerNightWithTaxes`. - **Find deals and drops**: Google's deal labels ("25% less than usual") and price-drop alerts from monitoring. - **Research a market**: hundreds of hotels per city with star class, rating, review counts, review sentiment by topic (service, location, breakfast…), amenities and coordinates. - **Vacation rentals**: apartments and houses with bedrooms, beds, bathrooms and capacity. - **Feed an AI agent, sheet or dashboard**: flat rows (one per hotel and booking site), only the fields you choose, and a run summary with the outcome of every search. ### Why this actor - **It works, and tells you when it can't.** Plain HTTP calls to Google Hotels' own data endpoint with automatic session rotation and proxy escalation (direct → datacenter → residential only when needed). A blocked or failed search is retried, then reported in `RUN_SUMMARY` — never returned as "0 hotels". A place Google doesn't recognise is reported instead of silently returning hotels from somewhere else (Google falls back to hotels near the caller). - **Switch without changing your code.** Already using a Google Hotels actor? The input keys `locations`, `checkInDate`, `checkOutDate`, `adults`, `currency`, `languageCode`, `countryCode`, `maxResults`, `requestTimeoutSecs` and `proxyConfiguration` work the same here, and every record also carries that actor's record field names (`name`, `price`, `priceValue`, `rating`, `reviewCount`, `hotelClass`, `starRating`, `latitude`, `longitude`, `placeId`, `hotelDescription`, `imageUrl`, `googleMapsUrl`, `googleHotelsUrl`, `location`, `checkInDate`, `checkOutDate`, `currency`, `scrapedAt`). Change the actor id and keep your schedules and parsers. - **Changes-only monitoring.** With `monitorMode`, each run is compared with the last run of the same search: you get price drops and rises (above your threshold), hotels selling out or coming back, and new or removed hotels — and unchanged hotels cost a sixth of a result. - **Dates that keep working on a schedule.** Write `+30` instead of a date and a daily schedule always looks 30 days ahead (monitoring compares "the stay 30 days ahead" day after day). - **Every filter Google Hotels has**: sort, price range, guest rating, star classes, 19 amenities, 9 hotel types, hotel brands by name, free cancellation, special offers, children with ages, vacation rentals. - **Taxes both ways.** Every price comes with and without taxes and fees, as numbers and as Google displays them. ### Input | Field | Type | What it does | | -------------------------------------------- | -------------------------------------------------------------- | --------------------------------------------------------------------------------------------------- | | `locations` | array of strings | Places to search: "Lisbon", "Shibuya, Tokyo", "near Times Square". Each runs "hotels in " | | `searchQueries` | array of strings | Free-form Google Hotels searches, as typed in Google | | `hotels` | array of strings | Specific hotels by name, e.g. "Avenida Palace Lisbon" | | `startUrls` | array of URLs | Google Hotels hotel pages or search pages | | `propertyType` | `hotels`, `vacation-rentals` | What to search (default `hotels`) | | `checkInDate`, `checkOutDate` | `YYYY-MM-DD` or `+N` | The stay; `+N` is N days after the run date (default check-in `+14`, 1 night) | | `nights` | array of integers | Lengths of stay to price, e.g. `[1, 3, 7]` | | `checkInDates` | array of dates | More check-in dates | | `checkInDateTo`, `dateStep` | date, integer | Price every check-in date up to this date, every `dateStep` days | | `adults`, `childrenAges` | integer, array | Guests (up to 30 adults), e.g. `2` and `[4, 9]` | | `sortBy` | `relevance`, `lowest-price`, `highest-rating`, `most-reviewed` | Google's sort order | | `minPrice`, `maxPrice` | integers | Price per night range, in `currency` | | `minRating` | `3.5`, `4`, `4.5` | Minimum guest rating | | `hotelClass`, `hotelClasses` | integer, array | Minimum stars, or exact star classes | | `amenities` | array | `free-wifi`, `free-breakfast`, `pool`, `spa`, `pet-friendly`, `free-parking`, `ev-charger`… (19) | | `hotelTypes` | array | `hostel`, `bed-and-breakfast`, `boutique-hotel`, `spa-hotel`, `beach-hotel`, `apartment-hotel`… | | `brands` | array of strings | Brand names, e.g. "Marriott Bonvoy" (with all its brands) or "Moxy" | | `freeCancellation`, `specialOffers` | boolean | Only free-cancellation offers / only hotels with offers | | `maxResults` | integer | Hotels per search and stay (default 20, up to 1,000) | | `maxItems` | integer | Stop after this many results in the run (a cost cap) | | `includeBookingSources` | boolean | Every booking site's price and link, and review scores by site (one extra request per hotel) | | `includeRoomRates` | boolean | Room-level rates with cancellation terms | | `monitorMode`, `monitorName` | boolean, string | Changes only, compared with the last run under the same name | | `changeTypes` | array | `new`, `price-drop`, `price-rise`, `sold-out`, `back-in-stock`, `removed` | | `priceChangePercent`, `priceChangeMinAmount` | numbers | Ignore smaller price moves (default 1%) | | `removedAfterRuns` | integer | Missing runs in a row before a hotel counts as removed (default 2) | | `currency`, `languageCode`, `countryCode` | strings | `EUR`, `de`, `de`: prices, language and the region Google searches from | | `outputFormat` | `nested`, `flat` | One record per hotel, or flat rows (one per hotel and booking site) | | `fields` | array of strings | Return only these fields (dotted paths allowed) | #### Example inputs A trip search with filters: ```json { "locations": ["Lisbon"], "checkInDate": "2026-11-10", "checkOutDate": "2026-11-13", "currency": "EUR", "sortBy": "lowest-price", "hotelClass": 4, "maxPrice": 200, "amenities": ["free-wifi", "pool"], "maxResults": 50, "includeBookingSources": true } ``` A daily competitor-rate monitor (schedule it once a day): ```json { "hotels": ["Hotel Mundial Lisbon", "Avenida Palace Lisbon", "Hotel Avenida Lisbon"], "checkInDate": "+30", "nights": [1, 2], "currency": "EUR", "includeBookingSources": true, "monitorMode": true, "monitorName": "lisbon-compset", "changeTypes": ["price-drop", "price-rise", "sold-out", "back-in-stock"], "priceChangePercent": 3 } ``` A price calendar: every Friday-to-Sunday stay in December: ```json { "locations": ["Rome"], "checkInDate": "2026-12-04", "checkInDateTo": "2026-12-25", "dateStep": 7, "nights": [2], "sortBy": "lowest-price", "maxResults": 10 } ``` ### Output One record per hotel and stay (shortened; a real record from 5 October 2026): ```json { "hotelName": "Hotel Mundial", "hotelId": "16189655629992449383", "propertyType": "hotel", "position": 1, "searchQuery": "hotels in Lisbon", "location": "Lisbon", "resolvedLocation": "Lisbon", "checkInDate": "2026-11-10", "checkOutDate": "2026-11-13", "nights": 3, "adults": 2, "currency": "EUR", "available": true, "pricePerNight": 99.59, "pricePerNightDisplay": "€100", "pricePerNightWithTaxes": 114, "totalRate": 299, "totalRateWithTaxes": 341, "deal": "25% less than usual", "hotelDescription": "Straightforward rooms in a relaxed hotel offering a traditional restaurant & a rooftop bar.", "hotelClass": "4-star hotel", "starRating": 4, "overallRating": 4.3, "reviewCount": 7199, "ratingsBreakdown": [{ "stars": 5, "percent": 54, "count": 3705 }], "reviewsBreakdown": [ { "name": "Breakfast", "sentiment": 0.43, "total_mentioned": 276, "positive": 188, "negative": 60 } ], "gpsLatitude": 38.7150471, "gpsLongitude": -9.1369825, "address": "Praça Martim Moniz 2, 1100-341 Lisboa, Portugal", "phone": "+351 21 884 2000", "website": "https://www.hotel-mundial.pt/", "amenities": [ "Breakfast ($)", "Free Wi-Fi", "Parking ($)", "Air conditioning", "Bar", "Restaurant" ], "nearbyPlaces": [ { "name": "Tram 28", "category": "attraction", "transportations": [{ "type": "transit", "duration": "1 min" }] } ], "googleHotelsUrl": "https://www.google.com/travel/hotels/entity/ChgIrYeF1aLy5vM5GgwvZy8xamt2dDlkdmcQAQ/prices?hl=en&gl=us&curr=EUR&checkin=2026-11-10&checkout=2026-11-13", "bookingSources": [ { "vendorName": "Hotel Mundial", "isOfficial": true, "isSponsored": false, "numGuests": 2, "ratePerNight": 100, "ratePerNightWithTaxes": 114, "totalRate": 299, "totalRateWithTaxes": 341, "bookingUrl": "https://www.google.com/travel/lodging/clk?..." }, { "vendorName": "Expedia.com", "isOfficial": false, "ratePerNight": 146, "ratePerNightWithTaxes": 163, "totalRate": 439, "bookingUrl": "https://www.google.com/travel/lodging/clk?..." } ], "bookingSourceCount": 27, "cheapestSource": "Hotel Mundial", "cheapestBasis": "with-taxes", "cheapestRatePerNightWithTaxes": 114, "officialSiteRatePerNightWithTaxes": 114, "roomRates": [ { "vendorName": "Hotel Mundial", "roomName": "Classic Room - Standard rate Room Only", "ratePerNight": 99.59, "ratePerNightWithTaxes": 113.57, "totalRate": 298.78, "totalRateWithTaxes": 340.71, "freeCancellation": false, "freeCancellationUntil": null } ], "scrapedAt": "2026-10-05T19:53:46.724Z" } ``` `location` is what you asked for; `resolvedLocation` is the place Google searched. `cheapestSource` compares sites on one basis (`cheapestBasis`): including taxes among the sites that show it, otherwise before taxes. `fields` paths reach into lists too: `["hotelName", "bookingSources.vendorName", "bookingSources.ratePerNightWithTaxes"]`. `available: false` with null prices means Google shows no price for those dates (sold out or not bookable). Vacation rentals add `essentialInfo` (for example "Entire apartment", "Sleeps 4", "2 bedrooms"). In monitoring mode each record starts with the change: `changeType`, `previousPricePerNight`, `priceChange`, `priceChangePercent` and `previouslySeenAt`. Removed hotels come as a short record with what was last known. Every run also writes `RUN_SUMMARY` to the key-value store: the outcome (`COMPLETE`, `PARTIAL`, `NO_CHANGES`, `EMPTY` or `FAILED`), counts of results, changes and booking-source lookups, warnings, and the reason for any failed search. ### Pricing Pay only for results delivered. Blocked or failed searches are never charged. | Event | Free and Bronze | Silver | Gold | | ------------------------------------------------------------------- | --------------- | ------ | ----- | | Hotel result (one hotel for one stay, with price and listing data) | $3.00 | $2.70 | $2.40 | | Booking sources and room rates (add-on per hotel, when switched on) | $2.00 | $1.80 | $1.60 | | Change (monitoring mode: one changed hotel) | $3.00 | $2.70 | $2.40 | | Unchanged hotel checked (monitoring mode) | $0.50 | $0.45 | $0.40 | Prices are per 1,000; your tier depends on your Apify plan. Each run also has a $0.00005 start fee. Flat mode is billed per hotel, not per row. ### How monitoring works Each search (place or hotel × stay × filters) keeps its own memory under your `monitorName`. The first run reports every hotel as `new` and sets the baseline; later runs report only changes. Prices compare per night before taxes. A hotel counts as `removed` only after it is missing from `removedAfterRuns` searches in a row that reached the end of Google's results. With a `maxResults` cap, Google's ranking reshuffles which hotels make the top N, so hotels entering your top N show as `new`: for exact watch lists, list hotels by name (`hotels`), or sort by price. ### Limits - Google shows a few hundred hotels per search at most (about 200 when sorted by price). For larger `maxResults` the actor runs extra passes (other sort orders and price bands, or continuing from the last price when sorted by price), so big cities return up to 1,000 hotels; later passes follow the first in the results. - Prices are what Google Hotels shows a logged-out visitor in the chosen region and currency; booking sites can show different prices to signed-in members. - `reviewSources` holds each site's rating and review count with the few sample reviews Google includes; it is not a full review export. - Amenity filters are the ones Google Hotels offers; any amenity Google lists for a hotel is returned in `amenities`. - Google answers a place it doesn't recognise with hotels near the caller; this actor asks again, then reports that search as failed instead. - Check-in dates already past are skipped with a warning (a scheduled run keeps its other dates); use `+N` dates in schedules. - Two runs with the same `monitorName` and search at the same time share one memory; schedule them apart. - **Nothing found**: a place Google does not recognise, or a hotel name with no match, is not a failure: when no search finds anything, the run still succeeds, with one free `recordType: "unreadable"` row per search giving the `reason`; nothing is charged. A run near its time limit stops starting searches, delivers what it found and lists the rest in RUN_SUMMARY. ### Changelog - **0.1.x, reliability** (2026-10-24): runs that find nothing (places Google does not know, hotel names with no match, invalid dates) end SUCCEEDED with a free `unreadable` row saying why, instead of FAILED; dates and currency are checked in the input form; a run stops starting searches before its time limit, never TIMED-OUT. A run whose every search Google blocked still fails. Prices and events unchanged. - **0.1** (October 2026): searches by place, query, hotel name and URL; every Google Hotels filter; booking sources and room rates; price calendars; vacation rentals; changes-only monitoring; flat output and field selection; input compatible with other Google Hotels actors. # Actor input Schema ## `locations` (type: `array`): Cities, neighbourhoods, landmarks or regions, one per line. Each becomes the Google Hotels search "hotels in " (or "vacation rentals in "). A line that already says what to find, such as "boutique hotels near the Eiffel Tower", is searched as written. ## `searchQueries` (type: `array`): Optional. Free-form Google Hotels searches, exactly as you would type them in Google, for example "hotels with pool near Disneyland Paris". ## `hotels` (type: `array`): Optional. Specific hotels to price, one per line, for example "Avenida Palace Lisbon". Adding the city helps Google find the right one. Use this to watch a competitive set of hotels. ## `startUrls` (type: `array`): Optional. Google Hotels hotel pages (google.com/travel/hotels/entity/...) or search pages (google.com/travel/search?q=...). Hotel pages return that hotel; search pages run their query. ## `propertyType` (type: `string`): Search hotels or vacation rentals (apartments, houses). ## `checkInDate` (type: `string`): YYYY-MM-DD, or +N for N days after the day the run starts (for example +30). Use +N in scheduled runs so they keep looking the same distance ahead. Dates already past are skipped with a warning. ## `checkOutDate` (type: `string`): Optional. YYYY-MM-DD or +N. Sets the length of stay; ignored when Nights is set. Without either, stays are 1 night. ## `nights` (type: `array`): Optional. One or more lengths of stay, for example \[1, 3, 7]. Each check-in date is priced for each length. ## `checkInDates` (type: `array`): Optional. Extra check-in dates (YYYY-MM-DD or +N), each priced like the first. ## `checkInDateTo` (type: `string`): Optional. Price every check-in date from Check-in date up to this date (YYYY-MM-DD or +N), every Date step days: a price calendar. ## `dateStep` (type: `integer`): Days between check-in dates in a date range. ## `adults` (type: `integer`): Adult guests. ## `childrenAges` (type: `array`): Ages of child guests, for example \[4, 9]. Prices change with the number and ages of children. ## `sortBy` (type: `string`): Google's sort order. With a Max results limit, this decides which hotels you get. ## `minPrice` (type: `integer`): Optional. In the chosen currency. ## `maxPrice` (type: `integer`): Optional. In the chosen currency. ## `minRating` (type: `string`): Optional. Only hotels rated at least this on Google. ## `hotelClass` (type: `integer`): Optional. Only hotels with at least this many stars (2 to 5). ## `hotelClasses` (type: `array`): Optional. Only these star classes, for example \[3, 4]. Overrides Minimum star class. ## `amenities` (type: `array`): Optional. Only properties with all of these amenities (the filters Google Hotels offers). ## `hotelTypes` (type: `array`): Optional. Only these kinds of hotel. ## `brands` (type: `array`): Optional. Brand or chain names as Google lists them for the place, for example "Marriott Bonvoy" (with all its brands) or "Moxy". Unknown names are reported in the log. ## `freeCancellation` (type: `boolean`): Only offers that can be cancelled for free. ## `specialOffers` (type: `boolean`): Only hotels with a special offer or deal. ## `maxResults` (type: `integer`): Hotels per location, query and stay. The actor pages through Google (20 a page), and when Google stops paging a search (it shows a few hundred hotels at most), runs extra passes with other sort orders and price bands until it has this many or Google has no more. Sorted by lowest price, extra passes continue from the highest price seen, so results stay in price order. ## `maxItems` (type: `integer`): Optional. Stop after this many results in total (a cost cap). ## `includeBookingSources` (type: `boolean`): Fetch each hotel's full price list: every booking site (Booking.com, Expedia, Agoda, the hotel's own site...) with nightly and total prices, taxes and booking links, and review scores by site. One extra request per hotel, billed as a detail. ## `includeRoomRates` (type: `boolean`): Also return room-level rates (room name, price per site, free-cancellation deadline). Comes with the same detail request as booking sources. ## `monitorMode` (type: `boolean`): Remember each run and return only what changed since the last run under the same Monitor name: price drops and rises, hotels selling out or coming back, new and removed hotels. Unchanged hotels are billed at a fraction of a result. ## `monitorName` (type: `string`): Runs with the same name compare with each other. Use one name per watch list. ## `changeTypes` (type: `array`): Which changes count. The first run reports every hotel as new. ## `priceChangePercent` (type: `number`): Ignore price moves smaller than this percentage. ## `priceChangeMinAmount` (type: `number`): Ignore price moves smaller than this amount in the chosen currency. ## `removedAfterRuns` (type: `integer`): Report a hotel as removed only after it is missing from this many runs in a row (Google reshuffles results; one miss is often noise). Only searches that reached the end of Google's results count. ## `currency` (type: `string`): Three-letter currency code for prices, for example USD, EUR, GBP, JPY. ## `languageCode` (type: `string`): Language for names and descriptions (Google hl), for example en, fr, de, es. ## `countryCode` (type: `string`): Region Google searches from (Google gl), for example us, gb, de. Prices can differ by region. ## `outputFormat` (type: `string`): Nested keeps lists (booking sources, rooms, amenities) inside each hotel. Flat gives one row per hotel and booking site with plain columns, for CSV, Excel and AI agents. ## `fields` (type: `array`): Optional. Keep only these fields in each record, for example \["hotelName", "pricePerNight", "bookingSources"]. Dotted paths reach nested fields. ## `searchQuery` (type: `string`): Optional. One search query; same as adding it to Search queries. ## `requestTimeoutSecs` (type: `integer`): Timeout for each request to Google. ## `proxyConfiguration` (type: `object`): Optional. The actor picks proxies itself: direct first, then datacenter, then residential only if Google blocks the others. Set a proxy here to use it after the direct attempt. ## Actor input object example ```json { "locations": [ "Lisbon" ], "propertyType": "hotels", "checkInDate": "+14", "dateStep": 1, "adults": 2, "childrenAges": [], "sortBy": "relevance", "amenities": [], "freeCancellation": false, "specialOffers": false, "maxResults": 20, "includeBookingSources": false, "includeRoomRates": false, "monitorMode": false, "monitorName": "default", "changeTypes": [ "new", "price-drop", "price-rise", "sold-out", "back-in-stock", "removed" ], "priceChangePercent": 1, "priceChangeMinAmount": 0, "removedAfterRuns": 2, "currency": "USD", "languageCode": "en", "countryCode": "us", "outputFormat": "nested", "requestTimeoutSecs": 30 } ``` # Actor output Schema ## `results` (type: `string`): Every hotel record (or change record in monitoring mode, or flat rows). ## `overview` (type: `string`): No description ## `bookingSources` (type: `string`): No description ## `changes` (type: `string`): No description ## `runSummary` (type: `string`): Outcome (COMPLETE, PARTIAL, NO_CHANGES, EMPTY, FAILED), counts, warnings and any failed searches. # 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 '' with your token const client = new ApifyClient({ token: '', }); // Prepare Actor input const input = { "locations": [ "Lisbon" ], "checkInDate": "+14" }; // Run the Actor and wait for it to finish const run = await client.actor("cleanpull/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 '' with your token. client = ApifyClient("") # Prepare the Actor input run_input = { "locations": ["Lisbon"], "checkInDate": "+14", } # Run the Actor and wait for it to finish run = client.actor("cleanpull/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": [ "Lisbon" ], "checkInDate": "+14" }' | apify call cleanpull/google-hotels-scraper --silent --output-dataset ``` ## MCP server setup ```json { "mcpServers": { "apify": { "type": "http", "url": "https://mcp.apify.com/?tools=fetch-actor-details,cleanpull/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 ` 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/KGNP9vhRvV7eX7Bfr/builds/TG564AndP56M0qmL2/openapi.json