# Google Flights Scraper - Live Fares, Airlines & Layovers (`sian.agency/google-flights-scraper`) Actor

Scrape live Google Flights fares for any route: price, airline, departure and arrival times, duration, stops and full layover detail. 32 itineraries per search, from $1 per 1,000.

- **URL**: https://apify.com/sian.agency/google-flights-scraper.md
- **Developed by:** [SIÁN OÜ](https://apify.com/sian.agency) (community)
- **Categories:** Travel
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.88 / 1,000 flight searches

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?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## ✈️ Google Flights Scraper — Live Fares, Airlines & Layovers

[![Actor](https://img.shields.io/badge/Apify-Actor-brightgreen)](https://apify.com/sian.agency/google-flights-scraper)
[![Pricing](https://img.shields.io/badge/Pay%20per%20result-%240.001%20per%20itinerary-blue)](https://apify.com/sian.agency/google-flights-scraper)
[![Data](https://img.shields.io/badge/Up%20to%2032-itineraries%20per%20search-orange)](https://apify.com/sian.agency/google-flights-scraper)
[![Support](https://img.shields.io/badge/Support-Issues%20%26%20Reviews-purple)](https://apify.com/sian.agency/google-flights-scraper/issues)

### 🔎 What is the Google Flights Scraper — and when should you use it?

The **Google Flights Scraper** turns live Google Flights fares for a route and date, with airlines, times and layovers into clean, structured rows you can filter, export and feed straight into a spreadsheet, database or AI agent. No account, no portal API key, no browser automation to maintain.

**Use it when you need:** itinerary rows for one origin, destination and date. Each row carries the fare in US dollars, the operating airlines, departure and arrival times with their dates, total journey duration as both a label and minutes, and the stop count. Every connection adds a layover entry giving the airport, the city and the wait in minutes. Cabin class and a maximum-stops cap narrow the search at the source, and one search returns up to 32 itineraries.

**Use something else when:** you want accommodation, a different travel platform, or a booked-fare feed. Use [Agoda Flight Scraper](https://apify.com/sian.agency/agoda-flight-scraper?fpr=sian) for flight results from Agoda's own inventory, including bulk route lists. Use [Booking.com Scraper](https://apify.com/sian.agency/booking-com-scraper?fpr=sian) for Booking.com stays, reviews and forward availability. Use [Agoda Hotel Scraper](https://apify.com/sian.agency/agoda-hotel-scraper?fpr=sian) for Agoda listings with nightly price, guest score, rooms and reviews. Use [Tripadvisor Hotel Scraper](https://apify.com/sian.agency/tripadvisor-hotel-scraper?fpr=sian) for Tripadvisor hotels with price, rating, city ranking and reviews. This actor covers one-way Google Flights searches only. It cannot return round-trip or multi-city fares — Google composes those in the browser, so they are absent from the served page for any reader. It also does not book, and does not return seat maps or fare rules.

### 🤖 Use with AI agents

Already connected to the [Apify MCP server](https://mcp.apify.com)? Just ask for this Actor by name: sian.agency/google-flights-scraper

**Your agent can pay for its own runs.** This Actor is eligible for [agentic payments](https://docs.apify.com/platform/actors/publishing/monetize), so an agent can discover it, run it and settle the bill over [x402](https://www.x402.org/) (USDC on Base) or [Skyfire](https://www.skyfire.xyz/) — without an Apify account or API token of its own. Billing is the same either way: per successful row, never for errors.

Otherwise copy this prompt into Claude, ChatGPT, Cursor or any MCP-enabled assistant:

```text
I want live airfares for a route and date, with airlines, times, stops and layovers using the Apify Actor `sian.agency/google-flights-scraper`.

Use it when I need: itinerary rows for one origin, destination and date. Each row carries the fare in US dollars, the operating airlines, departure and arrival times with their dates, total journey duration as both a label and minutes, and the stop count. Every connection adds a layover entry giving the airport, the city and the wait in minutes. Cabin class and a maximum-stops cap narrow the search at the source, and one search returns up to 32 itineraries.

Don't use it when: you want accommodation, a different travel platform, or a booked-fare feed — use agoda-flight-scraper or booking-com-scraper or agoda-hotel-scraper or tripadvisor-hotel-scraper instead.

How to call it: set `origin` and `destination` to IATA codes and `departureDate` to YYYY-MM-DD
  origin / destination -> three-letter airport codes (LHR, JFK). City codes work too:
                          LON covers all five London airports, NYC covers JFK/LGA/EWR
  departureDate        -> YYYY-MM-DD, up to about eleven months ahead
  cabinClass           -> economy | premium | business | first (default economy)
  maxStops             -> any | 0 (nonstop only) | 1 | 2 (default any)
  adults               -> passenger count; fares are quoted per passenger
  maxResults           -> caps itineraries returned, and so caps what the run charges
One search returns up to 32 itineraries. For a return journey, run each direction
separately and treat the total as an upper bound — published round-trip fares are
often cheaper than two one-way tickets..

Start with this input:
{
  "origin": "LHR",
  "destination": "JFK",
  "departureDate": "2026-10-15",
  "cabinClass": "economy",
  "maxStops": "any",
  "adults": 1
}

Ask me which airports and which departure date, and whether I care about cabin class or nonstop only, then run the Actor and summarise the results as a table.
```

**Things you can ask your agent for:**

- *Price London to New York on 15 October and show me the cheapest nonstop next to the cheapest option overall.*
- *Run these twelve routes for the same date and tell me which ones have no nonstop service at all.*
- *Track this route daily for two weeks and flag any day the fare drops more than 15% below the running median.*
- *Compare business class against economy on this route and tell me what the premium actually buys in journey time.*

Machine-readable API, MCP config and OpenAPI definition for this Actor are published at [apify.com/sian.agency/google-flights-scraper.md](https://apify.com/sian.agency/google-flights-scraper.md).

### Overview

Pull live airfares for any route from Google Flights and get them back as clean, structured rows.

Give it an origin, a destination and a date. You get up to **32 itineraries**, each with the fare
in US dollars, the operating airlines, departure and arrival times, total journey duration, the
number of stops, and **full layover detail** — which airport, which city, and how long you wait
there — for every connection.

Fares move constantly. Every run fetches the route fresh and stamps each row with the moment it
was collected, so you always know how old a price is.

### Features

- **32 itineraries per search** — the cheapest, the fastest, and the whole spread in between, rather than the single result a search page leads with.
- **Full layover detail on every row** — airport, city and wait time per connection, included in the base result rather than sold as an add-on.
- **Real filters, not cosmetic ones** — cabin class (economy, premium economy, business, first) and a maximum-stops cap both narrow the result set at the source.
- **Worldwide coverage** — any airport pair Google Flights serves. City codes such as `LON` and `NYC` widen a search to every airport in that city.
- **Fares in one currency** — everything is quoted in USD so routes and runs are directly comparable.
- **You are billed per itinerary returned** — a search that finds nothing costs you nothing beyond the run start.
- **An HTML run report** with every row, what you paid, and a fix for anything that failed.

### Quick start

1. Open the Actor and press **Start** — the default input searches London Heathrow to New York JFK.
2. Swap `origin`, `destination` and `departureDate` for the route you care about.
3. Read the results in the **Output** tab, or export to JSON, CSV or Excel.

```json
{
  "origin": "LHR",
  "destination": "JFK",
  "departureDate": "2026-10-15",
  "cabinClass": "economy",
  "maxStops": "any",
  "adults": 1
}
```

### Getting started

Airports are given as three-letter IATA codes — `LHR`, `JFK`, `CDG`, `NRT`. City codes work too:
`LON` covers Heathrow, Gatwick, Stansted, Luton and City, and `NYC` covers JFK, LaGuardia and
Newark. Using a city code is usually the right move when you care about the price rather than the
terminal.

Dates are `YYYY-MM-DD`. Google publishes fares about eleven months ahead; ask for a date past that
window and you get no itineraries rather than an error.

To price a return journey, run each direction as its own search. Be aware that published
round-trip fares are frequently cheaper than two one-way tickets, so treat the sum of two legs as
an upper bound rather than the true return price.

### Input configuration

| Field | Type | Default | What it does |
|---|---|---|---|
| `origin` | string | `LHR` | IATA airport or city code to depart from |
| `destination` | string | `JFK` | IATA airport or city code to fly to |
| `departureDate` | string | `2026-10-15` | Departure date, `YYYY-MM-DD` |
| `cabinClass` | select | `economy` | `economy`, `premium`, `business` or `first` |
| `maxStops` | select | `any` | `any`, `0` (nonstop only), `1`, or `2` |
| `adults` | integer | `1` | Adult passengers; fares are quoted per passenger |
| `maxResults` | integer | `32` | Upper bound on itineraries returned, and so on what a run can charge |

### Output

One row per itinerary:

| Field | Type | Example |
|---|---|---|
| `priceUsd` | number | `463` |
| `currency` | string | `USD` |
| `airlines` | array | `["Brussels Airlines", "Lufthansa"]` |
| `stops` | integer | `1` |
| `stopsLabel` | string | `1 stop` |
| `originAirport` | string | `Heathrow Airport` |
| `destinationAirport` | string | `John F. Kennedy International Airport` |
| `departureTime` | string | `12:20 PM` |
| `departureDate` | string | `Thursday, October 15` |
| `arrivalTime` | string | `8:05 PM` |
| `arrivalDate` | string | `Thursday, October 15` |
| `durationLabel` | string | `12 hr 45 min` |
| `durationMinutes` | integer | `765` |
| `layovers` | array | `[{ "airport": "Vienna International Airport", "city": "Vienna", "duration": "1 hr 20 min", "durationMinutes": 80, "position": 1, "of": 1 }]` |
| `cabinClass` | string | `Economy` |
| `route` | string | `LHR → JFK` |
| `originCode` / `destinationCode` | string | `LHR` / `JFK` |
| `searchDate` | string | `2026-10-15` |
| `searchUrl` | string | the exact search this row came from |
| `scrapedAt` | string | ISO timestamp the fare was collected |

### Use cases

- **Fare tracking** — run a route on a schedule and keep every quoted fare. Because each row carries the airline, times and stop count next to the price, you can tell a genuinely cheaper fare from a worse itinerary that happens to cost less.
- **Airline competitive pricing** — see every carrier on a route for a date side by side, including the connections that undercut the nonstops.
- **Travel content and deal feeds** — power a deals site, newsletter or channel with current fares for the routes you cover.
- **Corporate travel benchmarking** — check what a city pair actually costs before approving a booking, and keep the evidence.
- **Route and market research** — measure how many carriers serve a pair, what the nonstop premium is, and what a connection saves.

### Integration examples

**JavaScript**

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: 'YOUR_APIFY_TOKEN' });

const run = await client.actor('sian.agency/google-flights-scraper').call({
    origin: 'LHR',
    destination: 'JFK',
    departureDate: '2026-10-15',
    cabinClass: 'economy',
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
const cheapest = items.sort((a, b) => a.priceUsd - b.priceUsd)[0];
console.log(`Cheapest: $${cheapest.priceUsd} with ${cheapest.airlines.join(' + ')}`);
```

**Python**

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")

run = client.actor("sian.agency/google-flights-scraper").call(run_input={
    "origin": "LHR",
    "destination": "JFK",
    "departureDate": "2026-10-15",
})

rows = list(client.dataset(run["defaultDatasetId"]).iterate_items())
nonstop = [r for r in rows if r["stops"] == 0]
print(f"{len(nonstop)} nonstop options, from ${min(r['priceUsd'] for r in nonstop)}")
```

**cURL**

```bash
curl -X POST "https://api.apify.com/v2/acts/sian.agency~google-flights-scraper/run-sync-get-dataset-items?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"origin":"LHR","destination":"JFK","departureDate":"2026-10-15"}'
```

**Automation workflows** — the Actor works as a step in n8n, Make or Zapier through Apify's
connectors. A common pattern is a daily schedule that runs a set of routes, appends the rows to a
sheet or database, and alerts you when a fare drops below a threshold you set.

### FAQ

**Does this return round-trip or multi-city fares?**
No. It searches one direction and one date at a time. Google composes round-trip and multi-city
prices in the browser rather than in the page it serves, so those fares are not present in the
response at all. Run each direction separately for a return journey, and treat the total as an
upper bound — published round-trip fares are often cheaper than two one-ways.

**How many itineraries does one search return?**
Up to 32. That is the source's own ceiling for a single search, not a limit we impose. Narrowing
by cabin class or stops returns fewer because fewer itineraries qualify.

**Are the prices live?**
Yes. Every run fetches the route at the moment you run it, and every row records when it was
collected. Airfares move constantly, so a fare read an hour ago may no longer be bookable.

**Can I book through this?**
No. It reports what Google Flights publicly displays for a search. Booking happens with the
airline or an agent.

**Which currency are fares in?**
US dollars, so routes and runs stay directly comparable.

**How far ahead can I search?**
Roughly eleven months, which is how far fares are published. A later date returns no itineraries
rather than an error.

**Why did my search return nothing?**
Usually there are genuinely no flights for that pair on that date. Try a nearby date, use a city
code such as `LON` or `NYC` instead of a single airport, or allow more stops.

### Troubleshooting

| What you see | What it means | What to do |
|---|---|---|
| No itineraries, run succeeded | No flights published for that route and date | Try a nearby date, a city code, or a higher `maxStops` |
| `Origin "..." is not a three-letter airport code` | The code was rejected before anything was charged | Use an IATA code such as `LHR`, not a city name |
| `Origin and destination are the same airport` | Both fields hold the same code | Set two different airports |
| `... is not in YYYY-MM-DD form` | Date format | Use `2026-10-15`, not `15/10/2026` |
| Fewer rows than expected on a free plan | Free Apify accounts are capped at 25 rows per run | Add credits or a payment method to lift the cap |
| `Flight search is temporarily unavailable` | The source was briefly unreachable; the run already retried | Re-run in a few minutes |

### Legal

This Actor collects only flight search results that Google Flights displays publicly. It does not
log in, does not bypass authentication, and does not collect personal data.

Google Flights is a trademark of Google LLC. This tool is not affiliated with, endorsed by or
sponsored by Google. You are responsible for ensuring your use of the data complies with
applicable law and the source's terms.

### Support

- 🐛 **Issues:** https://apify.com/sian.agency/google-flights-scraper/issues
- ⭐ **Reviews:** https://apify.com/sian.agency/google-flights-scraper/reviews
- 🌐 **More actors:** https://apify.com/sian.agency?fpr=sian
- 🚀 **New to Apify?** https://apify.com/pricing?fpr=sian

Related travel actors: [Booking.com Scraper](https://apify.com/sian.agency/booking-com-scraper),
[Airbnb Property Scraper](https://apify.com/sian.agency/airbnb-property-scraper),
[Tripadvisor Hotel Scraper](https://apify.com/sian.agency/tripadvisor-hotel-scraper),
[Agoda Hotel Scraper](https://apify.com/sian.agency/agoda-hotel-scraper),
[Agoda Flight Scraper](https://apify.com/sian.agency/agoda-flight-scraper).

### Keywords for LLM Discovery

google flights api, google flights scraper, flight price api, flight data api, flight search api,
airfare api, scrape flight prices, google flights data, cheap flights api, airline fare scraper,
flight fare tracking, airfare monitoring, flight price monitoring, route pricing data, air travel
data extraction, airline ticket prices api, flight itinerary scraper, layover data, nonstop flight
search, business class fare data, premium economy fares, one-way fare lookup, IATA route pricing,
travel deals data feed, fare comparison api, airline competitive pricing, corporate travel
benchmarking, flight duration data, connection time data, carrier route coverage, air fare
history, travel market research data, flight availability data, airfare trend tracking

# Actor input Schema

## `operation` (type: `string`):

One search returns up to 32 distinct itineraries for a route and date.

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

Three-letter IATA airport code to depart from, for example LHR, JFK or LAX. City codes such as NYC and LON also work and widen the search to every airport in that city.

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

Three-letter IATA airport code to fly to, for example JFK, CDG or NRT. City codes such as NYC and LON also work and widen the search to every airport in that city.

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

Departure date in YYYY-MM-DD form. Google publishes fares roughly eleven months ahead; a date beyond that window returns no itineraries.

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

Which cabin to price. The source returns a different, smaller itinerary set for the premium cabins, so this genuinely narrows results rather than only relabelling them.

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

Cap the number of connections. Nonstop-only is a real filter at the source and returns a genuinely smaller set, not a filtered copy of the same one.

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

Number of adult passengers to price. Fares are quoted per passenger, so this changes availability rather than multiplying the displayed price.

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

Upper bound on itineraries returned per route, and therefore on what a run can charge. A single search yields at most 32, so values above that simply return everything available.

## Actor input object example

```json
{
  "operation": "flightSearch",
  "origin": "LHR",
  "destination": "JFK",
  "departureDate": "2026-10-15",
  "cabinClass": "economy",
  "maxStops": "any",
  "adults": 1,
  "maxResults": 32
}
```

# Actor output Schema

## `googleFlightsItinerary` (type: `string`):

Every itinerary this run returned.

## `scrapingSummary` (type: `string`):

HTML summary showing successful and failed results with key metrics

# 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 = {
    "operation": "flightSearch",
    "origin": "LHR",
    "destination": "JFK",
    "departureDate": "2026-10-15",
    "cabinClass": "economy",
    "maxStops": "any",
    "adults": 1,
    "maxResults": 32
};

// Run the Actor and wait for it to finish
const run = await client.actor("sian.agency/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 = {
    "operation": "flightSearch",
    "origin": "LHR",
    "destination": "JFK",
    "departureDate": "2026-10-15",
    "cabinClass": "economy",
    "maxStops": "any",
    "adults": 1,
    "maxResults": 32,
}

# Run the Actor and wait for it to finish
run = client.actor("sian.agency/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 '{
  "operation": "flightSearch",
  "origin": "LHR",
  "destination": "JFK",
  "departureDate": "2026-10-15",
  "cabinClass": "economy",
  "maxStops": "any",
  "adults": 1,
  "maxResults": 32
}' |
apify call sian.agency/google-flights-scraper --silent --output-dataset

```

## MCP server setup

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