# Google Flights Scraper & Price Tracker API - Fare Alerts (`akhil_rajesh/google-flights-scraper`) Actor

Google Flights scraper and price tracker: fares, cheapest day to fly, stops, airlines, CO2 and price history for any route and dates. Google Flights price drop alerts in Slack, Discord, Teams or Telegram. Google Flights API and MCP server for AI agents. Residential proxy included, no login.

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

## Pricing

from $0.70 / 1,000 results

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 & Price Tracker API

**Google Flights Scraper & Price Tracker** is an Apify Actor that works as a Google Flights API, a fare-drop alert tool and an MCP server for AI agents. Scrape **Google Flights** fares for any route and date without a login or API key: every itinerary Google lists with its **price, airlines, flight numbers, times, stops, layovers, duration and emissions**, plus each search's **cheapest fare, Google's price level (low, typical or high), its typical price range and about 60 days of price history**. Search a range of dates in one run to find the cheapest day to fly.

It is also a **flight price tracker**. Schedule it with **Only changes** and each run returns only what moved since the last one: **price drops, fares under your target price, price rises and new flights**, posted to **Slack, Discord, Microsoft Teams or Telegram** if you like. It runs as a **live API and MCP server** for AI agents too.

### Why this scraper

- **It tracks fares, not just today's prices.** Each route and date keeps its own history: a run reports a drop once, against the price it last reported, and a slow slide is reported once it adds up to your minimum change (1% unless you set it).
- **Target prices that don't nag.** Set a target and a fare at or under it is reported once, then again only after it has gone back above the target and come down again.
- **Routes as you'd type them.** "Toronto to London", "YYZ-LHR", "NYC to Tokyo", or a Google Flights link. Dates as `2026-12-10`, ranges (`2026-12-10 to 2026-12-14`) or relative (`in 30 days`, `in 2 weeks`), so a schedule always searches ahead.
- **Residential proxy included.** Google Flights withholds flight data from cloud servers' addresses about half the time. The Actor reads it through its own residential proxy, one address for the whole run, and its cost is in the search price: there's no proxy in your bill and nothing to set up.
- **Clear about what it didn't read.** A search Google didn't answer is named in the status message, a place Google Flights doesn't know gets a free row with Google's suggestions, and a run that read nothing fails without charging.
- **Works with other Google Flights Actors' inputs.** The input forms of four popular Google Flights scrapers are read as they are (origin and destination fields, `departure_id` / `arrival_id`, a `searches` list, `departDaysAhead`), so you can switch with the same JSON.

### Use cases

- **Fare alerts**: a schedule every few hours for your trip that posts to Slack, Discord or Telegram when the fare drops or falls under your target.
- **The cheapest day to fly**: a route over a range of dates (`2026-12-10 to 2026-12-20`), one way or with a 7-day trip; each date's search row has its cheapest fare.
- **Travel and deal sites**: fares, price levels and Google's typical range for many routes, refreshed daily.
- **Airline and route research**: which airlines fly a route, nonstop or not, how long it takes and what it costs across dates.
- **Corporate travel**: watch the routes your team flies and get told when fares are low.
- **AI agents**: ask an assistant "what's the cheapest nonstop from Toronto to London in December?" through the MCP server.

### How to use it in 4 steps

1. Type one or more **Routes** ("New York to London") and **Departure dates** ("in 30 days", or a date or a range).
2. For a round trip, set a **Return date** or a **Trip length**. Pick passengers, cabin, stops and airlines if you like.
3. Set **Flights per search** and **Sort flights by** if you like.
4. Run it. For a tracker, tick **Only changes**, add a target price or an alert webhook, and schedule it.

### What you get

Each search gives one **search** row and its **flight** rows. Views split them into Overview, Flights and Changes tables.

A **search** row (one route on one departure date):

```json
{
  "type": "search",
  "route": "YYZ to London, United Kingdom",
  "departureDate": "2026-12-10",
  "tripType": "oneWay",
  "maxStops": "nonstop",
  "currency": "USD",
  "flightsFound": 7,
  "cheapestPrice": 331,
  "cheapestFlight": {"flightNumbers": ["TS 122"], "airlines": ["Air Transat"], "departs": "2026-12-10T21:35",
                     "arrives": "2026-12-11T09:45", "stops": 0, "durationMinutes": 430},
  "cheapestNonstopPrice": 331,
  "shortestDurationMinutes": 425,
  "priceLevel": "low",
  "typicalPrice": 484,
  "typicalPriceLow": 335,
  "typicalPriceHigh": 890,
  "priceHistory": [{"date": "2026-09-11", "price": 341}, "..."],
  "airlinesOffered": [{"code": "A3", "name": "Aegean"}, {"code": "EI", "name": "Aer Lingus"}, "..."],
  "googleFlightsUrl": "https://www.google.com/travel/flights?q=Flights+to+London%2C+United+Kingdom+from+YYZ+on+2026-12-10+one+way+nonstop&curr=USD&hl=en&gl=US"
}
```

A **flight** row (one itinerary): `rank`, `price` (for all passengers), `pricePerAdult`, `airlines`, `flightNumbers`, `from`, `to`, `departs`, `arrives`, `arrivesNextDay`, `durationMinutes`, `stops`, `layovers` (airport, length, overnight, change of airport), `legs` (each flight with its airports, times, aircraft, legroom and the airline that operates it), `alsoSoldAs` (codeshares), `emissionsGrams`, `emissionsVsTypicalPercent` and `isBest` (among Google's best flights). The first row of that search: TS 122 from YYZ to LGW, $331, an Airbus A321neo with 31 inches of legroom, also sold as Porter Airlines.

With **Only changes**, each reported row also has `change` (`priceDrop`, `priceRise`, `belowTarget`, `newFlight`, or `firstRun` on a tracker's first run), `previousPrice`, `priceChange`, `priceChangePercent`, `lowestPriceSeen` and `isLowestPriceSeen`.

A **notFound** row (free) names a place Google Flights doesn't know, with what its place lookup offered instead.

### How to use it

#### Routes and dates

- **Routes**: one per line, as "From to To". Each end can be a city ("London" means all its airports) or an airport code. Up to 50 routes and 100 searches a run.
- **Departure dates**: dates (`2026-12-10`), ranges (`2026-12-10 to 2026-12-14`, up to 31 days) or relative dates (`in 30 days`, `in 2 weeks`, `in 3 months`, `tomorrow`). Each route is searched on each date. Google Flights lists flights about 330 days ahead; earlier or later dates are skipped and named.
- **Return date** or **Trip length (days)**: a round trip. A trip length works with every departure date.
- **Google Flights links**: paste a search link from Google Flights; its route, dates, currency and country are used.

#### Passengers, cabin and filters

Adults and children; economy, business or first; any number of stops, nonstop only, 1 stop or fewer, or 2 stops or fewer; airlines to keep (codes such as `DL`) or to leave out. Filters for a maximum price, duration, layover, and departure or arrival times apply to the flight rows and to each search's cheapest fare; `flightsMatchingFilters` says how many passed.

#### Output

**Flights per search** (20 unless you set it, up to 300: Google lists up to about 300) and **Sort flights by** (price, Google's best order, duration, departure, arrival or emissions). **Max results** (1,000 unless you set it) caps the run's rows and is shared fairly between searches.

#### Paused for now

Since November 16, 2026, Google Flights asks every request to its data call for a browser check, which this Actor doesn't pass. The Actor reads each search from the page a visitor opens instead, so a few options are paused until that changes: the **price calendar**, **infants**, **premium economy**, **alliances**, **several places on one side** and **a country** as a destination. A run that asks for infants, premium economy or an alliance is refused before any search, so it costs nothing; one that asks for the others says so and searches the rest, and nothing is charged for what wasn't searched. "1 stop or fewer", "2 stops or fewer" and airline codes still work: the page is searched with every flight, and the ones that don't match are left out (the status says so). The Actor checks every week whether the data call answers again.

#### Market

**Currency** (USD unless you set it), **Country** (the market Google prices for) and **Language**.

### Tracking fares on a schedule (Google Flights price tracker)

Tick **Only changes** and schedule the Actor (every few hours, or daily). The first run saves each search's fare as the baseline and returns it marked `firstRun`; later runs return only changes:

- `priceDrop` and `priceRise`: a move of at least **Minimum price change (%)** (1 by default) since the price last reported; smaller moves don't move the baseline, so a slow slide is reported once it adds up.
- `belowTarget`: a fare at or under your **Target price**, once, until it goes back above it.
- `newFlight`: an itinerary Google hadn't listed for this search before.

Pick which ones to report in **Changes to report** (price drops and fares under your target unless you set it). Track **fixed dates** (`2026-12-10`, or a range): a relative date such as "in 30 days" is a new departure day every day, so each day's run is that date's first run. Each search keeps its own history in a named store (`google-flights-history`, or the **History name** you give), so several schedules can share it without overwriting each other. Rows are charged only when they are returned, so a tracker that finds nothing new costs only its searches.

### Alerts in Slack, Discord, Microsoft Teams or Telegram

Paste an incoming-webhook URL in **Alert webhook URL** (Slack, Discord, Microsoft Teams, or any HTTPS endpoint that takes JSON, such as Zapier, Make or n8n), or a **Telegram bot token** and **chat id**. Either switches on Only changes. The first run posts one short "alerts are set up" message; each later run posts its changes, up to 50 a run, most important first, each with the fare, the move, the flight and a Google Flights link. The URL and the token are treated as secrets and masked in logs. If posting fails, the run still succeeds and its status says why.

### Run summary for pipelines

Each run saves a `RUN_SUMMARY` record in its key-value store: rows by type, the changes, the run's cheapest fare, what wasn't found or didn't load and why, the searches with no flights, and the notes on your input.

### Google Flights API: use it from code or from an AI assistant

Run the Actor through Apify's API and read the dataset, as with any Actor:

```bash
curl -X POST "https://api.apify.com/v2/acts/akhil_rajesh~google-flights-scraper/run-sync-get-dataset-items?token=<YOUR_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"routes": ["Toronto to London"], "departureDates": ["in 30 days"], "maxFlightsPerSearch": 5}'
```

#### For AI agents: MCP server and live API

The same code runs as a live endpoint that answers in seconds, with no run to wait for: [Google Flights MCP Server & API](https://apify.com/akhil_rajesh/google-flights-mcp-server), at the same prices.

- **MCP server** at `https://akhil-rajesh--google-flights-mcp-server.apify.actor/mcp` (send your Apify token as `Authorization: Bearer <token>`), with 3 tools: `search_flights` (a route on one or more dates, with every filter), `find_airport` (what a city or airport name means to Google Flights; free) and `run_actor` (the whole input above).
- **HTTP API** at the same host: `GET /flights?from=YYZ&to=London&dates=2026-12-10`, `GET /airports?q=london` (free) and `POST /run` with this Actor's input. `GET /` lists every parameter.

A request reads up to 10 searches (3 per MCP tool call) and returns the rest as `notRead`, to send in another request. Tracking and alerts need a scheduled run. Agents that pay per call (x402, Skyfire) can run this Actor through `https://mcp.apify.com` instead, as a normal run per call.

### How much does it cost?

You pay **$6.00 per 1,000 searches** and **$1.00 per 1,000 results**, plus a start fee of $0.00005 per run. A search is one route on one departure date, charged once when Google Flights' page for it is read, whatever it lists: each one is a page load through the residential proxy. A result is a flight row or a search row with flights; notFound rows are free, and a search that didn't load isn't charged. **Platform usage and the residential proxy are included** in runs of the Actor. The live endpoint ([Google Flights MCP Server](https://apify.com/akhil_rajesh/google-flights-mcp-server)) charges at the same prices, plus the Standby run's platform usage while it serves you.

| Apify plan | Per 1,000 searches | Per 1,000 results |
|---|---|---|
| Free | $6.00 | $1.00 |
| Starter | $6.00 | $0.90 |
| Scale | $6.00 | $0.80 |
| Business and above | $6.00 | $0.70 |

| Run | Searches | Results | Cost (Free plan) |
|---|---|---|---|
| One route on one date, 20 flights | 1 | 21 | about $0.03 |
| 5 routes on 7 dates, 10 flights each | 35 | 385 | about $0.60 |
| One route over 30 dates, 5 flights each (the cheapest day) | 30 | 180 | about $0.36 |
| A tracker of 3 routes twice a day, a few changes a run | 6 a day | about 10 a day | about $0.05 a day |

To cap spending, lower Flights per search or Max results, or set a maximum cost per run in the run options; the Actor stops cleanly at the limit.

### Good to know

- Prices are Google Flights' prices for the market, currency and passengers asked for, as a visitor sees them; they can change between a run and a booking.
- Booking options (which sellers offer a fare, and their links) aren't read: Google's robots rules close those pages to crawlers. Each row links its Google Flights search, where the booking options are one click away.
- Multi-city trips, Explore (anywhere) and bag fees aren't covered. A rival input asking for them is searched without them, and the status says so.
- A place Google Flights doesn't know isn't guessed: it gets a free notFound row with Google's suggestions.
- Each search is read from its own Google Flights page, the one a visitor opens, after checking that the page read the same search in the currency asked for. The options that page can't say are paused or applied to the rows (see Paused for now); a search that can't be read is named in the status and isn't charged. The run summary counts the searches read and charged (`searchesReadFromPage`, `chargedSearches`).
- The Actor asks Google about once every 3 seconds. After a burst of searches Google can refuse a server's address for several minutes (its "unusual traffic" page). A run then waits, asking again once a minute for up to 10 minutes, and says so in its status; it keeps the same address. The live API and MCP server answer at once instead, naming what Google refused.

### FAQ

**Is there a Google Flights API?** Google has no public Google Flights API: its QPX Express API for airfares closed in 2018. This Actor works as one. Call it through Apify's REST API (`run-sync-get-dataset-items` returns the flights as JSON), or through the live HTTP endpoint of its MCP server listing (`GET /flights?from=JFK&to=LAX&dates=2026-12-10`), from any language.

**Is there a Google Flights MCP server?** Yes: [Google Flights MCP Server](https://apify.com/akhil_rajesh/google-flights-mcp-server), at `https://akhil-rajesh--google-flights-mcp-server.apify.actor/mcp`, with the tools `search_flights`, `find_airport` and `run_actor`. Add it to Claude, Cursor or any MCP client with your Apify token as a Bearer header, then ask for fares in plain language.

**How do I get Google Flights price drop alerts?** Schedule the Actor with **Only changes** on, and add a Slack, Discord or Teams webhook or a Telegram bot. Each run then posts only price drops, fares under your **Target price**, and (if you ask) rises and new flights.

**How do I find the cheapest day to fly?** Give a route a range of departure dates (`2026-12-10 to 2026-12-20`) and sort by price: each date's search row has its cheapest fare, and the status names the run's cheapest.

**How much does it cost to scrape Google Flights?** $6.00 per 1,000 searches plus $1.00 per 1,000 results, with the residential proxy and platform usage included. One route on one date with 20 flights costs about $0.03.

**Can I scrape Google Flights with Python?** Yes, with the `apify-client` package: `ApifyClient(token).actor("akhil_rajesh/google-flights-scraper").call(run_input={"routes": ["Toronto to London"], "departureDates": ["in 30 days"]})`, then read the run's dataset.

**Does it show Google Flights price history?** Each search row has Google's price level, its typical price range and about 60 days of the route's price history as Google shows it. With Only changes, the Actor also keeps its own history of the fares it reported, with the lowest price seen.

**Is it legal to scrape Google Flights?** The Actor reads the public fares a visitor sees, at a modest pace, and leaves out the pages Google's robots rules close. Check the laws and terms that apply to how you use the data.

**Do I need a proxy?** No. The Actor uses its own residential proxy, included in the price. Your own proxy URLs are used instead if you give them; an Apify Proxy setting isn't, since the Actor's own proxy is the one it was tested through.

**Why does my run show fewer flights than Google Flights?** Flights per search is 20 unless you set it; Google lists up to about 300. Filters and Max results also cut what's returned.

**How do I get round-trip prices?** Set a Return date or a Trip length. A round trip's price is for the whole trip, as Google shows it for the outbound flights.

**Can it watch one exact flight?** Yes: track the search with Changes to report set to price drops, and narrow it with Airlines, departure times or Stops; the search row's cheapest fare then follows the flights you care about.

### Other Actors by this developer

- [Google Flights MCP Server & API - Live Fares for AI Agents](https://apify.com/akhil_rajesh/google-flights-mcp-server): the same Google Flights data as a live MCP server and HTTP API for AI agents, answering in seconds
- [Indeed Jobs MCP Server & API - 62 Countries](https://apify.com/akhil_rajesh/indeed-jobs-mcp-server): Indeed job search for AI agents and apps: a live MCP server and HTTP API over Indeed's 62 country sites, answering in seconds with pay, full descriptions, employer details and apply links
- [Google Hotels Scraper - Hotel Price Tracker & Comparison](https://apify.com/akhil_rajesh/google-hotels-scraper): hotel prices from Google Hotels, with price tracking
- [Google Trends Scraper & API - Trending Now, Pinterest Trends](https://apify.com/akhil_rajesh/google-trends-scraper): Trending Now in 125 countries, interest over time, by region and rising searches without a login or API key, plus Pinterest Trends and Slack, Discord, Telegram or Teams alerts for new trends
- [Zillow Price Tracker & Scraper](https://apify.com/akhil_rajesh/zillow-price-tracker): US homes for sale, sold and for rent, with price cuts, agents and change tracking
- [Amazon.ca Product & Trending Tracker](https://apify.com/akhil_rajesh/amazon-ca-product-trending-tracker): Amazon Best Sellers, prices, search positions and reviews on 23 marketplaces, with change tracking
- [AliExpress Price Tracker & Scraper](https://apify.com/akhil_rajesh/aliexpress-price-tracker): AliExpress search results with store prices, units sold and price history
- [YouTube Channel Scraper & Tracker](https://apify.com/akhil_rajesh/youtube-channel-scraper): exact subscribers, total views and video counts of YouTube channels without a login or API key, plus new videos and growth with Slack, Discord or Teams alerts

### Disclaimer

This Actor is an independent tool. It is not affiliated with, endorsed by or sponsored by Google. It reads publicly available fares at a modest pace. Use the data in line with Google's terms and the laws that apply to you.

# Changelog

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

# Actor input Schema

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

One route per line: 'New York to London' or 'YYZ to LHR'. Cities (all their airports) and airports (IATA codes) work, as in Google Flights' own search box. Countries ('Toronto to Japan') and several places on one side ('YYZ/YTZ to LHR') are paused since 2026-11-16: Google Flights asks its data call for a browser check, which this Actor doesn't pass. At most 50 routes.

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

One per line: a date (2026-12-10), a range of up to 31 days (2026-12-10 to 2026-12-14), or a date counted from the run's day ('in 30 days', '2 weeks', '3 months'). Every route is searched on every date (at most 100 searches a run). Google Flights lists flights from today to about 11 months ahead. Leave empty for flights in 30 days. For Only changes, use fixed dates: 'in 30 days' is a new date each day.

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

For a round trip with one departure date: the return date (2026-12-20, or 'in 37 days'). Leave empty for one way. With several departure dates, use Trip length instead.

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

For round trips: return this many days after each departure date (7 for a week). Leave empty for one way.

## `googleFlightsUrls` (type: `array`):

Optional: Google Flights search links with a 'q=' search, such as the googleFlightsUrl of this Actor's rows (https://www.google.com/travel/flights?q=Flights+to+LHR+from+YYZ+on+2026-12-10). Their dates, currency and country are used for that route.

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

Adults (default 1). Prices are for all passengers together, as Google Flights shows them; rows with several adults also give the price per adult.

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

Children aged 2 to 11.

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

Paused since 2026-11-16: Google Flights asks its data call for a browser check, which this Actor doesn't pass; a run with infants is refused before any search, at no cost. Infants under 2 in their own seat.

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

Paused since 2026-11-16: Google Flights asks its data call for a browser check, which this Actor doesn't pass; a run with infants is refused before any search, at no cost. Infants under 2 on a lap (one per adult). At most 9 passengers in all.

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

Economy (default), business or first. Premium economy is paused since 2026-11-16 (Google Flights asks its data call for a browser check): a run that asks for it is refused before any search, at no cost.

## `stops` (type: `string`):

Default: any. Nonstop is sent with the search. Since 2026-11-16 '1 stop or fewer' and '2 stops or fewer' are applied to the flights after the search, since Google Flights asks its own filter's data call for a browser check; the status says so.

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

Only these airlines: codes (AC, BA, DL) or names (Air Canada), matched against each flight's airlines. Since 2026-11-16 codes are applied after the search (Google Flights asks its own Airlines filter's data call for a browser check), and alliances (Star Alliance, oneworld, SkyTeam) are paused: name their airlines instead. Leave empty for all.

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

Flights flown by these airlines (codes or names) are left out.

## `maxPrice` (type: `number`):

Leave out flights above this price, in the run's currency. A search's cheapest fare is the cheapest flight that passes every filter.

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

Leave out flights longer than this, layovers included (600 for 10 hours).

## `maxLayoverMinutes` (type: `integer`):

Leave out flights with a longer layover.

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

Local time at the departure airport, 06:00. With Departs before, a window; a window from 22:00 to 05:00 crosses midnight.

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

Local time, 12:00 (a plain hour, 12, includes 12:59).

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

Local time at the arrival airport.

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

Local time at the arrival airport.

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

Flight rows each search returns, in the Sort by order (default 20, up to 300: Google lists up to about 300). 0 returns only each search's summary row, with its cheapest fare and price insight.

## `sortBy` (type: `string`):

The order of each search's flight rows (default: price).

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

Charged rows a run returns in all (default 1,000), shared evenly across the searches. Free rows (not found, no flights) don't count.

## `priceCalendarDays` (type: `integer`):

Paused since 2026-11-16: Google Flights asks its data call for a browser check, which this Actor doesn't pass. A run that asks for it says so and searches the departure dates. The cheapest fare for each departure day, for this many days from each route's first departure date (one calendar row per route; round trips keep the trip length). 0 or empty: no calendar.

## `calendarOnly` (type: `boolean`):

Paused since 2026-11-16: Google Flights asks its data call for a browser check, which this Actor doesn't pass. A run that asks for it says so and searches the departure dates. Only the price calendar, no searches (60 days unless Price calendar says otherwise).

## `onlyChanges` (type: `boolean`):

Return only what changed since the last run of the same search: the cheapest fare dropping or rising by at least the minimum change, a fare at or under your target, and flights whose own price moved. The first run returns everything (firstRun) and saves it as the baseline. Use it with a schedule. Alerts switch it on.

## `changeTypes` (type: `array`):

Which changes Only changes returns and alerts post. Default: price drops and fares under your target.

## `minPriceChangePercent` (type: `number`):

A smaller move isn't reported, and the last reported price stays the baseline, so a slow slide is reported once it adds up (default 1).

## `targetPrice` (type: `number`):

With Only changes: report a search (and alert) when its cheapest fare reaches this price or less, in the run's currency, for all passengers. Reported once until the fare goes back above it.

## `alertWebhookUrl` (type: `string`):

Post the changes to a Slack, Discord or Microsoft Teams channel (its incoming webhook URL), or any HTTPS endpoint that takes JSON (Zapier, Make, n8n). The first run posts one 'alerts are set up' message; fare changes follow from the next run.

## `telegramBotToken` (type: `string`):

Post the changes to Telegram through your own bot: its token from @BotFather (123456789:AAH...).

## `telegramChatId` (type: `string`):

The chat the bot posts to: a chat id (-1001234567890) or a public channel (@mychannel, with the bot as an admin).

## `historyName` (type: `string`):

The named key-value store that keeps the fares Only changes compares with (default google-flights-history). Each search keeps its own record in it, so schedules can share one.

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

The currency of every price: USD (default), EUR, GBP, CAD, INR...

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

The country Google Flights is shown for (two letters: US by default, GB, CA, IN). Fares can differ by country.

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

The language of place and airline names (en by default, de, fr, pt-BR).

## `proxy` (type: `object`):

Leave it off: the Actor reads Google Flights through its own residential proxy, included in the price. Your own proxy URLs are used instead if you give them; an Apify Proxy setting isn't used.

## Actor input object example

```json
{
  "routes": [
    "New York to London"
  ],
  "departureDates": [
    "in 30 days"
  ],
  "changeTypes": [
    "priceDrop",
    "belowTarget"
  ],
  "minPriceChangePercent": 1,
  "proxy": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

## `flights` (type: `string`):

No description

## `calendar` (type: `string`):

No description

## `changes` (type: `string`):

No description

## `notFound` (type: `string`):

No description

## `allData` (type: `string`):

No description

## `runSummary` (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 = {
    "routes": [
        "New York to London"
    ],
    "departureDates": [
        "in 30 days"
    ],
    "proxy": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("akhil_rajesh/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": ["New York to London"],
    "departureDates": ["in 30 days"],
    "proxy": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("akhil_rajesh/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": [
    "New York to London"
  ],
  "departureDates": [
    "in 30 days"
  ],
  "proxy": {
    "useApifyProxy": false
  }
}' |
apify call akhil_rajesh/google-flights-scraper --silent --output-dataset

```

## MCP server setup

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