# Google Flights Scraper - Fares, Prices & Booking (`eiv/google-flights-scraper`) Actor Scrape Google Flights by route and date: every itinerary with price, airlines, flight numbers, times, stops, layovers, CO2 and Google's price level. One-way, round trip, multi-city, return flights, booking options and a cheapest-date calendar. No login, no browser. From $0.60 per 1,000 flights. - **URL**: https://apify.com/eiv/google-flights-scraper.md - **Developed by:** [Eimantas V](https://apify.com/eiv) (community) - **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks - **User rating**: No ratings yet ## Pricing from $0.65 / 1,000 flight 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 Scraper** extracts every itinerary Google Flights lists for a route and date: price, airlines, flight numbers, departure and arrival times, stops, layovers, aircraft, legroom, CO2 and Google's own price level (low, typical or high). Paste routes like `LAX-JFK` or Google Flights links, get one clean row per flight. One-way, round trip and multi-city. No login, no API key, no browser, from **$0.65 per 1,000 flights**. ``` price airline flights from to departs arrives stops priceLevel 239 American AA4 LAX JFK 2026-11-19T13:44 2026-11-19T21:59 0 typical 225 American AA1989+AA450 LAX JFK 2026-11-19T06:00 2026-11-19T19:00 1 typical 267 JetBlue B6524 LAX JFK 2026-11-19T11:00 2026-11-19T19:29 0 typical ``` **Benchmark: 2,000 flights from 20 routes in 7 seconds on 256 MB, no proxy (Apify platform run, October 2026).** ### What does Google Flights Scraper do? It searches Google Flights the way you would on its website, with the same filters, and returns Google's full list of itineraries (up to ~150 per route, ~300 for city-to-city searches) as structured data. Add return flights, booking options from the airline and travel agencies, or a cheapest-date calendar with one switch each. - **Every input form.** Airport codes (`LAX-JFK`), several airports (`JFK,EWR-LHR`), city codes (`NYC-LON`), dates or days from today (`LAX-JFK +30`), round trips (`LAX-JFK 2026-12-01 2026-12-08`), multi-city trips, and links copied from Google Flights. - **Every Google filter.** Travellers, cabin, stops, airlines and alliances, max price, duration, departure and arrival times, layover airports and length, checked and carry-on bags, basic economy, lower emissions, sort order, currency, country and language. - **Price insights included.** Every flight carries Google's price level and the price range the route usually costs; an optional summary row adds the cheapest nonstop and ~60 days of price history. - **Add-ons without a surcharge.** Return flights for the top departing flights, the rest of a multi-city trip, booking options with seller, fare name, price and booking link, and the cheapest flight for each of the next 90 days. Every row costs the same. - **Only pay for flights.** Searches with no flights, invalid airports and past dates return a free error row. Summary rows are free. - **Built for automation.** Relative dates keep scheduled price checks pointing at the future. Run it from the API, Make, Zapier, n8n or Google Sheets, or let an AI agent call it through Apify's MCP server. ### Why it is fast and cheap The Actor calls the same data service the Google Flights website uses, over plain HTTP, from Apify's own address: no browser to start, no proxy to pay for, and Google's full list in one request per search. Google streams slow searches as hundreds of repeated updates; the Actor reads them as they arrive and stops once the result has settled, so even big city-to-city searches stay quick and light. ### What data can you extract from Google Flights? | Field | Example | What it is | |---|---|---| | `price`, `currency` | `225`, `USD` | Total for all travellers; round trips and multi-city: the whole trip | | `priceLevel` | `typical` | Google's insight: low, typical or high for this route and date | | `typicalPriceLow`, `typicalPriceHigh` | `135`, `280` | The range the route usually costs | | `airline`, `airlineCodes` | `American`, `["AA"]` | Main airline and every airline on the itinerary | | `flightNumbers` | `["AA2564", "AA4421"]` | Every flight, in order | | `origin`, `destination` | `LAX`, `JFK` | Airport codes, with `originName` and `destinationName` | | `departAt`, `arriveAt` | `2026-12-01T06:04` | Local times, also split into date and time fields | | `durationMinutes`, `stops` | `435`, `1` | Door-to-door minutes and number of stops | | `layovers` | `[{"airport": "ORD", "durationMinutes": 36}]` | Each connection, its city, length and airport change | | `legs` | `[{"aircraft": "Airbus A321", "legroom": "30 in"}]` | Each flight: number, operator, aircraft, times, legroom, CO2 | | `emissionsKg`, `emissionsVsTypicalPercent` | `436`, `31` | Google's CO2 estimate and how it compares with the route's typical | | `isBestFlight`, `isCheapest`, `rank` | `true`, `false`, `1` | Google's top flights, the cheapest, and the position | | `bookingOptions` | `[{"seller": "American", "fareName": "Basic Economy", "price": 225}]` | Add-on: who sells it, at what fare and price, with a booking link | | `googleFlightsUrl` | `https://www.google.com/travel/flights/booking?tfs=…` | Opens this flight on Google Flights | | `section` | `departing` | departing, returning, next-leg or calendar | | `input`, `scrapedAt` | `LAX-JFK` | The search as you typed it, and when the row was collected | ### How to scrape Google Flights 1. Click **Try for free** and type your routes into **Searches**, one per line: `LAX-JFK`, `JFK-LHR 2026-12-10 2026-12-17`, or a Google Flights link. 2. Set the **Departure date** (a date or "30 days" from today) and, for round trips, a return date or trip length. Pick travellers, cabin and filters if you need them. 3. Click **Start**. A search takes 1-3 seconds; big city-to-city searches up to a minute. 4. Open the **Output** tab, or download the flights as JSON, CSV, Excel or HTML. ### How much does it cost to scrape Google Flights? You pay per flight returned, and the price drops on higher Apify plans: | Apify plan | Per 1,000 flights | |---|---| | Free | $1.00 | | Starter | $0.80 | | Scale | $0.70 | | Business | $0.65 | - A daily price check of 10 routes with 20 flights each is 200 flights, **$0.16 a day** on Starter (about $4.80 a month). - A market study of 100 routes with 100 flights each is 10,000 flights, **$8.00** on Starter or **$6.50** on Business. - Return flights, next-leg and calendar rows are flights and cost the same; price insights and booking options cost nothing extra. - A run also costs **$0.00005** to start. A search that fails, or finds nothing, costs nothing more. - The Free plan's $5 monthly credit covers about **5,000 flights**. ### Input ```json { "searches": ["LAX-JFK", "JFK-LHR 2026-12-10 2026-12-17", "NYC-LON +45"], "departureDate": "30 days", "adults": 1, "cabinClass": "economy", "maxStops": "any", "sortBy": "best", "maxResultsPerSearch": 50, "currency": "USD", "market": "US", "includePriceInsights": true, "returnFlightsTop": 0, "includeBookingOptions": false, "priceCalendarDays": 0 } ``` | Field | Default | Notes | |---|---|---| | Searches | `LAX-JFK` | Routes, one per line, or Google Flights links. Multi-city: legs separated by `;`, each with its date | | Departure date | 30 days | For routes without their own date: YYYY-MM-DD or a time from today | | Return date / Trip length | empty | Either one makes undated routes round trips; both empty = one-way | | Adults, children, infants | 1, 0, 0 | Prices are totals for everyone | | Cabin, stops, airlines, filters | any | The same filters as Google Flights' website | | Sort by | Best | Or cheapest, departure, arrival, duration, emissions | | Flights per search | 100 | Up to 300 | | Max results | 1,000 | Total flights in the run: your cost cap | | Currency, country, language | USD, US, en | Prices follow the country you price from | | Price insights | on | Price level and typical range on every flight | | Return flights for the top N | 0 | Round trips: return flights of the first N departing flights | | Booking options | off | Sellers, fares, prices and links for the first N itineraries | | Cheapest-date calendar | 0 | Cheapest flight for each of the next N days | | Search summary row | off | One free row per search with totals and price history | | Proxy | off | Not needed: the Actor uses Apify's own address | ### Output Each flight is one row. The **Flights** view shows the key columns; **Flight details**, **Booking options** and **Search summaries** show the rest. Every export includes all fields. ```json { "recordType": "flight", "input": "LAX-JFK", "route": "LAX-JFK", "tripType": "one-way", "section": "departing", "rank": 2, "isBestFlight": true, "isCheapest": true, "price": 499, "currency": "USD", "priceLevel": "high", "typicalPriceLow": 135, "typicalPriceHigh": 280, "airline": "JetBlue", "airlineCode": "B6", "flightNumbers": ["B6524"], "origin": "LAX", "originName": "Los Angeles International Airport", "destination": "JFK", "destinationName": "John F. Kennedy International Airport", "departAt": "2026-11-28T13:30", "arriveAt": "2026-11-28T21:57", "durationMinutes": 327, "stops": 0, "layovers": [], "legs": [{ "flightNumber": "B6524", "airline": "JetBlue", "aircraft": "Airbus A320", "from": "LAX", "to": "JFK", "departAt": "2026-11-28T13:30", "arriveAt": "2026-11-28T21:57", "durationMinutes": 327, "legroom": "33 in", "emissionsKg": 422 }], "emissionsKg": 422, "typicalEmissionsKg": 332, "emissionsVsTypicalPercent": 27, "cabinClass": "economy", "searchDepartureDate": "2026-11-28", "googleFlightsUrl": "https://www.google.com/travel/flights/booking?tfs=CBwQAho_EgoyMDI2LTExLTI4…" } ``` A search that cannot be read becomes a free row with `"recordType": "error"` and an `errorCode` instead of failing the run: | `errorCode` | Meaning | |---|---| | `INVALID_SEARCH` | Google rejected the search: an airport code is wrong, or the date is too far ahead | | `INVALID_DATE` | A date is in the past, or the legs are out of order | | `NO_FLIGHTS` | Google lists no flights for that route, date and filters | | `GOOGLE_ERROR` / `TIMEOUT` | Google failed or was too slow on this search; run it again | | `RATE_LIMITED` | Google refused every address the run tried; run it again later | ### Tips and limits - **Schedules:** use relative dates ("30 days", "+45") so a saved task keeps searching the future, and the search summary row to track Google's price level over time. - **Faster big searches:** city codes (`NYC-LON`) cover every airport pair, which Google can take up to a minute to price. Single airports answer in about a second. - **Fewer than 15 flights per search** reads Google's short list, which always includes the cheapest flight when sorted by price; more reads the full list. - **Prices** are what Google Flights shows for the chosen country and currency at that moment. Booking links lead through Google to the seller and expire after a while, like Google's own. - **Not available:** Google's Explore map (cheapest destinations from one airport). Price history comes only for searches Google shows a graph for (mostly one adult). - **Hit your spending limit?** The run stops cleanly at your maximum cost per run and keeps everything it collected. Raise the limit in the run options to get more. ### FAQ #### Is it legal to scrape Google Flights? This Actor collects only flight data that Google Flights shows publicly, without logging in: schedules, prices and fares, no personal data. Check the terms of the services you use and ask a lawyer if you are unsure about your use case. Google Flights is a trademark of Google LLC; this Actor is not affiliated with or endorsed by Google. #### Can I use it through the API or with Make, Zapier and n8n? Yes. Every run can be started through the [Apify API](https://docs.apify.com/api/v2) and returns the dataset as JSON, CSV or Excel. Schedules, webhooks and integrations for Make, Zapier, n8n and Google Sheets are on the **Integrations** tab. #### Can AI agents use it? Yes. Agents connected to [Apify's MCP server](https://mcp.apify.com) can find and run this Actor as a tool to plan trips or compare fares, with the same per-flight pricing. #### Why did I get fewer flights than I asked for? Google listed fewer for that route and filters, the run reached your maximum cost per run, or it reached its timeout. The log says which, and nothing collected before that is lost. ### Related scrapers - [Google Hotels Scraper](https://apify.com/eiv/google-hotels-scraper): hotel prices and every booking site's rate for the same trip. - [Airbnb Market Scraper](https://apify.com/eiv/airbnb-market-scraper): vacation rental listings and prices at the destination. - [Google Trends Scraper](https://apify.com/eiv/google-trends-scraper): search interest in destinations over time. ### Support Missing a field, or found a route that does not work? Open an issue on the **Issues** tab with the input you used, and it will be looked at quickly. # Actor input Schema ## `searches` (type: `array`): One route per line, with IATA airport codes: "LAX-JFK" (dates from the fields below), "LAX-JFK 2026-12-01" (one-way), "LAX-JFK 2026-12-01 2026-12-08" (round trip), "JFK,EWR-LHR" (several airports), "NYC-LON" (city codes), "LAX-JFK +30" (30 days from today). Multi-city: legs separated by ";", each with its date. Google Flights links (with tfs=) work too. ## `startUrls` (type: `array`): The same searches in the URL-list shape other Actors output: Google Flights search links (google.com/travel/flights/search?tfs=…). Use this or the field above. ## `departureDate` (type: `string`): For routes without their own date: a date (YYYY-MM-DD) or a time from today, such as "30 days" or "2 weeks". Relative dates keep scheduled runs pointing at the future. ## `returnDate` (type: `string`): Optional, for routes without their own date: a date or a time from today. Set it (or "Trip length") for round trips; leave both empty for one-way. ## `tripLengthDays` (type: `integer`): Optional: return this many days after departure (used when no return date is set). Handy on schedules: "30 days" departure + 7 days = a week-long trip a month out. ## `adults` (type: `integer`): Travellers aged 12 and over. Prices are the total for all travellers. ## `children` (type: `integer`): Travellers aged 2-11. Google applies child fares where the airline has them. ## `infantsInSeat` (type: `integer`): Under 2, with their own seat. ## `infantsOnLap` (type: `integer`): Under 2, on an adult's lap (at most one per adult). ## `cabinClass` (type: `string`): Cabin class to price. ## `maxStops` (type: `string`): Most stops allowed per direction. ## `airlines` (type: `array`): Only these airlines: two-character IATA codes (DL, BA, LH) and/or alliances (ONEWORLD, SKYTEAM, STAR_ALLIANCE). ## `excludeAirlines` (type: `array`): Leave out these airlines or alliances, same codes as above (e.g. NK, F9). ## `maxPrice` (type: `integer`): Only itineraries at or below this total price, in the currency below. ## `maxDurationHours` (type: `integer`): Longest journey per direction, layovers included. ## `departureTimeRange` (type: `string`): Hour window for leaving, local time, 24-hour clock: "6-12" for mornings, "18-23" for evenings. Applies to the outbound (and every multi-city leg). ## `arrivalTimeRange` (type: `string`): Hour window for arriving, local time, e.g. "8-20". Applies to the outbound. ## `returnDepartureTimeRange` (type: `string`): Round trips: hour window for the return's departure, e.g. "12-23". ## `returnArrivalTimeRange` (type: `string`): Round trips: hour window for the return's arrival, e.g. "0-22". ## `connectVia` (type: `array`): Connections must be at one of these airports (codes such as ORD, DFW). Nonstop flights still show. ## `avoidConnectingIn` (type: `array`): Drop itineraries with a layover at any of these airports (codes such as JFK). Dropped flights are not charged. ## `minLayoverMinutes` (type: `integer`): Shortest connection time allowed. ## `maxLayoverMinutes` (type: `integer`): Longest connection time allowed. ## `checkedBags` (type: `integer`): Price fares including this many checked bags per traveller, as Google's Bags filter does. ## `carryOnBag` (type: `boolean`): Price fares with a carry-on bag included (drops fares that charge for one). ## `excludeBasicEconomy` (type: `boolean`): Leave out basic economy fares (mostly US airlines). ## `lessEmissionsOnly` (type: `boolean`): Only flights Google marks as lower emissions. ## `sortBy` (type: `string`): Order of the flights: Google's best ranking, or by price, departure time, arrival time, duration or emissions. ## `maxResultsPerSearch` (type: `integer`): Most flights to return per search, in the order above. Google lists up to ~150 on busy routes (300 for city-to-city searches). ## `maxItems` (type: `integer`): Stop after this many flight rows in total. You pay per flight, so this is also your cost cap for the run. ## `currency` (type: `string`): ISO currency code for prices: USD, EUR, GBP, CAD, AUD, INR, JPY… ## `market` (type: `string`): Two-letter country code Google prices from: US, GB, DE, IN… Fares and availability differ by country. ## `language` (type: `string`): Language of airport and airline names: en, de, fr, es… ## `includePriceInsights` (type: `boolean`): Add Google's price level (low / typical / high) and the typical price range to every flight. Included in the price; adds about a second per search. Not available for multi-city trips. ## `returnFlightsTop` (type: `integer`): Round trips: list the return flights for the first N departing flights, each with the round-trip total. Multi-city: Google's best flight on each later leg for the first N first-leg flights. Each row is charged as a flight. 0 = off. ## `returnFlightsPerOutbound` (type: `integer`): How many return flights to keep for each departing flight above, in the sort order. ## `includeBookingOptions` (type: `boolean`): For the first itineraries of each search, who sells the fare: the airline and travel agencies, each with its fare name (Basic Economy, Main…), price and a booking link. Included in the flight price; adds about a second per itinerary. Needs a complete trip: one-way flights, round-trip return flights, the last multi-city leg. ## `maxBookingItineraries` (type: `integer`): How many itineraries per search get booking options, from the top of the list. Each is one extra lookup. ## `priceCalendarDays` (type: `integer`): Also return the cheapest flight for each of this many departure dates, starting at the search's date (round trips keep their length). One row per date, charged as a flight. 0 = off. ## `includeSearchSummary` (type: `boolean`): Add one free row per search: flights found, lowest price, cheapest nonstop, Google's price level, typical range and ~60 days of price history. ## `proxyConfiguration` (type: `object`): Leave as it is: the Actor uses Apify's own address (no proxy needed, no proxy cost) and moves to datacenter proxy if Google refuses it. Apify's datacenter proxy as your setting is slower and often refused by Google Flights; your own proxy is tried first, then Apify's address. ## `maxConcurrency` (type: `integer`): How many searches run at the same time. ## `requestTimeoutSecs` (type: `integer`): How long to wait for one answer. Google can take up to a minute on big city-to-city searches (NYC-LON); a full list that misses this falls back to Google's short list. ## `maxRetries` (type: `integer`): Retries for refused or failed requests, each from a fresh address. Timeouts are not retried. ## Actor input object example ```json { "searches": [ "LAX-JFK" ], "departureDate": "30 days", "adults": 1, "children": 0, "infantsInSeat": 0, "infantsOnLap": 0, "cabinClass": "economy", "maxStops": "any", "checkedBags": 0, "carryOnBag": false, "excludeBasicEconomy": false, "lessEmissionsOnly": false, "sortBy": "best", "maxResultsPerSearch": 100, "maxItems": 1000, "currency": "USD", "market": "US", "language": "en", "includePriceInsights": true, "returnFlightsTop": 0, "returnFlightsPerOutbound": 10, "includeBookingOptions": false, "maxBookingItineraries": 10, "priceCalendarDays": 0, "includeSearchSummary": false, "proxyConfiguration": { "useApifyProxy": false }, "maxConcurrency": 5, "requestTimeoutSecs": 60, "maxRetries": 2 } ``` # Actor output Schema ## `results` (type: `string`): One row per flight (recordType "flight"), an optional free summary per search ("search-summary"), and one uncharged row per search that could not be read ("error"). ## `summary` (type: `string`): Totals for the run: searches, flight rows, failures, why the run stopped, requests and megabytes. # 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 = { "searches": [ "LAX-JFK" ] }; // Run the Actor and wait for it to finish const run = await client.actor("eiv/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 = { "searches": ["LAX-JFK"] } # Run the Actor and wait for it to finish run = client.actor("eiv/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 '{ "searches": [ "LAX-JFK" ] }' | apify call eiv/google-flights-scraper --silent --output-dataset ``` ## MCP server setup ```json { "mcpServers": { "apify": { "type": "http", "url": "https://mcp.apify.com/?tools=fetch-actor-details,eiv/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/MnB76TW7BVhfjEKxg/builds/EPzFsu3SMKJAqXHYL/openapi.json