# Google Flights Scraper API ✈️ (flight prices, cheapest dates) (`tagadanar/google-flights-scraper`) Actor

Google Flights fares for any route and date: price, airlines, flight numbers, local times, stops, layovers, aircraft, CO2 and Google's price insight, plus a cheapest-date calendar. Round trips, batch routes, any currency. No API key.

- **URL**: https://apify.com/tagadanar/google-flights-scraper.md
- **Developed by:** [Tagada Data](https://apify.com/tagadanar) (community)
- **Categories:** Travel, Agents, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.14 / 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 API ✈️ (flight prices, cheapest dates)

Get Google Flights prices for any route and date as clean rows: price, airlines, flight numbers, local departure and arrival times, duration, stops, layover airports and waits, aircraft, legroom, CO2 and Google's own price insight (low, typical or high, with the typical price range). Switch on the cheapest-date calendar to get the lowest fare for every departure date over the next weeks. One-way and round trips, several airports at once, batches of routes, any currency and point of sale. No API key, no login, no browser.

It costs **$0.20 per 1,000 flights** (plus $0.001 per run), and you only pay for rows delivered.

### What you get

One row per itinerary, in Google's order (or cheapest / shortest / earliest first):

| Field | Example |
|---|---|
| `price`, `currency`, `priceType` | 204, USD, one_way_total_all_passengers |
| `airlines`, `airlineCodes`, `flightNumbers` | \["JetBlue"], \["B6"], \["B6 223"] |
| `departureAirport`, `departureTime` | JFK, 2026-11-18T09:15 (local time) |
| `arrivalAirport`, `arrivalTime` | LAX, 2026-11-18T12:33 (local time) |
| `durationMinutes`, `duration` | 378, "6 hr 18 min" |
| `stops`, `layoverAirports`, `layovers` | 1, \["FLL"], \[{"airport":"FLL","city":"Fort Lauderdale","durationMinutes":113,"overnight":false,"changeOfAirport":false}] |
| `legs` | every flight: number, airline, airports, times, aircraft, legroom, cabin, codeshare numbers (`alsoSoldAs`) |
| `aircraft`, `cabinClasses`, `selfTransfer` | \["Airbus A320"], \["economy"], false |
| `emissionsKg`, `typicalEmissionsKg`, `emissionsVsTypicalPercent` | 411, 343, 20 |
| `isBest`, `isCheapest`, `rank` | true when the flight is in Google's "Best" list, true for the lowest fare, Google's position |
| `priceLevel`, `typicalPriceLow`, `typicalPriceHigh`, `lowestPriceForSearch` | typical, 105, 275, 174 |
| `googleFlightsUrl` | opens the itinerary on Google Flights with its booking options (sellers and fares) |
| `searchUrl`, `country`, `scrapedAt` | the search on Google Flights, point of sale, time of capture |

Round trips: the outbound rows carry the cheapest round-trip total Google shows for each outbound. Set **Return flights for the top N outbound flights** and you also get `return_flight` rows: the return options that go with each of your top outbounds, each with its exact round-trip price and a booking link for that exact pair (`outboundFlightNumbers` says which outbound it belongs to).

Cheapest-date calendar (`cheapestDatesDays`): one `cheapest_date` row per departure date with `price`, `weekday`, the airline, flight numbers, stops and duration of that day's cheapest itinerary, `flightsListed`, the price level and `isCheapestDate` on the best day. Round trips keep the same trip length for every date.

Each run also saves a `PRICE_INSIGHTS` record in the key-value store: per search, the price level, typical range and Google's 60-day price history for the searched date (the chart behind "View price history").

### Who uses it

- Fare trackers and deal newsletters: schedule a run with a relative date (`+30`) and alert when `priceLevel` turns `low` or the price drops under your threshold.
- Travel agencies and travel startups: compare carriers, schedules and fares on the routes you sell, with the Google Flights link for each option.
- Corporate travel and procurement: check what a route really costs on the dates people travel, nonstop or with one stop, in your company's currency.
- Analysts and researchers: route coverage, airline competition, CO2 by itinerary, price levels across dates and markets.
- AI agents and apps: call it through the Apify API or MCP and get flat JSON back.

### How to use it

1. Enter the origin and destination as IATA codes (JFK, LHR, CDG) or city codes (NYC, LON, PAR). Several airports work too: `JFK,EWR,LGA`.
2. Enter a departure date (2026-12-20) or a relative one (`+30` means 30 days after the run starts). Add a return date for a round trip (a date, or `+7` for seven days after departure).
3. Pick passengers, cabin, stops and airlines if you want, then click Start.

### Input examples

One-way, prefill style (always 30 days ahead, handy for a daily schedule):

```json
{ "origin": "JFK", "destination": "LAX", "departureDate": "+30" }
```

Round trip in business class for two, nonstop only, cheapest first, with the return options of the top 3 outbounds:

```json
{
  "origin": "SFO",
  "destination": "NRT",
  "departureDate": "2026-12-10",
  "returnDate": "2026-12-20",
  "adults": 2,
  "cabinClass": "business",
  "maxStops": "0",
  "sortBy": "price",
  "returnFlightsForTop": 3
}
```

Cheapest day to fly over the next 60 days, one week round trip, in euros from France:

```json
{
  "origin": "PAR",
  "destination": "LIS",
  "departureDate": "+7",
  "returnDate": "+7",
  "cheapestDatesDays": 60,
  "currency": "EUR",
  "country": "FR"
}
```

Many routes in one run, only Star Alliance carriers:

```json
{
  "routes": [
    { "origin": "LHR", "destination": "JFK", "departureDate": "2026-12-05" },
    { "origin": "FRA", "destination": "ORD", "departureDate": "2026-12-05", "returnDate": "2026-12-12" },
    "MUC-SFO 2026-12-06"
  ],
  "airlines": ["STAR_ALLIANCE"],
  "maxResultsPerSearch": 10
}
```

### Pricing

| Event | Price | Per 1,000 |
|---|---|---|
| Flight row (outbound or return itinerary) | $0.0002 | $0.20 |
| Calendar date priced (`cheapestDatesDays`) | $0.001 | $1.00 |
| Run start, once per run | $0.001 | |

Bronze, Silver and Gold plans pay less per row (down to $0.14 per 1,000 flights on Gold). A route Google has no flights for costs nothing beyond the run start, and so do calendar dates with no flights. Compute and proxies are included.

A one-way search returns up to about 30 flights, so a typical search costs under a cent. A 60-day calendar costs $0.06.

### FAQ

**Is there an official Google Flights API?** No. Google closed its QPX Express flight API in 2018. This actor reads the public Google Flights results page, the same flights and prices you see on the site.

**How many flights does a search return?** Google Flights lists up to about 30 itineraries per search page (fewer on small routes), split into "Best" flights and the rest. That is the list this actor returns. To go wider, search several dates, airports or stop filters in one run with `routes`.

**Are prices per person?** No, every price is the total for all the passengers you entered, as on Google Flights. `priceType` says whether it is a one-way or a round-trip total.

**Which currency and country are used?** The ones you set (USD and United States by default). Google prices the search for that point of sale and the currency is recorded on every row. Fares can differ between countries.

**Can I get the sellers (airline vs online travel agencies) and their fares?** `googleFlightsUrl` opens Google's booking page for that itinerary, which lists every seller and fare. Google loads that seller list only inside a real browser session, so the seller names are not in the dataset.

**Does it do multi-city trips?** Not yet. Google renders multi-city results only inside a real browser session. Search each leg as a one-way trip in the same run with `routes`.

**What is the cheapest-date calendar?** For each departure date in the window you choose, the actor runs a Google Flights search and keeps the cheapest fare of the day. It is the date grid you know from Google Flights, as rows you can sort and chart.

**How far ahead can I search?** Google Flights sells about 11 months ahead. Dates beyond that, and dates in the past, are skipped and the run status says so.

**Why did a search return nothing?** Either Google lists no flights for that route, date and filter combination (the status names the search), or the airport code was not recognised. Use IATA codes such as JFK or city codes such as NYC.

**Can I schedule it as a price tracker?** Yes. Use a relative date like `+30` so the schedule never goes stale, and read `price`, `priceLevel` and `PRICE_INSIGHTS` after each run.

### More travel data

- [Google Hotels Scraper](https://apify.com/tagadanar/google-hotels-scraper): nightly hotel rates for your dates, rating, stars and amenities.
- [Airbnb Scraper](https://apify.com/tagadanar/airbnb-scraper): Airbnb listings with prices and availability.

Keywords: Google Flights scraper, Google Flights API, flight price scraper, airfare data, cheap flights finder, flight price tracker, cheapest dates to fly, round trip fares, flight schedules, layovers, CO2 emissions per flight.

# Changelog

This Actor's version history is a separate document: https://apify.com/tagadanar/google-flights-scraper/changelog.md

# Actor input Schema

## `origin` (type: `string`):

IATA code of the departure airport (JFK, LHR, CDG) or of a whole city (NYC, LON, PAR). Several airports are fine, separated by commas: JFK,EWR,LGA.

## `destination` (type: `string`):

IATA code of the arrival airport or city, e.g. LAX, MIA, TYO. Several codes separated by commas work too.

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

A date like 2026-12-20, or +30 for "30 days after the day the run starts" (handy for schedules that always look a month ahead). Empty = 30 days from today.

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

Leave empty for a one-way trip. A date like 2026-12-27, or +7 for "7 days after the departure date".

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

Search many routes or dates in one run. Each item is {"origin": "JFK", "destination": "LAX", "departureDate": "2026-12-20", "returnDate": "2026-12-27"} or a line like "JFK-LAX 2026-12-20 2026-12-27". Passengers, cabin and filters below apply to every route. Up to 500 routes per run.

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

Travellers aged 12 and over. Prices are the total for all passengers.

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

Children aged 2 to 11.

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

Infants under 2 with their own seat (priced close to an adult fare).

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

Infants under 2 travelling on an adult's lap (one per adult).

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

Cabin to search. Rows also show the cabin of each flight, since some itineraries mix cabins.

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

Limit the number of stops. Google applies it, so the list you get is the full list for that filter.

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

Two-letter airline codes (AA, DL, BA) or an alliance: STAR_ALLIANCE, SKYTEAM, ONEWORLD. Empty = all airlines.

## `excludeAirlines` (type: `array`):

Airline codes or alliances to leave out, e.g. NK, F9.

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

How the rows of each search are ordered before the limit below is applied. Every row keeps Google's own rank and its "best" flag.

## `maxResultsPerSearch` (type: `integer`):

Google Flights lists up to about 30 itineraries per search (fewer on small routes). Lower this to keep only the top ones in the order chosen above.

## `returnFlightsForTop` (type: `integer`):

Round trips only. Google prices a round trip in two steps: first the outbound flights (each with the cheapest round-trip total), then the return flights that go with the outbound you pick. Set N to also get the return options of the top N outbound flights, each with its exact round-trip price. 0 = outbound list only.

## `cheapestDatesDays` (type: `integer`):

0 = normal flight search. Set e.g. 30 to get one row per departure date, starting at the departure date, with the cheapest fare of that day (round trips keep the same trip length). Calendar runs return date rows instead of the flight list.

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

Currency of every price. It is recorded on each row.

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

The country Google Flights prices the search for. Fares and the sellers shown can differ by country.

## Actor input object example

```json
{
  "origin": "JFK",
  "destination": "LAX",
  "departureDate": "+30",
  "adults": 1,
  "children": 0,
  "infantsInSeat": 0,
  "infantsOnLap": 0,
  "cabinClass": "economy",
  "maxStops": "any",
  "sortBy": "best",
  "maxResultsPerSearch": 30,
  "returnFlightsForTop": 0,
  "cheapestDatesDays": 0,
  "currency": "USD",
  "country": "US"
}
```

# Actor output Schema

## `results` (type: `string`):

One item per itinerary (or per date in calendar mode) in the default dataset.

## `insights` (type: `string`):

Key-value record PRICE_INSIGHTS: price level, typical range and 60-day price history for each search.

# 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 = {
    "origin": "JFK",
    "destination": "LAX",
    "departureDate": "+30"
};

// Run the Actor and wait for it to finish
const run = await client.actor("tagadanar/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 = {
    "origin": "JFK",
    "destination": "LAX",
    "departureDate": "+30",
}

# Run the Actor and wait for it to finish
run = client.actor("tagadanar/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 '{
  "origin": "JFK",
  "destination": "LAX",
  "departureDate": "+30"
}' |
apify call tagadanar/google-flights-scraper --silent --output-dataset

```

## MCP server setup

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