# Google Flights Scraper & Price Monitor: Fare Alerts, Calendar (`s_actors/google-flights-scraper`) Actor

Scrape Google Flights for many routes and dates in one run. All flights with prices, airlines, stops and CO2, a price calendar up to 11 months ahead, and price-drop alerts that report only fares that changed since the last run. One-way, round trip, multi-city.

- **URL**: https://apify.com/s\_actors/google-flights-scraper.md
- **Developed by:** [Superior Actors](https://apify.com/s_actors) (community)
- **Categories:** Travel, E-commerce, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 2 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

Pay per event

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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 Flights Scraper & Price Monitor

Scrape [Google Flights](https://www.google.com/travel/flights) for **many routes and dates in one run**: every flight with price, airlines, flight numbers, times, stops, layovers, aircraft and CO2. Get a **price calendar up to 11 months ahead** in seconds, and turn scheduled runs into **price-drop alerts** that return only the fares that changed.

Export results as **JSON, CSV, Excel or HTML**, or use it as a **Google Flights API**.

#### How it works

1. Enter routes like `JFK-LAX` or city codes like `NYC-LON` (all airports of a city)
2. Pick a departure date, or `+14 days` for scheduled runs
3. Choose **Flights** (all options per date) or **Price calendar** (cheapest fare per day)
4. Optional: switch on **Only report price changes** and schedule the task daily

No browser, no Google account, no API key.

#### Why this scraper

| | |
|---|---|
| 🔔 **Price-drop alerts** | Scheduled runs return only routes and dates whose price moved, with old price, new price and % change |
| 📆 **Price calendar** | Cheapest fare for every day up to 11 months ahead, one-way or round trip, in one run |
| ✈️ **Many routes and dates** | Any number of routes × up to 365 departure dates per run |
| 📊 **Price insights** | Google's verdict (low / typical / high), typical price range and 60-day price history |
| 🏙️ **City codes** | `LON`, `NYC`, `PAR`, `TYO`, `MIL` search all airports of the city |
| 🧳 **All trip types** | One-way, round trip with all return flights, multi-city; cabin class, passengers, stops and airline filters |
| 🛒 **Where to book** | Every seller (airline and travel agencies) with price, fare and booking link, cheapest seller first |
| 🔁 **Made for monitoring** | Relative dates like `+14 days` keep scheduled runs moving forward |

#### Use cases

- **Fare alerts**: get notified when a route drops to your target price
- **Travel agencies and startups**: live fares for your customers' routes
- **Revenue and market analysis**: airline prices by route, date and season
- **Cheapest travel dates**: find the best day to fly for any route
- **AI agents**: give your assistant live flight prices through MCP

#### Output

**Flights mode**: one row per flight.

| Field | Description |
|---|---|
| `route`, `departureDate`, `returnDate`, `tripType` | The search, e.g. `JFK-LAX`, `2026-11-12`, `one_way` |
| `price`, `currency` | Price for all passengers (whole trip for round trips) |
| `airlines`, `flightNumbers` | e.g. `["Finnair"]`, `["AY 1074", "AY 1337"]` |
| `departure`, `arrival` | Local times, e.g. `2026-11-12T13:45` |
| `durationMinutes`, `stops`, `layovers` | Total time, number of stops, layover airport and minutes |
| `segments` | Each flight: number, airline, operator, airports, times, aircraft, legroom, codeshares |
| `co2Grams`, `co2TypicalGrams`, `co2DiffPercent` | Emissions vs. typical for the route |
| `isBest`, `position` | Google's "best flights" and the order in results |
| `lowestPrice`, `priceLevel`, `typicalPriceLow`, `typicalPriceHigh` | Route summary and Google's price verdict |
| `priceHistory` | Lowest price over the last 60 days (first row of each search) |
| `googleFlightsUrl` | The same search on Google Flights |

With **Return flights** on (round trips), the top flights also have `returnFlights`: every return flight with the total round-trip price.

With **Where to book** on, the top flights also have:

| Field | Description |
|---|---|
| `bookingOptions` | Each seller: `seller`, `isAirline`, `price`, `fareName` (e.g. `Delta Main Basic`), `website`, `bookingUrl` |
| `cheapestSeller`, `cheapestSellerPrice`, `sellersCount` | The cheapest place to buy and how many sellers there are |
| `bookingReturnFlight` | Round trips: the return flight the booking prices are for |

Example, New York to London round trip:

| Seller | Price |
|---|---|
| Gotogate | $419 |
| TAP Air Portugal (airline) | $428 |
| ScholarTrip | $428 |
| FlightHub | $584 |

**Price calendar mode**: one row per departure day with `price`, `returnDate`, `weekday`, `isCheapest`.

**Price monitoring**: one row per route and date whose price changed:

| Field | Description |
|---|---|
| `direction` | `down`, `up`, `new` (first run), `below_target` (just reached your target), `unavailable`, `available_again` |
| `price`, `previousPrice` | Lowest fare now and when it was last reported |
| `change`, `changePercent` | Difference, e.g. `-67.2`, `-16.7` |
| `belowTarget` | The fare is at or below your target price |
| `cheapestFlight` | Airlines, flight numbers, times and stops of the cheapest option |
| `previousCheckedAt` | When the previous price was reported |

Example of price alerts:

| Route | Departure | Change | Now | Before | % |
|---|---|---|---|---|---|
| RIX-BCN | 2026-10-17 | down | €336 | €403 | -16.7 |
| NYC-PAR | 2026-10-24 | up | $512 | $455 | +12.5 |

#### Pricing

| Event | Price |
|---|---|
| Run start | $0.005 per run |
| Route and date searched | $0.002 (all flights for that route and date, with price insights) |
| Calendar day | $0.0001 per day with a price |
| Return flights (optional) | $0.002 per outbound flight |
| Where to book (optional) | $0.003 per flight |

**1 route, 1 date = $0.007** | **10 routes × 30 dates = $0.61** | **Price calendar, 3 routes × 11 months = $0.10**

Price monitoring costs the same as a normal search: you pay per route and date checked, and get only the changes. Set a maximum cost per run in the run options and the scraper stops there.

#### Input options

| Field | Default | Description |
|---|---|---|
| `routes` | | `JFK-LAX`, `NYC-LON` (airport or city codes) |
| `mode` | flights | `flights` or `calendar` |
| `departureDate` | in 14 days | `2026-11-12` or relative, e.g. `+14 days`, `tomorrow` |
| `returnAfterDays` | 0 | 0 = one-way, 7 = round trip returning after 7 days |
| `numberOfDates`, `dateStepDays` | 1, 1 | Flights mode: how many departure dates and days between them |
| `calendarDays` | 90 | Calendar mode: days to cover (up to 328) |
| `onlyPriceChanges` | false | Return only price changes since the last run |
| `minChangePercent` | 5 | Smallest change to report |
| `targetPrice` | | Report as soon as a fare drops to or below this price |
| `monitorName` | default | Separate memory for each monitoring task |
| `adults`, `children` | 1, 0 | Passengers |
| `cabinClass` | economy | `economy`, `premium_economy`, `business`, `first` |
| `maxStops` | any | `any`, `nonstop`, `max1`, `max2` |
| `airlines` | | e.g. `LH`, `BA`, or `STAR_ALLIANCE`, `ONEWORLD`, `SKYTEAM` |
| `maxPrice`, `maxFlightsPerSearch` | | Price cap; flights per search (0 = all) |
| `includePriceInsights` | true | Price verdict, typical range, 60-day history (free, skipped if Google limits the run) |
| `includeReturnFlights` | false | Round trips: all return flights for the top flights |
| `includeBookingOptions` | false | Sellers, fares, prices and booking links for the top flights |
| `detailsForTopFlights` | 3 | How many flights per search get these details |
| `multiCityTrips` | | `RIX-LHR 2026-11-12, LHR-CDG 2026-11-15, CDG-RIX 2026-11-19` |
| `currency`, `language`, `country` | USD, en, us | Prices can differ by country |

City codes: `LON`, `NYC`, `PAR`, `TYO`, `MIL`, `ROM`, `CHI`, `WAS`, `STO`, `SAO`, `SEL`, `OSA`, `BUE`, `YTO`, `BJS`, `RIO`, `MOW`, `YMQ`, `BUH`, `JKT`.

#### Daily fare alerts

1. Add your routes, set **Departure date** to `+7 days` and **Number of departure dates** to `30`
2. Switch on **Only report price changes**, set **Minimum change** to `5` and optionally a **Target price**
3. **Save as a new task** and **Schedule** it every morning
4. In **Integrations**, send new rows to email, Slack, Google Sheets, Make, Zapier or n8n

The first run saves the current prices and returns them all marked `new`. Every later run compares with the previous run and returns only the fares that moved by at least **Minimum change**, reached your **Target price**, sold out or came back. An empty result means no price changed.

Use a different **Monitor name** for each task, otherwise two tasks overwrite each other's memory. You pay for the routes and dates checked, not for the changes found.

#### Send prices to Google Sheets

Keep one sheet with the latest fare for every route and date, updated in place:

1. Share your Google Sheet with the e-mail shown on [Google Sheets Import & Export](https://apify.com/s_actors/google-sheets-import-export) as Editor
2. In this scraper's task: **Integrations** → **Connect Actor or Task** → choose **Google Sheets Import & Export**
3. Use this input (calendar mode):

```json
{
  "spreadsheetId": "https://docs.google.com/spreadsheets/d/YOUR_SHEET_ID/edit",
  "mode": "update",
  "sheetName": "Fares",
  "datasetId": "{{resource.defaultDatasetId}}",
  "deduplicateByField": "route,departureDate",
  "columnsOrder": ["route", "departureDate", "weekday", "price", "isCheapest"],
  "addTimestamp": true
}
```

#### Use with AI agents (MCP)

Connect the scraper to Claude, ChatGPT, Cursor or any MCP client:

```
https://mcp.apify.com?tools=s_actors/google-flights-scraper
```

Example prompts:

> "Find the cheapest day to fly from New York to London in December, round trip for a week."

> "Show nonstop flights from JFK to LAX next Friday under $250."

#### Examples

**All flights for the next 7 days**

```json
{ "routes": ["JFK-LAX", "SFO-SEA"], "departureDate": "tomorrow", "numberOfDates": 7 }
```

**Cheapest week-long round trip, 11 months ahead**

```json
{ "routes": ["NYC-LON"], "mode": "calendar", "departureDate": "tomorrow", "calendarDays": 320, "returnAfterDays": 7 }
```

**Daily price-drop alerts**

```json
{ "routes": ["RIX-BCN", "NYC-PAR"], "departureDate": "+14 days", "numberOfDates": 30, "onlyPriceChanges": true, "minChangePercent": 5, "targetPrice": 300, "monitorName": "autumn-trips" }
```

#### Ready-made tasks

Open one, change the inputs, and run or schedule it:

- [Flight Price Drop Alerts from Google Flights](https://apify.com/s_actors/google-flights-scraper/examples/flight-price-drop-alerts)
- [Cheapest Days to Fly: Google Flights Price Calendar](https://apify.com/s_actors/google-flights-scraper/examples/cheapest-days-to-fly-calendar)
- [All Google Flights for a Route: Prices, Airlines, Stops](https://apify.com/s_actors/google-flights-scraper/examples/all-flights-for-a-route)
- [Business Class Fare Tracker on Google Flights](https://apify.com/s_actors/google-flights-scraper/examples/business-class-fare-tracker)
- [Flight Price Alert: Tell Me When a Fare Drops Below $X](https://apify.com/s_actors/google-flights-scraper/examples/flight-target-price-alert)
- [Same Flight, Different Price: Airline vs Expedia, Kiwi](https://apify.com/s_actors/google-flights-scraper/examples/flight-booking-options-comparison)
- [Is It a Good Flight Price? Google Price Insights and History](https://apify.com/s_actors/google-flights-scraper/examples/flight-price-history-insights)
- [Multi-City Trip Price Tracker: Alerts for Open-Jaw Fares](https://apify.com/s_actors/google-flights-scraper/examples/multi-city-trip-price-tracker)
- [Nonstop Flight Price Alerts: Direct Flights Only](https://apify.com/s_actors/google-flights-scraper/examples/nonstop-flight-price-alerts)
- [Family Vacation Flight Tracker: 2 Adults, 2 Children](https://apify.com/s_actors/google-flights-scraper/examples/family-vacation-flight-tracker)

#### FAQ

**Is there an official Google Flights API?** No. This scraper is the easiest way to get Google Flights data via API.

**How do round trips work?** Google prices round trips as a whole: each row is an outbound flight with the total round-trip price, like the first step on Google Flights. Switch on **Return flights** to get the matching return flights too.

**Do booking links expire?** Yes, they are Google's redirect links and work for a limited time, like on Google Flights. Use them soon after the run.

**How far ahead can I search?** About 11 months (328 days), which is as far as Google sells.

**Is it legal?** It collects only publicly visible data, without login and without personal data. Check that your use complies with the laws and terms that apply to you.

#### Issues & feedback

Something missing or not working? Open an issue on the **Issues** tab with your run link. We respond quickly.

# Actor input Schema

## `routes` (type: `array`):

One route per line: origin-destination airport codes like "JFK-LAX". City codes search all airports of a city: LON, NYC, PAR, TYO, MIL, ROM, CHI, WAS and more, e.g. "NYC-LON".

## `mode` (type: `string`):

Flights: every flight for each route and date. Price calendar: the cheapest fare for every day, up to 11 months ahead, in one run.

## `departureDate` (type: `string`):

First departure date. Pick a fixed date, or a relative one like "+14 days" so scheduled runs always look ahead from the day they run (recommended for monitoring). Leave empty for 14 days from today. In calendar mode the calendar starts here.

## `returnAfterDays` (type: `integer`):

0 = one-way. 7 = round trip returning 7 days after departure; prices are for the whole round trip.

## `numberOfDates` (type: `integer`):

Flights mode: search many dates in one run. 1 = only the date above, 7 = the next 7 dates.

## `dateStepDays` (type: `integer`):

Flights mode, with several dates: 1 = every day, 7 = same weekday every week.

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

Price calendar mode: how many departure days to cover. Google sells about 11 months ahead (max 328; for round trips the return date must fit too).

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

For scheduled runs. The first run saves the lowest price of every route and date; later runs return only routes and dates whose lowest price moved by at least the percentage below, with the old price, the new price and the change. No noise, just the alerts.

## `minChangePercent` (type: `number`):

Report a change only if the lowest fare moved at least this much since it was last reported. 0 = any change.

## `targetPrice` (type: `integer`):

Optional. Report a route and date as soon as its lowest fare drops to or below this price, even if the change is smaller than the minimum above.

## `monitorName` (type: `string`):

Prices are remembered under this name. Use a different name for each monitoring task.

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

Prices are for all passengers together.

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

Number of children.

## `cabinClass` (type: `string`):

Travel class.

## `maxStops` (type: `string`):

Maximum number of stops.

## `airlines` (type: `array`):

Only these airlines: two-letter codes like "LH", "BA", or alliances STAR\_ALLIANCE, ONEWORLD, SKYTEAM. Empty = all.

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

Skip flights more expensive than this, in the selected currency.

## `maxFlightsPerSearch` (type: `integer`):

0 = all flights Google shows (usually 15-40). Best flights first, then by price.

## `includePriceInsights` (type: `boolean`):

Flights mode: adds Google's verdict (low / typical / high), the typical price range and the lowest-price history of the last 60 days.

## `includeReturnFlights` (type: `boolean`):

Round trips: for each of the top flights below, also get every return flight you can combine it with, priced for the whole trip. Charged per outbound flight.

## `includeBookingOptions` (type: `boolean`):

Every seller for the flight: the airline and online travel agencies (Expedia, Gotogate, Kiwi...), each with its price, fare (e.g. Basic, Main, Extra) and booking link. Shows the cheapest seller. Round trips use the cheapest return flight. Charged per flight.

## `detailsForTopFlights` (type: `integer`):

How many flights of each search get return flights and booking options (best flights first).

## `multiCityTrips` (type: `array`):

Flights mode, optional. One trip per line, legs separated by commas: "RIX-LHR 2026-11-12, LHR-CDG 2026-11-15, CDG-RIX 2026-11-19". Relative dates like "+30 days" work too. Returns options for the first leg with the total price of the whole trip.

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

ISO code, e.g. USD, EUR, GBP.

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

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

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

Google country (gl), e.g. us, gb, de. Prices can differ by country.

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

How many requests run at the same time. Keep the default unless you know you need more.

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

Requests go direct first. If Google refuses them, the scraper retries through this proxy (datacenter works best for Google Flights).

## Actor input object example

```json
{
  "routes": [
    "JFK-LAX",
    "NYC-LON"
  ],
  "mode": "flights",
  "returnAfterDays": 0,
  "numberOfDates": 1,
  "dateStepDays": 1,
  "calendarDays": 90,
  "onlyPriceChanges": false,
  "minChangePercent": 5,
  "monitorName": "default",
  "adults": 1,
  "children": 0,
  "cabinClass": "economy",
  "maxStops": "any",
  "maxFlightsPerSearch": 0,
  "includePriceInsights": true,
  "includeReturnFlights": false,
  "includeBookingOptions": false,
  "detailsForTopFlights": 3,
  "currency": "USD",
  "language": "en",
  "country": "us",
  "maxConcurrency": 5,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `overview` (type: `string`):

One row per flight: price, airlines, times, duration, stops.

## `calendar` (type: `string`):

Cheapest fare for every departure day (calendar mode).

## `changes` (type: `string`):

Only routes and dates whose price changed (price monitoring).

## `all` (type: `string`):

Every field, including segments, layovers, CO2 and price history.

# 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 = {
    "routes": [
        "JFK-LAX",
        "NYC-LON"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("s_actors/google-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 = {
    "routes": [
        "JFK-LAX",
        "NYC-LON",
    ],
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("s_actors/google-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 '{
  "routes": [
    "JFK-LAX",
    "NYC-LON"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call s_actors/google-flights-scraper --silent --output-dataset

```

## MCP server setup

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