# Google Flights Scraper & API - Fares, Stops & CO2 Emissions (`surefeed/google-flights-scraper`) Actor

Scrape Google Flights for any route and dates: price, airline, times, duration, stops, layovers, bags and CO2 emissions. One-way or round trip, any cabin, adults, children and infants, flexible dates, airline and time filters. Verified.

- **URL**: https://apify.com/surefeed/google-flights-scraper.md
- **Developed by:** [gianluca de dominicis](https://apify.com/surefeed) (community)
- **Categories:** Travel, Agents, Automation
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.67 / 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 - Fares, Stops & CO2 Emissions

Get **Google Flights fares** for any route and dates: price, airline, departure and arrival times, duration, stops and layovers, baggage and **CO2 emissions** — one-way or round trip, any cabin, adults, children and infants, flexible dates — as a spreadsheet, JSON or a live API.

**Round-trip searches:** each result describes an outbound option. Its `price` is the lowest associated round-trip total starting with that option; the return flight has not yet been selected. Do not treat a result as a confirmed complete return itinerary.

> ⭐ **Found this Actor useful?** [Leave a review](https://apify.com/surefeed/google-flights-scraper/reviews) — it takes 30 seconds and helps other people find it.
>
> 🛠️ **Something not working?** [Open an issue](https://apify.com/surefeed/google-flights-scraper/issues) with the run link, expected behavior and observed result. We review reported issues; resolution time depends on the cause.

**What you get for each flight**

- 💶 **Price** in your currency (total for all passengers; round-trip total for round trips), and whether it excludes a carry-on bag
- ✈️ **Airlines** and operating carrier, **departure and arrival** airports (codes and names), times and dates, **duration**
- 🔁 **Stops and layovers**: airport, city and layover time
- 🌱 **CO2 emissions** in kg and versus the typical flight on the route (e.g. −23%), plus included bags
- 📅 **Flexible dates**: search several consecutive days and spot the cheapest one, plus Google's verdict on the fares (*low / typical / high*)
- 🎯 **Filters**: airlines to include or exclude, max price, max travel time, departure and arrival time windows, max stops

**First run:** open **Input**, paste the [simple example below](#input), update its dates if needed, then click **Start**. It searches **London → Rome**, round trip, for **1 adult in economy**, with prices in **EUR**, no airline exclusion and a limit of **20 results**. Open the completed run's dataset and export CSV, Excel or JSON. At the base rate before plan discounts, each returned flight costs **$0.001**; **20 returned flights cost $0.02**. Fewer results may be available. No Google account or login is needed.

Real results — London → Rome, round trip Feb 12–15, 2027, searched on Nov 12, 2026, prices in euros (same order as on Google Flights):

| # | Price (round trip) | Airline | Departs | Arrives | From → To | CO2 |
|---|---|---|---|---|---|---|
| 1 | €213 | Wizz Air | 9:45 PM | 1:20 AM | LTN → FCO | 102 kg |
| 2 | €251 | Wizz Air | 2:40 PM | 6:15 PM | LTN → FCO | 102 kg |
| 3 | €388 | Ryanair | 8:10 AM | 11:35 AM | STN → CIA | 116 kg |

#### Why this Google Flights scraper?

| Capability / common requirement | This Actor |
|---|---|
| Unverified data | **Historical validation**: we compared a full results page with Google Flights in a browser — **same 19 flights, same order, 76 of 76 prices, airlines and times identical** |
| Per-result pricing | **$1 per 1,000 flights**, no start fee: a typical search is a few cents |
| Price only | **CO2 emissions**, layover airports and times, included bags, operating carrier and "price without carry-on" flag |
| One date at a time | **Flexible dates**: search up to 30 following days in one run, cheapest flight of each day marked |
| Adults only | **Adults, children, infants in seat and on lap** — checked: the link opens Google Flights with the same passengers |
| Filter after downloading | Filter by **airline, price, travel time and departure/arrival time** in the run: you pay only for the flights you keep |
| Airport codes mixed up with airline names (ITA, KLM, LOT…) | Codes read from the airport they belong to |

Coverage depends on source availability, filters and accessible pages; complete coverage is not guaranteed. Any validation figures below or above describe historical samples, not a guarantee of future accuracy or uptime.

#### Use cases

- **AI travel agents**: find and compare flights for a user's exact route, dates, cabin and party size.
- **Fare monitoring**: track a route every day and configure alerts when the cheapest observed price drops.
- **Cheapest day to fly**: search the next 2–4 weeks and pick the best date.
- **Sustainability reporting**: compare CO2 emissions of business trips by airline and route.

#### How to use

1. Enter **Routes**, one per line: airport codes (`JFK-LAX`) or city codes covering all airports (`LON-ROM`, `NYC-PAR`).
2. Set the **Departure date** and, for a round trip, the **Return date**. Optional: **Also search the following days**. Google Flights shows fares up to about **11 months ahead** (329 days when last measured).
3. Choose the passengers (**Adults**, **Children**, **Infants**), **Cabin** and **Stops**, and optionally the **Filters** (airlines, max price, max duration, time windows).
4. Set the **Currency** (3-letter code: USD, EUR, GBP, JPY, AUD, CAD, INR, BRL…) and **Search from country** (2-letter code: us, gb, it…).
5. Click **Start** and download the results as JSON, CSV, Excel or via API.

#### Input

One route, one adult and one departure/return date pair make the first run easier to check. Replace both fixed dates with future dates appropriate for your trip. This configuration uses the same route, dates, cabin, passenger count and currency as the historical output example below.

```json
{
    "routes": ["LON-ROM"],
    "departureDate": "2027-02-12",
    "returnDate": "2027-02-15",
    "extraDays": 0,
    "adults": 1,
    "children": 0,
    "cabin": "economy",
    "currency": "EUR",
    "country": "it",
    "maxFlightsPerSearch": 20
}
```

#### Input checks: no failed runs, no charge for a wrong input

Input the search cannot use ends the run normally with an **"Input problem"** status message that says what to fix — no flights saved, nothing charged:

| Input | What happens |
|---|---|
| No routes, or a route that is not two 3-letter codes | Message asking for a route such as `JFK-LAX` |
| Same origin and destination (`JFK-JFK`) | Message naming the route |
| Departure date in the past, or return before departure | Message naming the date |
| Dates (including the extra days) beyond about 11 months | Message with the last date Google Flights offers |
| Airport or city code Google Flights does not know | That route is skipped within seconds and named in the final message; the other routes are still returned |
| Currency Google Flights does not offer | Run stopped with a message: Google would answer in US dollars, and prices are never returned under the wrong currency |

If a valid search cannot be loaded, the first page received is saved as `FAILED_PAGE` in the run's key-value store; add the run link to your issue and we can see what Google answered.

#### Output

One item per outbound flight option. This is a **sample from a real run on November 12, 2026** for London → Rome, February 12–15, 2027, one adult, economy and EUR—the same search as the first input. It is **not a current fare quote**: prices and availability change. For this round trip, `price` is the lowest associated round-trip total; the return flight is not yet selected.

```json
{
    "route": "LON-ROM",
    "tripType": "round trip",
    "searchDepartureDate": "2027-02-12",
    "searchReturnDate": "2027-02-15",
    "rank": 1,
    "isCheapest": true,
    "price": 213,
    "priceIsRoundTripTotal": true,
    "airlines": ["Wizz Air"],
    "operatedBy": null,
    "stops": 0,
    "layovers": [],
    "originAirport": "London Luton Airport",
    "originCode": "LTN",
    "destinationAirport": "Leonardo da Vinci International Airport",
    "destinationCode": "FCO",
    "departureTime": "9:45 PM",
    "departureDate": "Friday, February 12",
    "arrivalTime": "1:20 AM",
    "arrivalDate": "Saturday, February 13",
    "duration": "2 hr 35 min",
    "durationMinutes": 155,
    "co2Kg": 102,
    "co2VsTypical": "-18%",
    "bags": [],
    "priceExcludesCarryOn": true,
    "currency": "EUR",
    "priceInsight": "high",
    "cabin": "economy",
    "adults": 1,
    "googleFlightsUrl": "https://www.google.com/travel/flights/search?tfs=…&hl=en&gl=it&curr=EUR"
}
```

| Field | Meaning |
|---|---|
| `price` | Total for all passengers. Round trips: cheapest round-trip total that starts with this outbound flight |
| `isCheapest` | Cheapest flight of this route and date (after your filters) |
| `priceInsight` | Google's verdict on fares for this search ("low", "typical", "high") when Google shows one |
| `layovers` | Each stop: airport, city, layover time (`durationMinutes`) |
| `co2Kg` / `co2VsTypical` | Estimated emissions and difference from the typical flight on the route, as shown by Google |
| `priceExcludesCarryOn` | The fare does not include an overhead-bin bag |
| `separateCabinNote` | Set when part of the trip is in another cabin (e.g. "First Class" on one leg) |

#### Advanced example: multiple routes and family filters

This is a separate advanced configuration, not the request behind the historical output above. It searches additional routes and dates for a different party size and excludes Ryanair. More returned flights mean a higher total Actor charge; use **Max flights per search** and **Max cost per run** to control volume and spending. Replace the fixed dates before running it when needed.

```json
{
    "routes": ["LON-ROM", "MXP-FCO"],
    "departureDate": "2027-02-12",
    "returnDate": "2027-02-15",
    "extraDays": 2,
    "adults": 2,
    "children": 1,
    "cabin": "economy",
    "maxStops": "1",
    "excludeAirlines": ["Ryanair"],
    "maxPrice": 400,
    "departureTimeFrom": "08:00",
    "currency": "EUR",
    "country": "it"
}
```

#### How much does it cost?

Prices and examples below use base rates before plan discounts. The Store’s “from” price may reflect a higher-plan discount; check the Pricing tab for your current plan’s rate.

**Pay per event** — no monthly rental, no start fee, no proxy or compute surcharge:

- **Flight** — each flight returned: **$1.00 per 1,000** (volume discounts on higher Apify plans).

| Example | Base-rate calculation | Actor charge (USD) |
|---|---|---|
| First-run example: 20 returned flights | 20 × $1 / 1,000 | **$0.02** |
| Larger search: 14 dates with 30 returned flights per date | 420 × $1 / 1,000 | **$0.42** |

These are Actor charges before plan discounts, **not airfare prices**. Fewer returned flights mean a lower charge. Use **Max flights per search** to limit results and **Max cost per run** to limit spending.

#### Automate & integrate

Scheduling, notifications and external destinations require configuration in Apify or the relevant integration.

Schedule daily runs to monitor fares, trigger webhooks when a price drops, or send results to Google Sheets, Slack, Make, Zapier or n8n. Call it from any language through the Apify API.

#### Use with AI assistants (MCP)

Add this Actor as a tool to Claude, ChatGPT, Cursor or any MCP client through the Apify MCP server (`https://mcp.apify.com`). Your assistant can then search and compare flights on demand.

#### Agent-ready: autonomous payments (x402 & Skyfire)

Where supported by Apify, agents can use platform payment integrations such as x402 or Skyfire. Availability, authentication and payment setup depend on Apify’s current integration requirements.

#### FAQ

**How accurate is the data?**
We opened the same search (London → Rome, round trip, Italy, euros) in a browser right after a run: Google Flights listed the same 19 flights in the same order, with identical prices, airlines and departure and arrival times. Fares change quickly, so compare runs made at the same time.

**What does the round-trip price mean?**
Like Google Flights' first step, each outbound flight shows the cheapest round-trip total starting with it; the return flight is not chosen yet.

**Are prices per person?**
No — they are the total for all the passengers you set, as on Google Flights.

**Why are some results missing compared with Google Flights?**
The Actor returns the flights in the results page Google sends. In a browser, Google sometimes adds a few more after the page has loaded: in our checks the Actor returned 19 of 19 flights for one search and 17 of 19 for a family search (2 flights of one airline were added later by the browser) — every flight returned had the same price and times as in the browser. Narrow the search with **Stops** or airport codes if you need a specific flight.

**Can I include children?**
Yes: **Children**, **Infants in seat** and **Infants on lap** (one per adult), up to 9 passengers in total.

**How far ahead can I search?**
About 11 months (329 days when last measured), the same window as the Google Flights calendar. A search that goes beyond it — counting the return date and the extra days — ends with a message instead of running.

**What if one of my routes has a wrong code?**
The run continues: routes Google Flights recognises are returned and the others are listed in the final status message. If no route is recognised, the run ends with an "Input problem" message and no charge.

**Multi-city trips?**
Not yet — one-way and round trips only.

**Is it legal to scrape Google Flights?**
This Actor only collects publicly available data. Check Google's terms and your local laws before using the data.

**Something is broken — what now?**
Open an issue on the **Issues** tab with the run link. Include the expected behavior and observed result. Resolution time depends on the cause.

#### More tools from us

- [Kleinanzeigen Scraper & API](https://apify.com/surefeed/kleinanzeigen-scraper) — available listings on Kleinanzeigen.de, with search partitioning for larger result sets, with price drops and only-new monitoring.
- [Google Hotels Scraper & API](https://apify.com/surefeed/google-hotels-scraper) — hotel prices with tax-basis indicators, optional booking-partner offers, and hotels near any address.
- [Google Trends Scraper & API](https://apify.com/surefeed/google-trends-scraper) — interest over time, by region, related queries and trending searches.
- [Google Play Scraper & API](https://apify.com/surefeed/google-play-scraper) — Android app data, star histograms and reviews.
- [App Store Scraper & API](https://apify.com/surefeed/app-store-scraper) — iPhone app data, top charts and reviews by country.
- [Workday Jobs Scraper & API](https://apify.com/surefeed/workday-jobs-scraper) — available jobs from supported Workday careers sites, with exact posting date, salary range and remote status.
- [Eventbrite Scraper & API](https://apify.com/surefeed/eventbrite-scraper) — available events by city or online, with ticket prices, sold out and organizer details.

#### Legal

**Disclaimer:** This Actor is an independent tool and is not affiliated with, endorsed by, or sponsored by Google LLC. It only collects publicly available data. All trademarks belong to their respective owners.

# Actor input Schema

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

One route per line: origin and destination as 3-letter airport codes (JFK-LAX, LHR-FCO) or city codes that include all airports (NYC-LON, LON-ROM, PAR-MIL).

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

YYYY-MM-DD. Defaults to 14 days from today.

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

Optional. Set it for round trips: prices are then the cheapest round-trip total starting with each outbound flight.

## `extraDays` (type: `integer`):

Flexible dates: also search this many days after the departure date (round trips keep the same length). 0 = only the chosen date. Each day is a separate search; isCheapest marks the cheapest flight of each day.

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

Number of adults (1–9). Prices are the total for all passengers.

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

Number of children.

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

Infants under 2 with their own seat.

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

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

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

Travel class.

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

Maximum number of stops.

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

Optional: keep only flights operated by these airlines, as Google Flights names them (e.g. "Ryanair", "British Airways", "ITA").

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

Optional: drop flights with these airlines.

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

Optional: keep flights up to this price (total, in the chosen currency).

## `maxDurationHours` (type: `integer`):

Optional: keep flights up to this total travel time, layovers included.

## `departureTimeFrom` (type: `string`):

Optional, 24-hour clock (e.g. 06:00): earliest departure time.

## `departureTimeTo` (type: `string`):

Optional, e.g. 12:00: latest departure time.

## `arrivalTimeFrom` (type: `string`):

Optional, e.g. 08:00: earliest arrival time.

## `arrivalTimeTo` (type: `string`):

Optional, e.g. 22:00: latest arrival time.

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

3-letter currency code (USD, EUR, GBP…).

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

Two-letter country of the Google Flights site (us, gb, it…): some fares and booking options depend on it.

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

Keep at most this many flights for each route and date, in Google's order (best flights first).

## Actor input object example

```json
{
  "routes": [
    "JFK-LAX"
  ],
  "extraDays": 0,
  "adults": 1,
  "children": 0,
  "infantsInSeat": 0,
  "infantsOnLap": 0,
  "cabin": "economy",
  "maxStops": "any",
  "currency": "USD",
  "country": "us",
  "maxFlightsPerSearch": 50
}
```

# Actor output Schema

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

Items produced by the run.

## `runSummary` (type: `string`):

Duration, charged events and whether the spending limit was reached.

# 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"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("surefeed/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"] }

# Run the Actor and wait for it to finish
run = client.actor("surefeed/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"
  ]
}' |
apify call surefeed/google-flights-scraper --silent --output-dataset

```

## MCP server setup

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