# Google Flights Scraper: Fares, Dates & Returns (`luzivanlt/google-flights-scraper`) Actor Google Flights fares for many routes and dates in one run: every flight listed, with legs, stops and CO2. $0.15 per 1,000 flights. Layovers, price history and return flight pairs. - **URL**: https://apify.com/luzivanlt/google-flights-scraper.md - **Developed by:** [Luzi](https://apify.com/luzivanlt) (community) - **Categories:** Travel, Automation - **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks - **User rating**: No ratings yet ## Pricing from $0.11 / 1,000 flights This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events. Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have. Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event ## What's an Apify Actor? An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes. In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours, and optionally produces a well-defined JSON output, datasets with results, or files in key-value store. In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server. Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md. ## How to integrate an Actor? If asked about integration, you help developers integrate Actors into their projects. You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready. Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run. For examples already wired to this Actor's own input schema, see the [API](#api) section below. Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`). # README ## Google Flights Scraper: Fares, Dates & Returns Price many routes and departure dates in one run and get every flight Google Flights lists for each, one row per itinerary: price, airlines, flight numbers, times, stops, layovers, aircraft, legroom and CO2, plus Google's price insight and 60 days of price history. Round trips can include every return flight, priced as the whole trip. No account, login or cookies needed. Tested daily. Latest checks: 21 flights from New York JFK to London Heathrow in 4 seconds; and 28 round-trip searches with every return flight, 3,432 outbound and return pairs in 23 minutes. ### What does this Actor do? You give it airports and dates. Each origin, destination and departure date is one search, run as Google Flights runs it for your cabin, passengers, stops and currency. The Actor saves one row per flight Google lists, in Google's order (top flights first), until your limit or the end of the list. Each row comes with: - the price for all passengers, the currency, its place in Google's list and whether it is one of Google's top flights - the airlines, their codes and the flight numbers - departure and arrival airports with their names, cities and countries, and local departure and arrival times - total duration, the number of stops, and each layover's airport, city and length, flagging a change of airport - every leg: flight number, airline, the airline operating it, airports, times, duration, aircraft, legroom, CO2 and the other flight numbers it is sold under - the trip's CO2 in grams, and for one-way searches the typical CO2 for the route and the difference - Google's price insight for the search: lowest price, typical price and range, low/typical/high, and the price history of the last 60 days - a cheaper nearby date Google suggests, travel notices, and each airline's baggage and special-assistance pages - for a round trip with return flights: the return flight with the same details, the whole-trip price and both flights' places in Google's lists - the search itself (airports, dates, cabin, passengers) and a link that opens it on Google Flights ### Why use it? - **Many dates in one run.** List departure dates, or write "30 days" to search 30 days from the run's day, and give a stay length to price the same trip on each day: built for daily schedules and fare calendars. - **Several airports at once.** JFK,EWR,LGA searches all of New York in one search. - **Return flights too.** One switch reads the return flights offered with each outbound flight, one row per pair with its whole-trip price. - **Price context on every row.** Google's typical price range, its verdict and 60 days of price history, so you can tell a deal from a normal fare. - **Use the data anywhere.** Download as JSON, CSV or Excel, or send it to your own tools through Apify's API and integrations. ### How to use it 1. Type airport codes into **From (airports)** and **To (airports)**. 2. Add one or more **Departure dates**. 3. For a round trip, set a **Return date** or a **Stay length in days**, and turn on **Read return flights too** if you want every return flight. 4. Optionally set the cabin, passengers, stops, currency, country, language or **Max flights per search**. 5. Click **Start**. When the run ends, open the **Output** tab to view the flights or download them. Run it with no input to see a sample: up to 30 flights from New York JFK to London Heathrow, 30 days from today, charged as usual. ### Input | Field | What it does | Default | | --------------------------------------------------------------------------------------------- | ----------------------------------------------------- | ------- | | **From (airports)** (`origins`) | IATA codes; several joined by commas mean any of them | — | | **To (airports)** (`destinations`) | IATA codes; several joined by commas mean any of them | — | | **Departure dates** (`departureDates`) | `YYYY-MM-DD` or days from the run's day (`"30 days"`) | — | | **Return date (round trip)** (`returnDate`) | One return day for every search | one-way | | **Stay length in days (round trip)** (`stayDays`) | Return this many days after each departure | one-way | | **Read return flights too (round trip)** (`returnFlights`) | One row per outbound and return pair | off | | **Cabin** (`cabinClass`) | `economy`, `premium_economy`, `business`, `first` | economy | | **Adults**, **Children**, **Infants** (`adults`, `children`, `infantsInSeat`, `infantsOnLap`) | Passengers, up to 9 in all | 1 adult | | **Stops** (`maxStops`) | `any`, `0` (nonstop), `1`, `2` | any | | **Currency** (`currency`) | 3-letter code | USD | | **Country** (`country`) | 2-letter code of the country searched from | us | | **Language** (`language`) | Language of names and notices | en | | **Max flights per search** (`maxFlightsPerSearch`) | Stop each search after this many flights | 100 | Every origin is searched to every destination on every date, up to 100 searches in one run. Example input: ```json { "origins": ["JFK,EWR"], "destinations": ["LHR", "CDG"], "departureDates": ["2026-12-04", "2026-12-05"], "stayDays": 7, "returnFlights": false, "cabinClass": "economy", "adults": 2, "maxStops": "1", "currency": "USD" } ``` ### Output One row per flight Google lists for a search. An example, with made-up values: ```json { "itinerary_key": "JFK|LHR|2026-12-04||economy|1-0-0-0|any|USD|us|2026-12-04:XX100", "rank": 1, "is_best": true, "price": 412, "currency": "USD", "price_type": "one_way", "airline_code": "XX", "airlines": ["Example Air"], "flight_numbers": ["XX 100"], "departure_airport": "JFK", "departure_airport_name": "John F. Kennedy International Airport", "departure_city": "New York", "departure_country_code": "US", "arrival_airport": "LHR", "arrival_airport_name": "Heathrow Airport", "arrival_city": "London", "arrival_country_code": "GB", "departure_time": "2026-12-04T18:30", "arrival_time": "2026-12-05T06:40", "duration_minutes": 430, "stops": 0, "layovers": [], "legs": [ { "flight_number": "XX 100", "airline_code": "XX", "airline_name": "Example Air", "operated_by": null, "departure_airport": "JFK", "departure_airport_name": "John F. Kennedy International Airport", "arrival_airport": "LHR", "arrival_airport_name": "Heathrow Airport", "departure_time": "2026-12-04T18:30", "arrival_time": "2026-12-05T06:40", "duration_minutes": 430, "aircraft": "Boeing 777", "legroom": "31 inches", "emissions_grams": 402000, "also_sold_as": [ { "flight_number": "YY 5100", "airline_code": "YY", "airline_name": "Sample Airways" } ] } ], "emissions_grams": 402000, "typical_emissions_grams": 427000, "emissions_vs_typical_percent": -6, "return_flight": null, "airline_links": [ { "airline_code": "XX", "airline_name": "Example Air", "baggage_url": "https://www.example.com/baggage", "special_assistance_url": "https://www.example.com/assistance" } ], "booking_token": "CjRIexample…", "price_insights": { "lowest_price": 298, "typical_price": 330, "typical_price_low": 280, "typical_price_high": 460, "price_level": "typical", "price_history": [ { "date": "2026-10-01", "price": 341 }, { "date": "2026-10-02", "price": 335 } ] }, "cheaper_dates": [{ "departure_date": "2026-12-06", "return_date": null, "price": 270 }], "travel_notices": [], "search_origin": "JFK", "search_destination": "LHR", "trip_type": "one_way", "departure_date": "2026-12-04", "return_date": null, "cabin_class": "economy", "adults": 1, "children": 0, "infants_in_seat": 0, "infants_on_lap": 0, "max_stops": null, "language": "en", "country": "us", "searched_airports": [ { "code": "JFK", "name": "John F. Kennedy International Airport", "city": "New York", "country_code": "US", "country": "United States", "latitude": 40.64, "longitude": -73.78 } ], "google_flights_url": "https://www.google.com/travel/flights/search?tfs=…" } ``` A field Google does not show is `null` (or an empty list). A round trip with return flights also fills `return_flight` (the same fields as the outbound: airlines, times, stops, layovers, legs, CO2), `return_rank`, `return_is_best` and `outbound_price`. ### How much does it cost? No surcharges and no paid options; an item that fails is not charged. This Actor is priced per flight saved: - **$0.15 per 1,000 flights** ($0.00015 a flight). A flight is one itinerary, or one outbound and return pair when return flights are read. Each is charged once per run. - No start fee, and nothing per search. So 1,000 flights cost $0.15. If you set a maximum cost for a run, the Actor stops when it reaches it and keeps every flight saved so far. ### How long does a run take? A few seconds for one one-way search (about 20 flights). Return flights take one more page per outbound flight: 28 round-trip searches with every return flight took 23 minutes (3,432 pairs). ### Good to know - **Prices are for all passengers together**, in your currency, as Google Flights shows them from the country you pick. They change often; a fare can differ by the time you book. - **Times are local** to each airport, as `YYYY-MM-DDTHH:MM`. - **A round trip without return flights** gives one row per outbound flight, priced from its cheapest return (`price_type` `round_trip_from`). With return flights on, each pair is a row priced as the whole trip (`round_trip`); that reads one more page per outbound flight. **Max flights per search then counts pairs**, and the outbound flights' pages come back in no set order: at the default 100, a search keeps the pairs of the first few outbound flights read. Set it to 1,000 to keep every pair. - **The list is Google's list.** A search returns what Google Flights lists for it, usually 10 to 40 flights one way; a busy domestic route gives more. A flight Google lists twice is saved once. - **`price` can be empty** when Google shows a flight without a price. - **Google sometimes answers a page with nothing**, and the Actor tries that page again, up to 7 tries in all. A search with a page that still cannot be read is listed in the run's status (2 of 28 in the round-trip check above), keeping every flight it did read; run it again to fill it in. - **One search that cannot be read does not stop the run.** The others carry on, and the run's status lists the searches that could not be read. - **A search with no flights is not an error.** It saves nothing. - **Not supported yet:** multi-city trips, flexible "anywhere" searches, the booking options of each flight (the sellers and their links), and filters by airline, price or time. ### More Actors from us - [Google Ads Transparency Scraper: Every Ad by Site](https://apify.com/luzivanlt/google-ads-transparency-scraper): Google Ads Transparency Center ads by website, advertiser or name, to the last page, in 216 regions. - [Google Play Reviews Scraper: Device, Star Filter & Replies](https://apify.com/luzivanlt/google-play-reviews-scraper): Google Play reviews with the device each was written on, a star filter and the developer's reply. - [AliExpress Product Scraper: Search Results & Prices](https://apify.com/luzivanlt/aliexpress-products-scraper): Every product of an AliExpress search to its last page, with exact sold counts and ratings. - [Amazon Product Scraper: Search Results & Prices](https://apify.com/luzivanlt/amazon-products-scraper): Every product on Amazon's search pages to the last page, sponsored marked, with monthly sales. - [App Store Reviews Scraper: All Reviews, Not 500](https://apify.com/luzivanlt/app-store-reviews-scraper): Every written App Store review of an app, not just the newest 500. - [Career Site Jobs Scraper: Workday, Greenhouse, Lever](https://apify.com/luzivanlt/career-site-jobs-scraper): Every job on Greenhouse, Lever, Ashby, SmartRecruiters and Workday boards, checked against each board's count. - [Facebook Ads Library Scraper: Meta Ads by Keyword or Page](https://apify.com/luzivanlt/facebook-ads-library-scraper): Meta Ad Library ads by keyword, Page or Ad Library link, with text, images, videos and dates. - [Facebook Comments Scraper: With Replies](https://apify.com/luzivanlt/facebook-comments-scraper): Comments and replies from public Facebook posts, reels and videos, with reactions by type. ### Use it from an AI agent or the API One call starts a run and returns its items (Apify waits up to 300 seconds; for a longer run, start it with `POST /v2/acts/…/runs` and read its dataset): ```text POST https://api.apify.com/v2/acts/luzivanlt~google-flights-scraper/run-sync-get-dataset-items?token= ``` With the sample input as its JSON body: ```json { "origins": ["JFK"], "destinations": ["LHR"], "departureDates": ["30 days"], "returnFlights": false, "cabinClass": "economy", "adults": 1, "children": 0, "infantsInSeat": 0, "infantsOnLap": 0, "maxStops": "any", "currency": "USD", "country": "us", "language": "en", "maxFlightsPerSearch": 30 } ``` Its inputs, in the order of the input form: | Input | What it takes | Default | | ------------------------------------------------------ | --------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------- | | `origins` (From (airports)) | Where the flights leave from, as 3-letter IATA airport codes, one per line. | — | | `destinations` (To (airports)) | Where the flights go, as 3-letter IATA airport codes, one per line; several on one line, joined by commas, means any of them (e.g. LHR,LGW). | — | | `departureDates` (Departure dates) | The days to fly out, one per line: a date as YYYY-MM-DD, or a number of days from the day the run starts, such as "30 days" (handy for a daily schedule). | — | | `returnDate` (Return date (round trip)) | Make every search a round trip coming back on this day: YYYY-MM-DD, or days from the run's day such as "37 days". | — | | `stayDays` (Stay length in days (round trip)) | Make every search a round trip that comes back this many days after its departure date (0 = the same day). | — | | `returnFlights` (Read return flights too (round trip)) | For a round trip, also read the return flights offered with each outbound flight: one row per outbound and return pair, with its whole-trip price. | `false` | | `cabinClass` (Cabin) | The cabin to price: economy, premium economy, business or first, as Google Flights offers it for the route. | `"economy"` | | `adults` (Adults) | Adult passengers (12 and over), from 1 to 9. | `1` | | `children` (Children (2 to 11)) | Children aged 2 to 11, from 0 to 8. | `0` | | `infantsInSeat` (Infants in their own seat) | Children under 2 who have a seat of their own, from 0 to 8. | `0` | | `infantsOnLap` (Infants on a lap) | Children under 2 who travel on an adult's lap, at most one per adult. | `0` | | `maxStops` (Stops) | Only flights with at most this many stops: any number (the default), nonstop only, 1 stop or fewer, or 2 stops or fewer. | `"any"` | | `currency` (Currency) | The currency every price is shown in, as a 3-letter code such as USD, EUR, GBP, JPY or VND. | `"USD"` | | `country` (Country) | The country Google Flights is used from, as a 2-letter code such as us, gb, de or vn. | `"us"` | | `language` (Language) | The language of airport, city, airline and notice names, as a language code such as en, de, fr or pt-BR. | `"en"` | | `maxFlightsPerSearch` (Max flights per search) | Stop each search after this many flights, in Google's order (top flights first), from 1 to 1,000 (100 by default). | `100` | Apify's MCP server, `https://mcp.apify.com`, lists it as `luzivanlt/google-flights-scraper`. To give an AI agent this Actor as a tool, add the server to the agent's MCP config: ```json { "mcpServers": { "apify": { "url": "https://mcp.apify.com?tools=luzivanlt/google-flights-scraper" } } } ``` The client signs in with OAuth, or add `"headers": { "Authorization": "Bearer " }`. Charged per flight delivered; the sample input above costs at most $0.02. ### FAQ **Do I need an account or cookies?** No. The Actor reads what anyone can see on Google Flights. **Can I track fares over time?** Yes. Write departure dates as days from the run's day ("30 days") and run the Actor on a schedule: each run prices the same trip ahead, and each row carries Google's 60 days of price history for its search. **Can I run it from my own code, on a schedule, or with other apps?** Yes. Like any Apify Actor, you can start it through the Apify API, run it on a schedule, and connect it to other apps with Apify's integrations and webhooks. ### Is it legal to scrape Google Flights? This Actor reads only what anyone can see on Google Flights without logging in. Check Google's terms and the laws that apply to you before you use the data. If you are unsure, ask a lawyer. ### Support Found a problem or missing a feature? Open an issue on the **Issues** tab and include the run's link. *** This Actor is not affiliated with, endorsed by or sponsored by Google. # Changelog This Actor's version history is a separate document: https://apify.com/luzivanlt/google-flights-scraper/changelog.md # Actor input Schema ## `origins` (type: `array`): Where the flights leave from, as 3-letter IATA airport codes, one per line. Put several codes on one line, joined by commas, to search any of those airports at once (e.g. JFK,EWR,LGA for all of New York). Every origin is searched to every destination on every departure date, up to 100 searches in one run. Example: JFK ## `destinations` (type: `array`): Where the flights go, as 3-letter IATA airport codes, one per line; several on one line, joined by commas, means any of them (e.g. LHR,LGW). Example: LHR ## `departureDates` (type: `array`): The days to fly out, one per line: a date as YYYY-MM-DD, or a number of days from the day the run starts, such as "30 days" (handy for a daily schedule). Each date is its own search, so 14 dates price two weeks of departures. Up to 330 days ahead, never in the past. Example: 2026-12-04 ## `returnDate` (type: `string`): Make every search a round trip coming back on this day: YYYY-MM-DD, or days from the run's day such as "37 days". It must not come before a departure date. Leave empty for one-way fares, or use Stay length instead. Example: 2026-12-11 ## `stayDays` (type: `integer`): Make every search a round trip that comes back this many days after its departure date (0 = the same day). Use it with several departure dates to price the same length of trip on each day. Give this or a return date, not both. Example: 7 ## `returnFlights` (type: `boolean`): For a round trip, also read the return flights offered with each outbound flight: one row per outbound and return pair, with its whole-trip price. Off by default, when a round trip gives one row per outbound flight, priced from its cheapest return. This reads one more page per outbound flight, so a search gives many more rows. Example: true ## `cabinClass` (type: `string`): The cabin to price: economy, premium economy, business or first, as Google Flights offers it for the route. Economy by default; a cabin an airline does not sell on a route simply lists fewer flights. Example: business ## `adults` (type: `integer`): Adult passengers (12 and over), from 1 to 9. Every price is for all passengers of the search together, as Google Flights shows it, not per person. At most 9 passengers in all. Example: 2 ## `children` (type: `integer`): Children aged 2 to 11, from 0 to 8. They are priced with the adults in each flight's price. At most 9 passengers in all, adults, children and infants together. Example: 1 ## `infantsInSeat` (type: `integer`): Children under 2 who have a seat of their own, from 0 to 8. Priced with the other passengers in each flight's price. At most 9 passengers in all. Example: 1 ## `infantsOnLap` (type: `integer`): Children under 2 who travel on an adult's lap, at most one per adult. Priced with the other passengers in each flight's price; Google usually adds a small fare for each. Example: 1 ## `maxStops` (type: `string`): Only flights with at most this many stops: any number (the default), nonstop only, 1 stop or fewer, or 2 stops or fewer. The same limit applies to the return flights of a round trip. Example: 0 ## `currency` (type: `string`): The currency every price is shown in, as a 3-letter code such as USD, EUR, GBP, JPY or VND. Google converts the fare itself; prices are whole amounts in that currency. USD by default. Example: EUR ## `country` (type: `string`): The country Google Flights is used from, as a 2-letter code such as us, gb, de or vn. It can change which fares and sellers are offered, as for a traveller in that country. us by default. Example: gb ## `language` (type: `string`): The language of airport, city, airline and notice names, as a language code such as en, de, fr or pt-BR. Times, codes and prices are the same in every language. en by default. Example: de ## `maxFlightsPerSearch` (type: `integer`): Stop each search after this many flights, in Google's order (top flights first), from 1 to 1,000 (100 by default). A one-way search usually lists 10 to 40 flights. With return flights on it counts outbound and return pairs, read in no set order: set 1,000 to keep them all. You pay per flight saved ($0.15 per 1,000), so this caps what each search costs. Example: 50 ## Actor input object example ```json { "origins": [ "JFK" ], "destinations": [ "LHR" ], "departureDates": [ "30 days" ], "returnFlights": false, "cabinClass": "economy", "adults": 1, "children": 0, "infantsInSeat": 0, "infantsOnLap": 0, "maxStops": "any", "currency": "USD", "country": "us", "language": "en", "maxFlightsPerSearch": 30 } ``` # Actor output Schema ## `flights` (type: `string`): Every flight the run saved, one row per itinerary (per outbound and return pair when return flights are read). ## `allFields` (type: `string`): The same rows with every field. # 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 '' with your token const client = new ApifyClient({ token: '', }); // Prepare Actor input const input = { "origins": [ "JFK" ], "destinations": [ "LHR" ], "departureDates": [ "30 days" ], "maxFlightsPerSearch": 30 }; // Run the Actor and wait for it to finish const run = await client.actor("luzivanlt/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 '' with your token. client = ApifyClient("") # Prepare the Actor input run_input = { "origins": ["JFK"], "destinations": ["LHR"], "departureDates": ["30 days"], "maxFlightsPerSearch": 30, } # Run the Actor and wait for it to finish run = client.actor("luzivanlt/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 days" ], "maxFlightsPerSearch": 30 }' | apify call luzivanlt/google-flights-scraper --silent --output-dataset ``` ## MCP server setup ```json { "mcpServers": { "apify": { "type": "http", "url": "https://mcp.apify.com/?tools=fetch-actor-details,luzivanlt/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 ` 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/hUeRf7zJGTjyesrnQ/builds/mc9y1zO8QTEDUyaIf/openapi.json