# Google Flights Scraper - Airfare, Price Calendar & Alerts (`scrapewise/google-flights-scraper`) Actor

Get Google Flights prices by origin, destination and date: fares with a booking link per flight, cheapest price for every date up to 10 months ahead, typical price range and alerts below your target or cheaper than the last run. Airline, stops and cabin filters. No login. Free input checks.

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

## Pricing

from $1.28 / 1,000 flight delivereds

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

Google Flights Scraper turns **Google Flights** airfare into clean JSON, CSV or Excel, **without login or an API key**: flight prices with a real booking link per flight, the cheapest price for every departure date, Google's typical price range, and price alerts that charge only for the fares you want. It returns three kinds of rows:

- **Flights:** price, airlines, stops, layovers, every leg with its flight number and aircraft, CO2, and a **booking link** for that flight.
- **Price calendar:** the cheapest price for **every departure date up to about 10 months ahead**, as in Google's date grid.
- **Price insight:** Google's **typical price range** for the route (low, typical or high) and about 60 days of price history.

Routes can be one way or round trip, from airport or city codes (NYC, LON). You can choose any cabin, passenger count, airline and currency.

<a id="at-a-glance"></a>

### Google Flights scraper pricing at a glance

| Event | Free plan | Bronze | Silver | Gold and above |
|---|---|---|---|---|
| Flight delivered, per 1,000 | US$ 1.50 | US$ 1.43 | US$ 1.35 | US$ 1.28 |
| Calendar date delivered, per 1,000 | US$ 1.00 | US$ 0.95 | US$ 0.90 | US$ 0.85 |

No start fee and no monthly fee. Price insight rows, input checks and error rows are free.

- **43 fields across the three row types** (28 on a flight row, plus 8 more with price tracking), all in the [output fields](#output-fields).
- **Booking link per flight:** `bookingUrl` opens Google Flights with that flight selected, showing the airline and travel agency offers at the price in the row
- **Price alerts:** `alertBelowPrice` and `onlyPriceDrops` deliver, and charge, only fares below your target or cheaper than in the previous run
- **Price calendar:** cheapest price per departure date, up to ~290 dates per route in one run
- **Price insight:** typical price range, low/typical/high, ~60 days of history, free
- **Routes:** airport or city codes, several origins × destinations × dates in one run
- **Filters:** cabin, adults, children, max stops, airlines, currency, country
- **Free input checks:** past dates, unknown airport codes and a return before departure are free rows with an `errorCode`, and the rest of the input still runs

### What data the Google Flights scraper returns

Run on 2026-10-14, JFK to LHR, one way, 2 adults, airline BA. The booking link was opened in a browser: Google Flights showed "Book with British Airways, $735", the same total as the row.

```json
{
  "type": "flight",
  "origin": "JFK",
  "destination": "LHR",
  "departureDate": "2026-11-28",
  "price": 735,
  "currency": "USD",
  "isBest": true,
  "airlines": ["British Airways"],
  "stops": 0,
  "legs": [{ "flightNumber": "BA 178", "from": "JFK", "to": "LHR" }],
  "bookingUrl": "https://www.google.com/travel/flights/booking?tfs=CBwQAho_EgoyMDI2LTExLTI4Ih8KA0pGSxIKMjAyNi0xMS0yOBoDTEhSKgJCQTIDMTc4MgJCQWoFEgNKRktyBRIDTEhSQAFAAUgBmAEC&hl=en&gl=us&curr=USD"
}
```

**Calendar date** (round trip of 7 days, run on 2026-09-30, the cheapest of 288 dates):

```json
{ "type": "calendar_day", "origin": "NYC", "destination": "LON", "departureDate": "2026-11-09", "returnDate": "2026-11-16", "tripLengthDays": 7, "price": 429, "currency": "USD" }
```

**Price insight** for a search: `{"lowestPrice": 733, "typicalPriceLow": 490, "typicalPriceHigh": 670, "priceLevel": "high", "flightsFound": 31}`, with 61 days of `priceHistory`.

### Google Flights booking links

- **One way:** `bookingUrl` opens the Google Flights booking page of that flight, with the offers from the airline and travel agencies. In our tests the airline offer matched the row price (US$ 295 for a JetBlue nonstop, US$ 319 for a two-leg ITA flight, US$ 735 for 2 adults on British Airways).
- **Round trip:** Google prices the outbound flight with the whole trip. `bookingUrl` opens Google Flights with that outbound flight already chosen, on the screen where you pick the return; the cheapest return shown there gives the row price.
- The link carries the passengers, cabin, currency and country of your input, so the price on screen is for the same trip. Fares move during the day, so a link opened hours later can show a new price.
- `googleFlightsUrl` is the search page for the route and date, also on every calendar row.

### Google Flights price alerts: pay only for the fares you want

Set a target and schedule the run. Every fare is checked, but only the ones that pass are saved and charged.

| Input | What is delivered and charged |
|---|---|
| `alertBelowPrice: 400` | Flights and calendar dates priced below 400 in your currency |
| `onlyPriceDrops: true` | Flights and dates cheaper than in the previous run, plus new flights cheaper than anything that search had before. The first run of a search is the baseline |
| both | Below 400 **and** new or cheaper than last time: you pay once when a fare crosses your target, and again only if it drops further |

```json
{ "origins": ["JFK"], "destinations": ["LHR"], "departureDates": ["2026-12-08"], "tripLengthDays": 7, "includePriceCalendar": true, "calendarDays": 30, "alertBelowPrice": 700, "onlyPriceDrops": true }
```

Each delivered row says why in `alertReason`: `below_target`, `price_drop`, `new_cheaper_option` or `first_run`, with `previousPrice` and `priceChange`. A search where nothing passes returns one free row:

```json
{ "type": "error", "errorCode": "NO_PRICE_ALERT", "error": "15 flights checked: 14 at or above your target 700 USD, 1 not cheaper than in the previous run (not charged)", "cheapestPriceSeen": 697 }
```

Save the input as a Task with **fixed dates** and attach a daily Schedule. Add a webhook or an integration (email, Slack) on "run succeeded" and the dataset only has rows when there is news.

### What you can do with Google Flights data

- **Fare alerts:** a daily Task that only charges when a route drops under your budget.
- **Find the cheapest dates:** one calendar run shows the whole season for a route. Sort by price.
- **Travel content and deal sites:** "cheapest month to fly to London" pages from real data, with a booking link per fare.
- **Airline and route analysis:** who flies the route, with how many stops, on which aircraft, at what price and CO2.

### Google Flights scraper input

| Field | What it does |
|---|---|
| `origins`, `destinations` | 3-letter airport or city codes (JFK, NYC, LHR, LON). Every origin is combined with every destination |
| `departureDates` | `YYYY-MM-DD` or a number of days from today (`30`) |
| `tripLengthDays` | 0 = one way; 7 = return 7 days later (flights and calendar) |
| `returnDate` | Fixed return date for the flight search (optional) |
| `scrapeFlights` | Flight rows (default on) |
| `includePriceCalendar`, `calendarDays` | Cheapest price per departure date, from the earliest departure date, up to 330 days |
| `adults`, `children`, `cabinClass`, `maxStops` | Filters. Prices are the total for all passengers |
| `airlines` | Only flights where every leg is flown by these airlines (BA, AA, LH) |
| `currency`, `country`, `language` | USD, EUR, GBP...; the Google Flights site country; names language |
| `maxFlightsPerSearch` | Default 50 (Google shows up to ~40 per route and date) |
| `alertBelowPrice`, `onlyPriceDrops` | Price alerts, see above |
| `compareWithPreviousRun`, `onlyChanged` | Price tracking between runs, see below |

```json
{ "origins": ["NYC"], "destinations": ["LON", "PAR"], "departureDates": ["30"], "tripLengthDays": 7, "includePriceCalendar": true, "calendarDays": 180, "currency": "USD" }
```

### Free input checks

Every value is checked before any search. A bad value becomes one free row with an `errorCode` and a message that says what to fix, and the rest of the input still runs. Nothing is charged for these rows.

- `"departureDates": ["2026-01-10"]` gives `PAST_DATE`: "the departure date 2026-01-10 is in the past (today is 2026-10-14 UTC); use a future date, or a number of days from today such as 30 so a saved Task never goes stale".
- `"returnDate": "2026-11-01"` with a departure on 2026-11-28 gives `RETURN_BEFORE_DEPARTURE`, and only that date is skipped.
- `QQQ` gives `INVALID_AIRPORT`: "Google Flights does not recognize QQQ as an airport or city code".
- `2026-02-30` gives `INVALID_DATE`, a date over 331 days ahead gives `DATE_TOO_FAR`.

Tip: in a saved Task, use a number of days (`30`) instead of a fixed date, unless the Task is a price monitor.

### Track Google Flights prices between runs

`compareWithPreviousRun` keeps the last price of every flight and calendar date in a key-value store on your own account, `google-flights-scraper-price-history`, and adds to each row `previousPrice`, `previousSeenAt`, `priceChange`, `priceChangePct`, `isNew`, `isNewLowest`, `lowestSeenPrice` and `firstSeenAt`.

- `onlyChanged` delivers, and charges, only new rows and fare changes up or down. A search with no change returns one free row with `errorCode: NO_PRICE_CHANGES`.
- A flight is matched by its flight numbers and times, one record per route and dates; a calendar date by its departure and return dates, one record per route, so the calendar keeps tracking the same dates as the window moves forward.
- A relative date such as `30` moves every day, so every run is a new flight search; use fixed dates for a monitor. Rows that leave the result stay in the history for 90 days.

<a id="output-fields"></a>

### Google Flights output fields

- **Flight rows (`type: "flight"`):** `price`, `currency`, `isBest`, `airlines`, `stops`, `durationMinutes`, `departureAirport`, `arrivalAirport`, `departureTime`, `arrivalTime`, `layovers`, `legs` (`flightNumber`, `airline`, `from`, `to`, `departure`, `arrival`, `durationMinutes`, `aircraft`, `legroom`), `co2Grams`, `co2TypicalGrams`, `co2DiffPercent`, `bookingUrl`, `googleFlightsUrl`.
- **Calendar rows (`type: "calendar_day"`):** `departureDate`, `returnDate`, `tripLengthDays`, `price`, `currency`, `googleFlightsUrl`.
- **Price insight rows (`type: "price_insight"`, free):** `lowestPrice`, `typicalPriceLow`, `typicalPriceHigh`, `priceLevel`, `priceHistory`, `flightsFound`.
- **With alerts or tracking:** `alertReason`, `alertBelowPrice`, `previousPrice`, `priceChange`, `priceChangePct`, `isNew`, `isNewLowest`, `lowestSeenPrice`, `firstSeenAt`, `previousSeenAt`.

#### Error codes (never charged)

| errorCode | Meaning |
|---|---|
| `PAST_DATE`, `INVALID_DATE`, `DATE_TOO_FAR` | A departure date in the past, not a real date, or more than 331 days ahead |
| `RETURN_BEFORE_DEPARTURE` | The fixed return date is before that departure date |
| `INVALID_AIRPORT` | Not a 3-letter code, or a code Google Flights does not know |
| `NO_FLIGHTS`, `NO_CALENDAR` | Google Flights has nothing for this route and date (or for your airline and stops filters) |
| `NO_PRICE_ALERT` | Every fare was checked and none passed your price alert; `cheapestPriceSeen` says how close it got |
| `NO_PRICE_CHANGES` | With `onlyChanged`: nothing is new or changed since the previous run |
| `BLOCKED` | Google blocked the request on several IPs; run again |
| `NOT_REACHED`, `UNEXPECTED` | The run timeout arrived, or something unforeseen broke; only that search is lost |

### Google Flights scraper pricing

Prices per plan are in [At a glance](#at-a-glance). On the Free plan, a daily alert on one route that finds 3 fares under your target costs US$ 0.0045 that day, and a day with nothing under the target costs nothing. A 180 date calendar costs US$ 0.18, and 40 flights cost US$ 0.06. Price insight, input check and error rows are free, and there is no Apify compute bill on top.

### Integrations, scheduling and AI agents

Video guides from Apify: [how to schedule an Actor](https://www.youtube.com/watch?v=1jI7WcVQmwM) and [how to connect it to other apps](https://www.youtube.com/watch?v=bNACk1_S_6w).

- **Schedule** a Task with fixed dates and `alertBelowPrice` or `onlyPriceDrops` in [Apify schedules](https://docs.apify.com/platform/schedules): the dataset only has rows when a fare is worth your attention.
- **Export** as JSON, CSV, Excel, XML or HTML, or read the dataset from the [Apify API](https://docs.apify.com/api/v2).
- **Connect** it to Make, n8n, Zapier, Google Sheets, Slack, email or a webhook through [Apify integrations](https://docs.apify.com/platform/integrations), for example a Slack message when a route drops under your budget.
- **AI agents:** the Actor works as a tool through the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp) in Claude, ChatGPT, Cursor and other MCP clients, for example "find the cheapest week in December to fly from New York to Lisbon".
- **API call:** `scrapewise/google-flights-scraper` with the Apify API or the Python and JavaScript clients.

### Google Flights scraper FAQ

**Do I need a Google account or an API key?**
No. The Actor reads public Google Flights pages.

**Is there an official Google Flights API?**
No. Google Flights has no public API; Google closed its flight search API (QPX Express) in 2018. This Actor reads the public Google Flights pages and returns prices, legs, CO2, a booking link per flight and the price calendar.

**Is the price the same one I see on Google Flights?**
Yes, at the time of the run, for the passengers, cabin, currency and country in your input. In our tests the booking link opened with the same total as the row. Fares move during the day.

**How do I find the cheapest day to fly?**
Turn on `includePriceCalendar`, set `calendarDays` (up to 330) and sort the `calendar_day` rows by `price`.

**Can I get multi-city itineraries?**
No. One way and round trip only, from any number of origins, destinations and dates in one run.

**Does it return the airline or agency checkout page?**
No. `bookingUrl` opens Google Flights on that flight, with the airline and agency offers; the purchase happens on the site you choose there.

### Google Flights scraper limitations

- On round trips, Google lists the outbound flights with the **total round trip price**. Return flight options are chosen on Google's next screen, which is where the round trip `bookingUrl` lands.
- The booking link opens Google Flights; the final purchase happens on the airline or agency site that you choose there.
- The calendar goes up to about 324 days from today, the limit of Google's own date grid. The airline filter applies to flight rows, not to the calendar.
- Prices are what Google Flights shows at the time of the run. This Actor reads public pages only.

### Related scrapers

- [Google Hotels Search Scraper](https://apify.com/scrapewise/google-hotels): hotel prices by booking site from Google Hotels.
- [Booking.com Scraper](https://apify.com/scrapewise/booking-scraper): hotel prices, availability and reviews.
- [GetYourGuide Scraper](https://apify.com/scrapewise/getyourguide-scraper): tours, prices, ratings and duration.
- [Viator Scraper](https://apify.com/scrapewise/viator-scraper): tours, prices, ratings and duration.
- [Trip.com and Ctrip Hotel Reviews Scraper](https://apify.com/scrapewise/tripcom-hotel-reviews): hotel reviews from Trip.com and Ctrip.

### Changelog

- **16 Oct 2026:** price per plan in At a glance, integrations and FAQ on this page; the pricing section no longer lists a start fee the Actor does not charge.
- **2026-10-14, 0.2: Real booking links, price alerts below your target, friendly date errors.** `bookingUrl` on every flight (tested to open with the same price), `alertBelowPrice` and `onlyPriceDrops` for alerts that charge only the fares you want, `airlines` filter, `googleFlightsUrl` on calendar rows, and free per-value input checks (`PAST_DATE`, `RETURN_BEFORE_DEPARTURE`, `INVALID_AIRPORT`, `INVALID_DATE`, `DATE_TOO_FAR`) instead of stopping the whole run.
- **2026-10-04:** price tracking between runs with `compareWithPreviousRun` and `onlyChanged`.
- **2026-09-30, 0.1:** first release. Flights with legs, layovers and CO2, price calendar up to ~10 months, free price insight rows, city codes, any currency.

# Actor input Schema

## `origins` (type: `array`):

Departure airports or cities as 3-letter IATA codes, one per line, for example JFK (one airport) or NYC (every New York airport). Several are allowed: every origin is combined with every destination and every date, and each combination is one search. Also accepts 'origin' and 'from'.

## `destinations` (type: `array`):

Arrival airports or cities as 3-letter IATA codes, one per line, for example LHR, LON (all London airports), LIS or TYO. Also accepts 'destination' and 'to'.

## `departureDates` (type: `array`):

Departure dates, one per line, as YYYY-MM-DD (2026-12-15) or a number of days from today (30 = in 30 days, handy for saved Tasks that run every day). Each date is a separate flight search. Also accepts 'departureDate' and 'outboundDate'.

## `tripLengthDays` (type: `integer`):

0 (default) = one way. Any other number makes it a round trip returning that many days after departure, for example 7, from 1 to 60. Also used by the price calendar, so each calendar date is priced as a round trip of this length.

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

Optional fixed return date for a round trip, as YYYY-MM-DD, for example 2026-12-22. Overrides 'Round trip: days until return' for the flight search; the price calendar keeps using the trip length.

## `scrapeFlights` (type: `boolean`):

On (default): one row per flight for each route and date, with price, airlines, flight numbers, stops, legs, times, duration and emissions, charged as 'Flight delivered'. Turn off to get only the price calendar.

## `includePriceCalendar` (type: `boolean`):

Off (default). On: adds the cheapest price for every departure date, as in the Google Flights date grid, up to about 10 months ahead. One row per date, charged as 'Calendar date delivered'. Useful to find the cheapest day to fly.

## `calendarDays` (type: `integer`):

How many departure dates the price calendar covers, starting from the earliest departure date, from 7 to 330 (default 90). Google shows prices up to about 324 days from today. Each date is one charged row.

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

Number of adult passengers, from 1 (default) to 9. Prices are the total for all passengers.

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

Number of children aged 2 to 11, from 0 (default) to 8. Prices include them.

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

Cabin class to price: Economy (default), Premium economy, Business or First.

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

Maximum number of stops: Any (default), Nonstop only, 1 stop or fewer, or 2 stops or fewer. Applies to the flights and to the calendar.

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

Only flights where every leg is flown by one of these airlines, as 2-letter IATA codes, for example BA, AA or LH. Leave empty for all airlines. Applies to flight rows; the price calendar always covers all airlines.

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

Maximum flights per route and date, default 50. Google shows up to about 40 flights per search, so the default returns all of them. Lower it, for example to 5, to get only the best and cheapest options and pay less.

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

3-letter currency code for every price, for example USD (default), EUR, GBP, BRL, INR or JPY.

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

2-letter country code of the Google Flights site, for example us (default), gb, de or br. It can change availability and some prices, as fares sold in different markets differ.

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

Language code for airport and airline names, for example en (default), de, es or pt-BR.

## `alertBelowPrice` (type: `integer`):

Optional target price in the chosen currency, for example 400. Only flights and calendar dates priced below it are saved and charged; the rest are checked for free. A search with nothing below the target returns one free row with errorCode NO_PRICE_ALERT and the cheapest price seen. Leave empty to get every fare.

## `compareWithPreviousRun` (type: `boolean`):

Keeps the last price of every flight and calendar date in a key-value store on your account ('google-flights-scraper-price-history', one record per search: route, dates, cabin, passengers, stops and currency) and adds to each row: previousPrice, priceChange, priceChangePct, isNew, isNewLowest (lowest price ever seen), lowestSeenPrice, firstSeenAt and previousSeenAt. On the first run everything is new. Save the input as a Task with fixed dates and schedule it daily to get a price monitor.

## `onlyChanged` (type: `boolean`):

With 'Compare prices with the previous run' on: rows whose price did not move since the previous run are not saved and not charged, and the maximum still counts the flights checked per search, so a daily run costs the same and you pay only for the rows you get. A search where nothing changed returns one free row with errorCode NO_PRICE_CHANGES.

## `onlyPriceDrops` (type: `boolean`):

Turns on 'Compare prices with the previous run' and delivers, and charges, only flights and calendar dates that got cheaper since the previous run, plus new flights cheaper than anything that search had before. The first run of a search is the baseline and delivers everything (or everything below your price alert). With a price alert, a fare is delivered once when it goes below the target and again only if it drops further. Each row says why in alertReason.

## `proxyConfiguration` (type: `object`):

Apify Proxy (datacenter) is the default and recommended. When Google keeps blocking a session, the Actor switches to Apify residential proxies on its own, with no extra charge. Change it only to use your own proxies.

## Actor input object example

```json
{
  "origins": [
    "JFK"
  ],
  "destinations": [
    "LHR"
  ],
  "departureDates": [
    "30"
  ],
  "tripLengthDays": 0,
  "scrapeFlights": true,
  "includePriceCalendar": false,
  "calendarDays": 90,
  "adults": 1,
  "children": 0,
  "cabinClass": "economy",
  "maxStops": "any",
  "maxFlightsPerSearch": 50,
  "currency": "USD",
  "country": "us",
  "language": "en",
  "compareWithPreviousRun": false,
  "onlyChanged": false,
  "onlyPriceDrops": false,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

No description

## `resultsCsv` (type: `string`):

No description

# 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 = {
    "origins": [
        "JFK"
    ],
    "destinations": [
        "LHR"
    ],
    "departureDates": [
        "30"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapewise/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 = {
    "origins": ["JFK"],
    "destinations": ["LHR"],
    "departureDates": ["30"],
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("scrapewise/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 '{
  "origins": [
    "JFK"
  ],
  "destinations": [
    "LHR"
  ],
  "departureDates": [
    "30"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call scrapewise/google-flights-scraper --silent --output-dataset

```

## MCP server setup

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