# Google Flights Deals Scraper (`boncross/google-flights-deals`) Actor

Describe a trip in plain English and let Google pick the destinations, or get the routes it is currently selling well below their usual price. Each row carries the fare, the fare that route normally costs, the saving, the dates, the airline, journey time and stops.

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

## Pricing

from $1.05 / 1,000 deal-scrapeds

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 Deals Scraper

### What is Google Flights Deals Scraper?

Type "a week on a beach in Spain" and an airport, and Google Flights Deals Scraper hands you Málaga, Ibiza, Palma, Menorca, Alicante and Cádiz, each with its fare and dates. Google's own model reads the description and picks the destinations. Leave the description blank and you get something different: the routes Google is selling well below their usual price from your airport right now.

Whichever you ask for, each row has the fare, what that route normally costs, the saving, the dates, the airline, journey time and stops.

What you get here that a route search won't give you:

- **You can ask in plain English.** "3 day trip to somewhere in Germany" returned German cities. "Skiing in the Alps in January" returned Innsbruck, Geneva, Salzburg and Turin.
- **You see the usual price, not only today's.** A Heathrow to Paphos deal came back at £200 against a usual £633, a 68% saving, and the saving is there as a percentage and as an amount.
- **Dozens of airports in one run.** 70 origins returned 2,100 deals in 16 seconds.
- **You set the bar.** Keep only deals above a minimum saving or under a price, nonstop only if you like.
- **It's cheap to try.** $1.50 per 1,000 deals on the Free plan, $1.05 on Business. One airport's 30 deals cost about 5 cents, with proxy usage and platform usage included.

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

- 22 of 22 live checks on its inputs and filters passed on 8 October 2026
- 4 origins run on 7 October 2026, Manchester, Osaka, São Paulo and Reykjavik: 120 deals, none empty
- Charges matched the rows: 1 start, 120 deals

People mostly use it for a cheap-flights newsletter or deal alert built from a set of home airports, for a daily watch on one airport, and to feed a travel inspiration page with destinations, photos and live prices. It also works for comparing how much cheaper a route is from a nearby airport, for researching seasonal pricing by running the same origin across different months, and for giving a travel agency a shortlist of what's worth selling this week.

### What data do you get for each deal?

| | |
|---|---|
| 🏙 Destination city and country | 🛬 Destination airport code |
| 💷 Deal price | The price that route usually costs |
| Saving as a percentage | Saving as an amount |
| 📅 Outbound and return dates | ✈️ Airline flying it |
| ⏱ Journey time in minutes | Number of stops |
| 🛫 Origin airport and city | 🔗 Link to the flights on Google |
| 🖼 Destination photo | Short description of the place |
| Destination tags | Currency |

### How to scrape Google Flights deals

One field is enough to get going: your airport.

1. [Sign up for a free Apify account](https://console.apify.com/sign-up), then open [Google Flights Deals Scraper](https://apify.com/boncross/google-flights-deals).
2. Enter your origin airport. Add a description of the trip and rough dates if you have them.
3. Want only the strong deals? Set a minimum saving or a maximum price.
4. Click Start. One airport takes 4 to 10 seconds.
5. Download the deals as Excel, CSV, JSON, XML or HTML.

### ⬇️ Input

All you have to give is an origin. A city code such as `LON` covers that city's airports, and several codes separated by commas search them together.

**Google chooses the dates.** Each deal arrives on its own outbound and return dates. Any dates you enter are a starting point, and if you enter none the search starts a month out.

Each origin returns its own shortlist from Google, about 30 deals. That shortlist is the per-origin limit, and there's no separate per-origin cap to set. "Maximum deals" caps the whole run, and nothing past it is pushed or charged for.

You can narrow what you get with "Minimum saving", "Maximum price", "Nonstop only" and "Maximum journey time" (the longest one-way journey, in minutes). Setting a minimum saving also drops any deal Google shows no usual price for. Cabin, adults (1 to 9), currency (default USD) and the language for place names (default en) are yours to set as well.

**Describe the trip and let Google choose**

```json
{
  "prompt": "a week on a beach in Spain",
  "origin": "LHR",
  "departureDate": "2026-11-17",
  "returnDate": "2026-11-24",
  "currency": "GBP"
}
```

That's the search behind the six Spanish destinations at the top of this page. Leave `prompt` blank for the standard discounted-destination list.

**Everything cheap from London that week**

```json
{
  "origin": "LHR",
  "departureDate": "2026-11-17",
  "returnDate": "2026-11-24",
  "currency": "GBP"
}
```

**Only genuine bargains, under a budget**

```json
{
  "origin": "LON",
  "departureDate": "2026-11-17",
  "returnDate": "2026-11-24",
  "minSavingPercent": 40,
  "maxPrice": 250,
  "nonstop": true
}
```

**Several origins in one run**

```json
{
  "origin": "LHR",
  "extraOrigins": ["MAN", "EDI"],
  "departureDate": "2026-11-17",
  "returnDate": "2026-11-24",
  "cabinClass": "business",
  "maxItems": 100
}
```

#### For developers

- `maxItems` is the run-wide cap. There is no per-origin key, because Google fixes the shortlist at about 30.
- The filter keys are `minSavingPercent`, `maxPrice`, `nonstop` and `maxDurationMinutes`. `cabinClass` takes `economy`, `premium_economy`, `business` or `first`.
- Several codes in `origin` are searched as one city. Each entry in `extraOrigins` is searched separately and returns its own deals.
- `maxConcurrency` (default 32, 1 to 32) is how many origins are searched at once. Seven origins took 41-48 s one at a time and 8 s in parallel, and 70 origins took 41 s at 16 at once and 16 s at the default.
- Deals are saved as they arrive. Should the platform restart the run, it resumes from the last origin it finished, with no deal saved or charged twice.

### ⬆️ Output

You get one record per deal. Within each origin the biggest saving comes first. With a prompt, the cheapest fare comes first.

```json
{
  "recordType": "deal",
  "originCode": "LHR",
  "id": "LHR-PFO-2026-10-02",
  "originAirport": "Heathrow Airport",
  "originCity": "London",
  "destinationCode": "PFO",
  "destinationCity": "Paphos",
  "destinationCountry": "Cyprus",
  "departureDate": "2026-10-02",
  "returnDate": "2026-10-08",
  "price": 200,
  "usualPrice": 633,
  "savingPercent": 68,
  "savingAmount": 433,
  "currency": "GBP",
  "airlineCode": "A3",
  "airlineName": "Aegean",
  "durationMinutes": 275,
  "stops": 0,
  "imageUrl": "https://…",
  "tags": ["Coastal resorts & archaeological sites"],
  "description": "Coastal city & resort known for …",
  "url": "https://www.google.com/travel/flights?tfs=…",
  "scrapedAt": "2026-09-13T18:00:37.402Z"
}
```

`usualPrice` is Google's own estimate of the typical fare for that route. `savingPercent` and `savingAmount` are the difference between it and `price`.

### How many deals can you get, and how fast?

| Search | Deals | Time |
|---|---|---|
| London Heathrow, one week in November | 30 | 4-10 s |
| Heathrow and Manchester in one run | 60 | 15 s |
| Seven origins in one run | 210 | 8 s |
| 32 origins in one run | 960 | 12 s |
| 70 origins in one run | 2,100 | 16 s |

Your origins are searched side by side. Most of a run is Google working out the deals, which takes 2-4 s per origin and varies from run to run. The times are for the whole run on Apify, start-up and all, and were taken from 1 to 3 October 2026.

Google publishes a fixed shortlist of deals per origin and date pair, not an exhaustive list, and around 30 is what you get. Asking for a wider date range doesn't lengthen it. Running more origins does. The dates on each deal are Google's own suggestion for that destination and are often not the dates you asked for: your request sets the shape of the trip, not the exact days.

### How much does it cost?

| Event | Free plan | Starter | Scale | Business |
|---|---|---|---|---|
| `actor-start`, per run | $0.001 | $0.001 | $0.001 | $0.001 |
| `deal-scraped`, per deal returned | $0.0015 | $0.00135 | $0.0012 | $0.00105 |
| `origin-checked`, per origin with no deal for your dates | $0.0005 | $0.0005 | $0.0005 | $0.0005 |

Enterprise plans pay the Business price.

**$1.50 per 1,000 deals** on the Free plan, $1.05 on Business. Proxy usage and platform usage are part of that price.

You pay `deal-scraped` for each deal you get. `origin-checked` applies only to an origin that returns no deal for your dates, either because none was offered or because your filters removed them all. An error isn't charged.

- One origin returning 30 deals: $0.001 + 30 × $0.0015 = **$0.046** ($0.0325 on Business).
- An origin with nothing for your dates: $0.001 + $0.0005 = $0.0015 on any plan.

Apify's Free plan comes with $5 of credits each month, which is about 108 single-origin runs, or roughly 3,200 deals, before you pay a cent.

### FAQ

#### Why do the dates differ from the ones I entered?

Google treats your dates as the shape of the trip (roughly when, and for how long) and then suggests the cheapest days near them for each destination. That's why each deal has its own dates, and it's a large part of why the price is low.

#### What does the plain-English search return?

The same rows as any other run: destination, country, airport, fare, the fare the route usually costs, the dates, the airline, journey time and stops. You don't get a flight number or a departure time. It answers "where should I go and roughly what will it cost". For "which flight shall I book", search the route in [Google Flights Scraper](https://apify.com/boncross/google-flights-search).

#### How is the saving worked out?

Google publishes both the current fare and the fare the route typically goes for. You get both, plus the difference as a percentage and as an amount.

#### How do I search more than one airport?

Put several codes in the origin, separated by commas, to search them as one city. To run airports separately, each with its own list of deals, add them under "More origins".

#### Can I get more than 30 deals from one airport?

Not from one search. Google curates about 30 per origin, and a wider date range doesn't add more. Add nearby airports as extra origins and each brings its own 30.

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

You need neither. There's no proxy to configure or pay for, and no account or API key.

#### Is scraping Google Flights legal?

Reading publicly available pages is legal in most jurisdictions, and the deals here are shown to anyone who opens Google Flights without signing in. The actor collects no personal data. If you plan to republish fares, check what applies to you first, because that use is your responsibility.

#### What won't it do?

- Deals are a shortlist Google curates per origin, not a list of all the cheap fares it sells. For the full list of what flies a specific route, use [Google Flights Scraper](https://apify.com/boncross/google-flights-search).
- The dates attached to a deal are Google's suggestion for that destination and usually differ from the dates you entered.
- A plain-English search returns destinations and fares, not individual flights.
- A plain-English search is priced in economy whatever cabin you choose. The cabin setting applies to the discounted-destinations list only.
- The usual price is Google's own estimate of the typical fare for that route, not a figure this actor computes.
- Some deals arrive without an airline named (about one in five in measured runs) or without a description (about one in eight).
- A deal's price is Google's figure when the run happened, not an airline's live quote. It can change before you book.

### Turn it into a daily deal alert

Schedule the run in Apify each morning with a minimum saving set, and send the rows to Slack, a Google Sheet or your newsletter tool through a webhook, Zapier or Make. No code is involved.

If you'd rather call it yourself, one request runs the actor and returns the deals. JavaScript and Python clients exist.

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

An AI agent can ask the same question a person would. Connect the Apify MCP server (`mcp.apify.com`) to Claude, ChatGPT, Cursor or LibreChat, reference `boncross/google-flights-deals`, and let the agent pass the trip description as `prompt`.

### More from BonCross

- [Google Flights Booking Options Scraper](https://apify.com/boncross/google-flights-booking-options): See every airline and travel agency selling the same flight, each with its own price…
- [Google Flights Explore Scraper](https://apify.com/boncross/google-flights-explore): Find everywhere you can fly from one airport and what each destination costs.
- [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 Prices Scraper](https://apify.com/boncross/google-hotels-prices): Google Hotels price comparisons for any hotel and stay.

### Your feedback

Seen a deal on Google that didn't show up here, or a saving that looks wrong? Post it on the Issues tab in Apify Console with the origin and dates. We answer every report there.

# Changelog

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

# Actor input Schema

## `prompt` (type: `string`):

Say what you want in plain English and Google picks the destinations: "3 day trip to somewhere in Germany", "a week on a beach in Spain", "skiing in the Alps in January". Leave blank to get the standard discounted-destination list instead.

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

The airport you would fly from, such as LHR. A city code such as LON searches every airport in that city, and several codes separated by commas search them together. You can also type a place name such as "Barcelona" or "Heathrow" and it is resolved for you.

## `extraOrigins` (type: `array`):

Additional origins, one per line. Each is searched separately and returns its own deals. You can also type a place name such as "Barcelona" or "Heathrow" and it is resolved for you.

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

Optional. Google picks each deal's own dates and uses this only as a starting point, so the deals come back on their own dates, usually not this one. Leave it empty and the search starts a month out. YYYY-MM-DD.

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

Optional, as with the outbound date: a starting point, not a filter. Leave it empty for a week after the outbound date. YYYY-MM-DD.

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

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

## `minSavingPercent` (type: `integer`):

Only keep deals at least this far below what the route usually costs, as a percentage. Works with a prompt too. A deal the site shows no usual price for is dropped when this is set.

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

Only keep deals at or under this total price.

## `nonstop` (type: `boolean`):

Only keep destinations reached without changing plane. Google does not always honour this on its own, so connecting deals are removed here as well.

## `maxDurationMinutes` (type: `integer`):

Longest acceptable one-way journey, in minutes.

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

Cabin to price the deals in.

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

Number of adult passengers.

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

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

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

Two letter language code for place names, 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",
  "extraOrigins": [],
  "minSavingPercent": 0,
  "nonstop": false,
  "cabinClass": "economy",
  "adults": 1,
  "currency": "USD",
  "language": "en",
  "maxConcurrency": 32,
  "restartAttempt": 0
}
```

# Actor output Schema

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

Google Flights deals: 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 = {
    "prompt": "",
    "origin": "LHR",
    "extraOrigins": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("boncross/google-flights-deals").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 = {
    "prompt": "",
    "origin": "LHR",
    "extraOrigins": [],
}

# Run the Actor and wait for it to finish
run = client.actor("boncross/google-flights-deals").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 '{
  "prompt": "",
  "origin": "LHR",
  "extraOrigins": []
}' |
apify call boncross/google-flights-deals --silent --output-dataset

```

## MCP server setup

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

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/1Daqvyzf55Hhbdbtp/builds/d0ZsMRPpQxSeT3CCr/openapi.json