# Google Flights Booking Options Scraper (`boncross/google-flights-booking-options`) Actor

See every airline and travel agency selling the same flight, each with its own price and a link into its checkout. Add a route and a date and get the seller, the fare, the website and whether it books direct with the airline.

- **URL**: https://apify.com/boncross/google-flights-booking-options.md
- **Developed by:** [BonCross API](https://apify.com/boncross) (community)
- **Categories:** Travel
- **Stats:** 2 total users, 1 monthly users, 80.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.20 / 1,000 itinerary-priceds

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 Booking Options Scraper

### What is Google Flights Booking Options Scraper?

A flight search shows you one price per itinerary. Behind that price sits a list of sellers, the airline and a row of travel agencies, each asking something different for the same seat. Google Flights Booking Options Scraper gets you that list: who sells the flight, what each one charges, and a link into each checkout.

Enter a route and a date, or paste a Google Flights link.

The short case for it:

- **You see the spread, not a single number.** A busy route returns around ten sellers per itinerary. London to New York, one way, gave 20 offers across 2 itineraries in 4 to 6 seconds.
- **Return trips are priced too.** Three round trips (London to New York, Manchester to Barcelona, London to Dubai) returned 51 offers across 9 itineraries in 11 seconds.
- **You decide which flights get priced.** Stop and airline filters are applied before anything is looked up, and an itinerary they exclude costs you nothing.
- **Each offer links to its checkout.** Airline direct or agency, you get the seller's booking link and a flag telling you which it is.
- **It scales.** 60 routes at three itineraries each returned 888 to 895 offers in 36 seconds.

**BonCross Verified** means we tested this actor against the live site before release and kept the record:

- 20 of 20 live checks on its inputs and filters passed on 8 October 2026
- 7 routes run on 7 October 2026, two of them returns: 14 itineraries priced, 31 seller offers
- Charges matched the rows: 1 start, 14 itineraries, 31 offers

### What can you do with seller prices?

- Check whether an agency really undercuts the airline before you book
- Show a price-comparison table for a flight on your own site
- Monitor how the spread between sellers moves on a route over time
- Find which agencies sell a route, and at what margin
- Feed a booking funnel with live seller links in place of a single price
- Audit whether your own fares are being resold below your direct price

### What data can you extract?

| | |
|---|---|
| 🏷 Seller name and code | ✈️ Whether it books direct with the airline |
| 💷 That seller's price | 🔗 Link into the seller's checkout |
| 🌐 Seller website | Seller logo, where Google supplies one |
| Flight numbers priced | Itinerary the offer belongs to |
| The itinerary's headline price | 📅 Departure date |
| 🛫 Origin and destination | Currency |

### How to scrape booking options

1. [Open a free Apify account](https://console.apify.com/sign-up). An email address is all it takes.
2. Open [Google Flights Booking Options Scraper](https://apify.com/boncross/google-flights-booking-options).
3. Enter a route and a date, or paste a Google Flights link.
4. Choose how many itineraries to price. They're taken in the order Google lists them for the route.
5. Click Start. London to New York with two itineraries took 4 to 6 seconds.
6. Download the offers as Excel, CSV, JSON, XML or HTML.

Our advice: start with the default of 3 itineraries and raise it once you've seen what a route returns.

### ⬇️ Input

Give it a route and a date, with a return date if it's a round trip. Got several routes? Add them under "More routes" as `origin,destination,date` lines, where a fourth date makes the line a round trip. If you already have Google Flights links, they go in "Google Flights URLs". You can type a place name such as "Heathrow" or "Barcelona" and it's resolved to airports for you.

The itineraries priced are the first ones Google lists for the route that pass "Maximum stops" and "Only these airlines". Those two filters change *which* flights are priced, not just what you get back.

You have two limits:

- "How many itineraries to price" (default 3, up to 25) is the per-route limit. Sellers are fetched one itinerary at a time, which makes this the setting that governs the cost of a run.
- "Maximum offers" is a ceiling on offers across the whole run. Nothing past it is pushed or charged for.

You can also set the cabin, adults (1 to 9), children (0 to 8), currency (default USD) and language (default en).

**Who sells the top London to New York flights**

```json
{
  "origin": "LHR",
  "destination": "JFK",
  "departureDate": "2026-11-17",
  "maxItineraries": 3,
  "currency": "GBP"
}
```

**More itineraries from one route**

```json
{
  "origin": "LHR",
  "destination": "JFK",
  "departureDate": "2026-11-17",
  "maxItineraries": 5,
  "cabinClass": "business"
}
```

**Only nonstop flights on one airline**

```json
{
  "origin": "LHR",
  "destination": "JFK",
  "departureDate": "2026-11-17",
  "maxStops": 0,
  "airlines": ["BA"],
  "maxItineraries": 2
}
```

**A round trip**

```json
{
  "origin": "LHR",
  "destination": "JFK",
  "departureDate": "2026-11-17",
  "returnDate": "2026-11-24",
  "maxItineraries": 2
}
```

**Several routes in one run**

```json
{
  "extraRoutes": [
    "LHR,JFK,2026-11-17",
    "MAN,DUB,2026-11-18",
    "LGW,BCN,2026-11-19"
  ],
  "maxItineraries": 2,
  "currency": "GBP"
}
```

#### For developers

- `maxItineraries` is the per-route limit and `maxItems` the run-wide ceiling on offers.
- The route keys are `origin`, `destination`, `departureDate` and `returnDate`. `extraRoutes` and `searchUrls` take the lists. `cabinClass` is one of `economy`, `premium_economy`, `business`, `first`.
- `maxStops` (0 to 3, 0 for nonstop only) and `airlines` (codes such as `BA`, or an alliance such as `ONEWORLD`) are applied before pricing. When no itinerary passes them, the run log says so and nothing is charged beyond the start.
- `maxConcurrency` (default 32, 1 to 32) is how many requests run at once. Routes, and the itineraries on each, are priced at the same time: the five-route run took 162 s one call at a time.
- Rows are saved as the run goes. After a platform restart the run continues from where it stopped and doesn't save or charge anything twice.

### ⬆️ Output

You get one record per seller, per itinerary.

```json
{
  "recordType": "bookingOffer",
  "id": "hXefte-BA-0",
  "itineraryId": "hXefte",
  "itineraryPrice": 331,
  "origin": "LHR",
  "destination": "JFK",
  "departureDate": "2026-11-17",
  "flights": ["BA175"],
  "sellerCode": "BA",
  "sellerName": "British Airways",
  "isAirlineDirect": true,
  "logoUrl": null,
  "price": 331,
  "currency": "GBP",
  "website": "www.britishairways.com/...",
  "url": "https://www.google.com/travel/flights/search?tfs=…",
  "bookingUrl": "https://www.google.com/travel/clk/f?u=…",
  "scrapedAt": "2026-09-13T19:30:00.000Z"
}
```

Offers from one itinerary share an `itineraryId`. Group by it and you have the price spread for a single flight. One seller can list the same flight at several fares (different fare products), which is why `id` is the itinerary, the seller and the offer's position together. `url` is the Google Flights search the offer was priced from, and `bookingUrl` leads into the seller's checkout.

For a round trip (a return date, a fourth date in a "More routes" line, or a pasted return search), each outbound itinerary is priced together with the cheapest return flight Google pairs with it. `flights` then lists both directions, `returnFlights` the return half and `returnItineraryId` its id, and `itineraryPrice` is the round-trip total. On a one-way offer `returnDate`, `returnFlights` and `returnItineraryId` are null.

### How much does it cost?

| Event | Free plan | Starter | Scale | Business |
|---|---|---|---|---|
| `actor-start`, per run | $0.001 | $0.001 | $0.001 | $0.001 |
| `itinerary-priced`, per itinerary whose sellers are looked up | $0.006 | $0.0054 | $0.0048 | $0.0042 |
| `offer-scraped`, per seller offer returned | $0.0006 | $0.00054 | $0.00048 | $0.00042 |

Enterprise plans pay the Business price.

**$12.00 per 1,000 itineraries** at about ten offers each (0.006 + 10 × 0.0006 = $0.012 an itinerary) on the Free plan, $8.40 on Business. Proxy usage and platform usage are included, and nothing else is added.

Pricing three itineraries and getting about thirty offers costs $0.001 + 3 × $0.006 + 30 × $0.0006 = **$0.037** ($0.026 on Business). The per-itinerary event is the one to watch, because each itinerary is a separate lookup.

With the $5 of monthly credits in Apify's Free plan you can do about 135 runs of that size, roughly 400 itineraries with their sellers.

### How long does pricing take?

| Search | Itineraries priced | Offers | Time |
|---|---|---|---|
| London to New York, one way | 2 | 20 | 4-6 s |
| London to Phuket, one way | 3 | 31 | 10-14 s |
| Three round trips (London-New York, Manchester-Barcelona, London-Dubai) | 9 | 51 | 11 s |
| Five routes, five itineraries each | 25 | 176-177 | 12-19 s |
| Eight routes, four itineraries each | 32 | 179 | 19-25 s |
| 60 routes, three itineraries each | 180 | 888-895 | 36 s |

Most of a run is Google pricing each itinerary, at 3-5 s a call. Because routes are priced side by side, 60 routes take about 36 seconds, and several thousand fit inside the default one-hour run limit. We timed whole runs on Apify, start-up included, between 1 and 7 October 2026.

How many sellers should you expect? A busy route returns somewhere around ten per itinerary, split between the airlines flying it and the agencies reselling it. A quiet route returns fewer, and sometimes only the airline. All offers have a booking link. Google supplies logos for a minority of sellers, and most rows have none.

### Limitations

- Sellers are fetched one itinerary at a time, and pricing many itineraries takes proportionally longer.
- The itineraries priced are the first Google lists for the route that pass your stop and airline filters. To choose by hand, narrow the route in Google Flights Scraper and paste its search link here.
- **A round trip is priced with one return per outbound**: the cheapest Google pairs with it (on a tie, one on the outbound's airline). A different return flight can have other sellers. To price a particular pairing, paste the Google Flights link for it.
- Prices are for the whole party in the request (two adults cost about twice one), not per person.
- Logo URLs are only published when Google supplies one, which is a minority of sellers. You get no logo in place of a guessed one that wouldn't load.
- Prices are the ones Google shows, not a live quote from the seller, and can move between a run and a booking.

### FAQ

#### How is this different from a flight search?

A search returns itineraries with one price each. This returns the sellers behind an itinerary, each with their own price, for comparing who sells the same flight and for how much. If you want the itineraries themselves, [Google Flights Scraper](https://apify.com/boncross/google-flights-search) is the one to use.

#### Which itineraries get priced?

The first ones Google lists for your route that pass the stop and airline filters, in its order. Raise the itinerary count to go deeper, or narrow the filters to steer which flights qualify.

#### How do I keep the cost of a run down?

Keep "How many itineraries to price" low. Each itinerary is its own lookup at $0.006 on the Free plan, and the offers under it are a tenth of that each. Filtering to nonstop or to one airline also helps, because itineraries that don't pass are never priced.

#### Which return flight is used on a round trip?

The cheapest one Google pairs with each outbound, and on a tie, one on the outbound's airline. `returnFlights` tells you which. For a specific pairing, paste the Google Flights link for it.

#### Can I paste a Google Flights link?

Put it in "Google Flights URLs" and the same route is priced.

#### Why do some sellers have no logo?

Google supplies a logo code for only some sellers. Where it doesn't, the field is empty.

#### Do I need proxies or a Google account?

No. Proxy usage is included in the price, and there's no account, login or API key involved.

#### Is scraping Google Flights legal?

Seller prices on Google Flights are shown to any visitor, signed in or not, and scraping public information of that kind is legal in most jurisdictions. No personal data is involved. You're responsible for how you use the prices, including any republishing. Check your own obligations first.

### Track a route's sellers over time

A daily check of the spread between sellers needs no code. Schedule the run in Apify and let a webhook, Google Sheets or Slack receive the offers. Group by `itineraryId` in the sheet and you can watch who undercuts whom.

To run it from code, send the input in one API call and the offers are returned in the response. Clients exist for JavaScript and Python.

```
POST https://api.apify.com/v2/acts/boncross~google-flights-booking-options/run-sync-get-dataset-items?token=YOUR_TOKEN
```

AI agents can call it through the Apify MCP server (`mcp.apify.com`) from Claude, ChatGPT, Cursor or LibreChat, with the actor referenced as `boncross/google-flights-booking-options`. A useful prompt is a route, a date and "who sells this cheapest".

### More from BonCross

- [Google Flights Multi-City Scraper](https://apify.com/boncross/google-flights-multi-city): Google Flights multi-city trips of three legs or more, and quiet routes Google leaves…
- [Google Flights Scraper](https://apify.com/boncross/google-flights-search): Google Flights for any route and date and get every itinerary with price, airlines,…
- [Google Maps Directions Scraper](https://apify.com/boncross/google-maps-directions): Google Maps directions as JSON for driving, transit, walking and cycling.
- [Google Hotels Search Scraper](https://apify.com/boncross/google-hotels-search): Google Hotels prices for a whole city or map area.
- [Accor Hotel Details Scraper](https://apify.com/boncross/accor-hotel-details): Full Accor hotel records.
- [Agoda Search Scraper](https://apify.com/boncross/agoda-search): Agoda search results for any destination and dates.

### Your feedback

Is a seller Google shows missing from your results, or a price different from the one on the page? Raise it on the Issues tab in Apify Console, with the route and date if you can. We read each one and reply there, and requests feed into what BonCross builds next.

# Changelog

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

# Actor input Schema

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

Departure airport code such as LHR. A city code such as LON searches every airport in that city. You can also type a place name such as "Barcelona" or "Heathrow" and it is resolved for you.

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

Arrival airport code such as JFK. You can also type a place name such as "Barcelona" or "Heathrow" and it is resolved for you.

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

Outbound date, as YYYY-MM-DD. Leave it empty to price the route 30 days from today.

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

Leave empty for a one-way trip. With a return date, each outbound itinerary is priced as a round trip together with the cheapest return flight Google pairs with it.

## `extraRoutes` (type: `array`):

One route per line as origin, destination and departure date, for example "LHR,JFK,2026-11-17". Add a return date for a round trip: "LHR,JFK,2026-11-17,2026-11-24".

## `searchUrls` (type: `array`):

Paste Google Flights search links instead of naming routes. Each is priced the same way.

## `maxItineraries` (type: `integer`):

Sellers are fetched one itinerary at a time, in the order Google lists the itineraries for the route. This number is what governs the cost of a run.

## `maxItems` (type: `integer`):

A ceiling on the whole run. Nothing past it is pushed or charged for.

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

Cabin to price in.

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

Number of adult passengers.

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

Number of children aged 2 to 11.

## `maxStops` (type: `integer`):

Only price itineraries within this many stops. 0 means nonstop only.

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

Airline codes such as BA, or an alliance name such as ONEWORLD, to restrict which itineraries are priced.

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

Three letter currency code, such as USD or GBP. Default USD.

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

Two letter language code, such as en.

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

How many requests run at once across the whole run. The default is the fastest level measured clean; lower it only if a run reports refusals or errors.

## `restartAttempt` (type: `integer`):

Set by the actor when it restarts itself in a fresh container after capturing nothing. Leave it alone.

## Actor input object example

```json
{
  "origin": "LHR",
  "destination": "JFK",
  "extraRoutes": [],
  "searchUrls": [],
  "maxItineraries": 3,
  "cabinClass": "economy",
  "adults": 1,
  "children": 0,
  "airlines": [],
  "currency": "USD",
  "language": "en",
  "maxConcurrency": 32,
  "restartAttempt": 0
}
```

# Actor output Schema

## `dataset` (type: `string`):

Google Flights booking options: every row the run returned.

## `stats` (type: `string`):

Counts for the run: what was resolved, fetched, filtered and returned.

# 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": "LHR",
    "destination": "JFK",
    "extraRoutes": [],
    "searchUrls": [],
    "airlines": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("boncross/google-flights-booking-options").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": "LHR",
    "destination": "JFK",
    "extraRoutes": [],
    "searchUrls": [],
    "airlines": [],
}

# Run the Actor and wait for it to finish
run = client.actor("boncross/google-flights-booking-options").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": "LHR",
  "destination": "JFK",
  "extraRoutes": [],
  "searchUrls": [],
  "airlines": []
}' |
apify call boncross/google-flights-booking-options --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,boncross/google-flights-booking-options"
        }
    }
}
```

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/NglsZF2WScEDwV5fN/builds/txbd3uMRh3vuzTbdu/openapi.json