# Google Flights Scraper: Prices, Cheapest Days & Insights (`kuezi/google-flights-scraper`) Actor

Scrape Google Flights for any route and dates: prices, airlines, flight numbers, times, stops, layovers, aircraft, CO2 and Google's price insights (low/typical/high + price history). Scan a date range to find the cheapest day.

- **URL**: https://apify.com/kuezi/google-flights-scraper.md
- **Developed by:** [Ishema Hugues](https://apify.com/kuezi) (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.40 / 1,000 flights

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 Flights Scraper: prices, cheapest days & price insights

Scrape **Google Flights** for any route, dates, passengers and cabin class. One-way and round trip are both supported. You get:

- price, airlines and flight numbers
- departure and arrival times, duration, stops and layovers
- aircraft, legroom and CO₂ emissions
- **Google's own price insights**: whether today's price is *low, typical or high*, the typical price range, and about 60 days of price history

Turn on **flexible dates** and the Actor searches every departure day in a range, then tells you the **cheapest day to fly** for each route.

### Why this Google Flights scraper?

- **Find the cheapest day.** Scan up to 90 departure days per route. `SUMMARY` reports the cheapest price and date for each route.
- **Price insights included.** Every row carries Google's `priceLevel` (low / typical / high) and the typical price range. Full price history is in `SUMMARY`.
- **Complete itineraries.** Every segment comes with flight number, aircraft, legroom and emissions. Every layover comes with airport and duration.
- **Reliable.** Plain HTTP and no browser. When Google returns an empty or blocked page, the Actor retries on a fresh residential IP.
- **Fair billing.** You pay per search and per flight saved. Empty searches, failures, and flights removed by your filters are free.

### Use cases

- **Fare monitoring and alerts:** schedule a daily run on your routes and act when `priceLevel` turns `low`.
- **Travel agencies & corporate travel:** compare carriers, stops and total trip prices for clients in any currency.
- **Travel content & deal sites:** find the cheapest days and the routes that are currently cheap.
- **Airline and market research:** see who flies a route, their schedules, aircraft, emissions and price positioning.
- **AI travel assistants:** give an agent real flight options through the Apify API or MCP.

### Input

```json
{
  "routes": ["JFK-LAX", "LHR-JFK 2026-12-01 2026-12-08", "KGL-NBO"],
  "departureDate": "2026-11-12",
  "returnDate": "",
  "scanDepartureUntil": "2026-11-19",
  "adults": 1,
  "cabinClass": "economy",
  "maxStops": "any",
  "currency": "USD",
  "maxFlightsPerSearch": 20
}
```

- **Routes** use IATA airport codes. To give a route its own dates, add one date for a one-way trip or two dates for a round trip. Routes without dates use `departureDate` / `returnDate`.
- **Round trips:** the price shown is the total for the whole trip. Each row describes the outbound itinerary.
- **Passengers:** prices are totals for all passengers.
- **Filters:** `maxStops` is applied by Google. `maxPrice` and `airlines` are applied before saving, so you don't pay for flights you filtered out.

### Output

One record per itinerary. The example below is a real result from 2 Oct 2026, shortened:

```json
{
  "route": "JFK-LAX",
  "tripType": "one-way",
  "searchDepartureDate": "2026-11-12",
  "rank": 1,
  "isBest": true,
  "price": 204,
  "currency": "USD",
  "isCheapest": true,
  "airlines": ["Delta"],
  "flightNumbers": ["DL 1788"],
  "from": "JFK",
  "to": "LAX",
  "departure": "2026-11-12T12:00",
  "arrival": "2026-11-12T15:08",
  "durationMinutes": 368,
  "stops": 0,
  "layovers": [],
  "segments": [{ "from": "JFK", "to": "LAX", "flightNumber": "DL 1788", "aircraft": "Airbus A330", "legroom": "31 inches", "durationMinutes": 368 }],
  "emissionsGrams": 261000,
  "typicalEmissionsGrams": 346000,
  "emissionsVsTypicalPct": -25,
  "priceLevel": "typical",
  "typicalPriceLow": 144,
  "typicalPriceHigh": 240,
  "cabinClass": "economy",
  "passengers": 1,
  "googleFlightsUrl": "https://www.google.com/travel/flights/search?tfs=…"
}
```

Times are local airport times. The key-value store holds:

- `SUMMARY`: the cheapest day per route, then for each search its cheapest price, Google's price level, the typical range and price history
- `FAILED`: anything that failed after all retries. You are not charged for it.

### Pricing

You pay a small fee per route-and-date search that returns flights, plus a fee per saved flight. Current prices are on the **Pricing** tab. Searches where Google has no flights, failed searches, and flights removed by your filters are never charged. To cap your spend, set *Max cost per run* in the run options.

### FAQ

**Is it legal to scrape Google Flights?** The Actor reads publicly available flight listings, needs no login and collects no personal data. Use the data in line with the rules that apply to you.

**Are these bookable prices?** They are the prices Google Flights shows for your search at run time. Fares change constantly, and the final price is set by the airline or agency at booking.

**Why is the return flight not listed for round trips?** Google prices the round trip on the outbound selection screen. This version returns those outbound options with the total round-trip price. Return-flight details are on the roadmap.

**Some routes return nothing.** Google sometimes has no fares for a specific combination, such as some passenger mixes on smaller routes. Those searches are free and are listed in `SUMMARY` with 0 flights.

### More Google data tools from the same developer

- 📈 [Google Trends Scraper](https://apify.com/kuezi/google-trends-scraper): interest over time, regions, rising and breakout queries, unlimited keyword comparison, Trending Now.
- 🏨 [Google Hotels Scraper](https://apify.com/kuezi/google-hotels-scraper): nightly and total prices for your dates, every booking site's price, ratings and contacts.

***

*Independent tool, not affiliated with or endorsed by Google.*

# Actor input Schema

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

One route per line using IATA airport codes: "JFK-LAX". Add dates per route if you like: "JFK-LAX 2026-11-12" (one-way) or "JFK-LAX 2026-11-12 2026-11-19" (round trip). Routes without dates use the dates below.

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

YYYY-MM-DD. Leave empty for 21 days from today.

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

YYYY-MM-DD. Leave empty for one-way. Round-trip prices are the total for the whole trip.

## `scanDepartureUntil` (type: `string`):

Optional. Searches every day from the departure date up to this date (max 90 days) and reports the cheapest day per route in SUMMARY. Round trips keep the same trip length.

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

Passengers 12+.

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

Prices are totals for all passengers.

## `infantsInSeat` (type: `integer`):

Under 2, own seat.

## `infantsOnLap` (type: `integer`):

Under 2, on an adult's lap.

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

Seat class to price.

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

Filter applied by Google itself.

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

In the chosen currency, for all passengers. 0 = no limit. Filtered-out flights are not charged.

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

Optional IATA airline codes, e.g. DL, BA, KQ. Keeps itineraries with at least one segment on these airlines.

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

Google returns up to ~30-100 itineraries per route and date. Best and cheapest come first.

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

3-letter code: USD, EUR, GBP, INR, KES...

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

Interface language (hl), e.g. en, de, fr.

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

Point of sale (gl), e.g. us, gb, de. Prices can differ by country.

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

Searches run at the same time.

## `maxRetries` (type: `integer`):

Each retry uses a fresh IP.

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

Residential US proxies are the reliable default for Google.

## Actor input object example

```json
{
  "routes": [
    "JFK-LAX",
    "LHR-JFK"
  ],
  "adults": 1,
  "children": 0,
  "infantsInSeat": 0,
  "infantsOnLap": 0,
  "cabinClass": "economy",
  "maxStops": "any",
  "maxPrice": 0,
  "maxFlightsPerSearch": 20,
  "currency": "USD",
  "language": "en",
  "country": "us",
  "maxConcurrency": 3,
  "maxRetries": 5,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}
```

# Actor output Schema

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

One row per itinerary: route, dates, price, airlines, flight numbers, times, duration, stops, CO2, Google price level.

## `fullResults` (type: `string`):

Complete itineraries with every segment, layover, aircraft and legroom.

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

Cheapest price and date per route, per-search cheapest price, Google's typical price range 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",
        "LHR-JFK"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "US"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("kuezi/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",
        "LHR-JFK",
    ],
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "US",
    },
}

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

```

## MCP server setup

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