# Google Travel Hotels Scraper: Hotel Prices & Flight Fares (`moggedhq/google-hotels-flights-scraper`) Actor

Get Google Hotels prices or Google Flights fares for a trip, e.g. hotels in Paris next weekend or New York to London flights. About $0.0035 per hotel, $0.0018 per flight. Hotel price comparison across booking sites, rating, reviews; airline, times, stops, CO2. Airfare and hotel price tracker.

- **URL**: https://apify.com/moggedhq/google-hotels-flights-scraper.md
- **Developed by:** [mogged](https://apify.com/moggedhq) (community)
- **Categories:** Travel, AI, Automation
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.80 / 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 Travel Hotels Scraper: Hotel Prices & Flight Fares

**Get Google Hotels prices or Google Flights fares for a trip: for example hotels in Paris next weekend, or flights from New York to London.**

For travel agencies, travel startups, hotel revenue managers, price trackers and AI travel agents that need Google Hotels and Google Flights data as clean rows, without a Google account.

**About $0.0035 per hotel and $0.0018 per flight.** Checking 50 hotels in Paris costs about $0.18; 20 flights from New York to London cost about $0.04. A first run with the default settings costs under $0.10 and takes about half a minute.

Type a city or a route, pick dates, and get:

- **Hotels** from Google Hotels: price per night and for the whole stay, the price on every booking site (Booking.com, Expedia, Hotels.com, Agoda, the hotel's own site and others), star class, guest rating and review count, address, phone, amenities, photos, check-in and check-out times, coordinates and links.
- **Flights** from Google Flights: airlines, flight numbers, departure and arrival times, duration, stops and layovers, price, CO2 estimate and Google's "best flights" flag.

No login, no cookies to paste, no browser to run. Runs that hit bad input still finish and tell you, in plain words, what to change, free of charge.

### Pricing

You pay only for what you get:

| What you get | Price |
|---|---|
| A hotel, with every booking site's price | **$0.0035** |
| A flight option | **$0.0018** |

What a typical job costs before you press Start:

| Job | Results | Cost | Time |
|---|---|---|---|
| First run with the default settings, one city | 20 hotels | about $0.07 | about 15 seconds |
| Compare booking-site prices across a city | 100 hotels | about $0.35 | about 1 minute |
| Daily price tracker, 3 cities | 150 hotels a day | about $0.53 a day | 1 to 2 minutes |
| One flight route | 20 flights | about $0.04 | under 20 seconds |
| A route in depth | 100 flights | about $0.18 | under 30 seconds |

Higher Apify plans get 5% to 20% off. Rows that only explain a problem (a typo in a date, a place Google cannot find) are never charged. On the free Apify plan each run shows the first 20 results; any paid Apify plan removes the limit.

### Hotel fields

| Field | Example |
|---|---|
| `summary` | Hotel Best Roma: $74 a night, $147 total for 2 nights. 4-star, rated 3.3/5 from 600 reviews. Cheapest of 13 booking sites: Amimir.com at $74 a night. |
| `name` | Hotel Best Roma |
| `pricePerNight` / `totalPrice` / `currency` | 73.63 / 147.26 / USD |
| `priceBeforeTaxes` / `taxesAndFees` | when Google shows the split |
| `dealText` | 41% less than usual |
| `bookingSites` | site, price per night, total, free cancellation until, room type, booking link |
| `lowestBookingSite` | Amimir.com |
| `hotelClass` / `rating` / `reviewCount` | 4 / 3.3 / 600 |
| `ratingBreakdown` | count of 5 to 1 star reviews |
| `otherRatings` | Tripadvisor, Priceline, Trip.com scores |
| `address` / `phone` / `website` | Via di Porta Maggiore, 51, 00185 Roma RM, Italy |
| `latitude` / `longitude` / `countryCode` | 41.8928 / 12.5116 / IT |
| `checkInTime` / `checkOutTime` | 2:00 PM / 11:00 AM |
| `amenities` / `amenitiesNotAvailable` | Free Wi-Fi, Free breakfast, Pool, Spa |
| `mainPhotoUrl` / `photos` | Google photo links |
| `description` | Google's short write-up |
| `nearbyPlaces` | nearest attraction, transit stop and airport with travel time |
| `propertyType` | hotel, bed_and_breakfast, hostel, vacation_rental |
| `hotelId` / `placeId` | Google Hotels id and Google Maps place id |
| `googleHotelsUrl` / `googleMapsUrl` | links that open the same dates on Google |
| `checkIn` / `checkOut` / `nights` / `adults` / `children` | the stay that was priced |

### Flight fields

| Field | Example |
|---|---|
| `summary` | $368 one way, nonstop: Virgin Atlantic VS 26, JFK 08:00 to LHR 20:10 (7 hr 10 min). |
| `from` / `to` | JFK / LHR |
| `price` / `currency` / `priceNote` | 368 / USD / One-way price for all passengers |
| `airlines` / `flightNumbers` | Virgin Atlantic / VS 26 |
| `departureTime` / `arrivalTime` | 2026-11-11 08:00 / 2026-11-11 20:10 (local times) |
| `durationMinutes` / `durationText` | 430 / 7 hr 10 min |
| `stops` / `layovers` | 1 / FCO, Rome, 45 minutes |
| `segments` | each flight: number, airline, airports, times, aircraft, legroom |
| `carbonEmissionsKg` / `typicalCarbonEmissionsKg` / `emissionsDifferencePercent` | 365 / 432 / -16 |
| `isBestFlight` | true for Google's "best flights" |
| `tripType` / `cabin` / `adults` / `children` | one_way / economy / 1 / 0 |
| `googleFlightsUrl` | opens the same search on Google Flights |

### How to use

**Hotels:** set `location` and, if you like, dates, guests and filters.

```json
{
  "searchType": "hotels",
  "location": "Paris",
  "checkIn": "2026-12-04",
  "checkOut": "2026-12-06",
  "adults": 2,
  "maxPrice": 200,
  "minRating": "4",
  "currency": "EUR",
  "maxResults": 50
}
```

**Flights:** set `from` and `to` (codes like JFK, LHR, NYC or city names like New York) and a date. Add `returnDate` for round trips.

```json
{
  "searchType": "flights",
  "from": "New York",
  "to": "London",
  "departDate": "2026-12-10",
  "returnDate": "2026-12-17",
  "cabin": "economy",
  "stops": "nonstop",
  "flightSort": "cheapest",
  "maxResults": 30
}
```

Leave the dates empty and the Actor uses 30 days from today (2 nights for hotels), so saved tasks and schedules always look ahead. Dates also accept "+14 days" or "friday".

Hotel filters work like Google Hotels' own: `minPrice`, `maxPrice` (per night), `minRating` (3.5, 4, 4.5), `hotelClass` (2 to 5 stars), `amenities` (free Wi-Fi, free breakfast, pool, spa, pet-friendly, free parking and more) and `sortBy` (relevance, lowest_price, highest_rating, most_reviewed). Several cities in one run: add them to `locations`.

### Daily price tracking

Save your search as a task and add a schedule (Apify Console, Schedules) to run it every morning. Each run is a fresh snapshot with `scrapedAt`, so you can chart a hotel's price or a route's fare over time in Google Sheets, a database or your BI tool. With empty dates the window rolls forward every day; with fixed dates you watch the same stay or flight approach.

### Use with AI agents (MCP)

AI agents can call this Actor through Apify's MCP server (mcp.apify.com) or the Apify API. Inputs are plain words an agent can fill in from a request like "find hotels in Rome for 2 nights next month under $150 with ratings":

```json
{ "location": "Rome", "checkIn": "+30 days", "nights": 2, "maxPrice": 150, "minRating": "4", "maxResults": 10 }
```

Every row starts with `summary`, a one-sentence answer an agent can quote as it is, followed by flat JSON with numbers as numbers, so an agent can sort and compare prices directly. Problems come back as a `message` row that tells the agent what to fix, instead of a failed run.

### Good to know

- **Prices change all the time.** They are Google's prices at the moment of the run, for the dates and guests you gave. Run again for a fresh price.
- **Taxes and fees vary by country.** Google includes them where it knows them; `priceBeforeTaxes` and `taxesAndFees` are filled when Google shows the split. Booking sites may add fees at checkout.
- **Booking sites depend on the region.** Which sites appear can change with `country` and over time.
- **Round trips:** each row is an outbound flight with the round-trip price; open `googleFlightsUrl` to pick the return flight.
- **Flights per search:** you get the itineraries Google lists in its "all flights" view: usually 80 to 300 on busy routes in our tests, fewer on thin routes. Each row is one itinerary; the same flight can appear with different connections.
- **Hotels per location:** up to 1,000, as far as Google Hotels pages go.
- Some properties show no price for your dates (sold out or not bookable on Google); those rows have `available: false`.

### FAQ

**Is this legal?** It collects only public pages that anyone can open without logging in. You are responsible for how you use the data, including any rules in your country.

**Is this an official Google product?** No. This Actor is not affiliated with, endorsed by or connected to Google.

**Why does a price differ from what I see on Google?** Google personalises by country, currency and time. Use the same `currency`, `country` and dates, and remember prices move during the day.

**Do I need a proxy or an account?** No. The Actor uses Apify Proxy and retries any blocked request on a fresh IP automatically. You never need a Google account.

**What does a run cost if something goes wrong?** Nothing for the problem rows. You pay only for hotel and flight rows delivered.

# Actor input Schema

## `searchType` (type: `string`):

Hotels (fill in Location) or flights (fill in From and To). If you leave Location empty and fill in From and To, the Actor searches flights.

## `location` (type: `string`):

City, area, address or landmark, written as you would on Google Hotels: "Paris", "Manhattan, New York", "hotels near the Eiffel Tower", "resorts in Cancun".

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

Search several places in one run, one per line. Max results applies to each location.

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

YYYY-MM-DD or a relative date such as "+30 days". Empty = 30 days from today, so scheduled runs always look ahead.

## `checkOut` (type: `string`):

YYYY-MM-DD. Empty = check-in plus Nights.

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

Length of stay used when no check-out date is given. Google allows up to 30 nights.

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

In the chosen currency. Leave empty for no minimum.

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

In the chosen currency, for example 200. Leave empty for no maximum.

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

Only hotels rated at least this on Google (out of 5).

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

Only hotels of these star classes. Leave empty for all.

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

Only hotels that have all of these, as Google Hotels' own filters.

## `sortBy` (type: `string`):

Google Hotels' own sort orders.

## `includeBookingSites` (type: `boolean`):

For each hotel, also get every booking site's price (Booking.com, Expedia, Hotels.com, the hotel's own site and others), free-cancellation dates, street address, phone and ratings from other sites. Same price per hotel; turn off for faster runs.

## `includeVacationRentals` (type: `boolean`):

Google mixes some apartments and houses into hotel results. Off = hotels, B\&Bs, hostels and other lodging only.

## `from` (type: `string`):

Airport or city code (JFK, LHR, NYC, LON) or a city name (New York, Cape Town).

## `to` (type: `string`):

Airport or city code (CDG, NRT, PAR) or a city name (Paris, Tokyo).

## `departDate` (type: `string`):

YYYY-MM-DD or "+30 days". Empty = 30 days from today.

## `returnDate` (type: `string`):

Leave empty for one way. With a return date, prices are round-trip totals and each row is an outbound flight.

## `cabin` (type: `string`):

Seat class to price.

## `stops` (type: `string`):

Maximum number of stops.

## `flightSort` (type: `string`):

Best keeps Google's own order (its "best flights" first).

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

Guests for hotels or passengers for flights. Empty = 2 for hotels, 1 for flights.

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

Number of children (0 to 8).

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

One age per child, 0 to 17. Missing ages count as 8.

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

Prices are shown in this currency.

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

Most hotels per location, or most flight itineraries. You pay per result, so this also caps the cost: 100 hotels = $0.35, 50 flights = $0.09. Free Apify plans get up to 20 results per run.

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

Two-letter country code for the Google region, which can change which booking sites appear. Default us.

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

Apify Proxy is used by default; blocked requests are retried on new IPs automatically.

## Actor input object example

```json
{
  "searchType": "hotels",
  "location": "New York",
  "nights": 2,
  "minRating": "any",
  "sortBy": "relevance",
  "includeBookingSites": true,
  "includeVacationRentals": false,
  "cabin": "economy",
  "stops": "any",
  "flightSort": "best",
  "children": 0,
  "currency": "USD",
  "maxResults": 10,
  "country": "us",
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

No description

## `flights` (type: `string`):

No description

## `all` (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 = {
    "searchType": "hotels",
    "location": "New York",
    "maxResults": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("moggedhq/google-hotels-flights-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 = {
    "searchType": "hotels",
    "location": "New York",
    "maxResults": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("moggedhq/google-hotels-flights-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 '{
  "searchType": "hotels",
  "location": "New York",
  "maxResults": 10
}' |
apify call moggedhq/google-hotels-flights-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,moggedhq/google-hotels-flights-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/oEj9jpw86onvZ0IaJ/builds/jHg77nyLY0TK0S6i0/openapi.json