# Google Flights Scraper API πŸ’°$2/1k β€” Fares & Multi-City (`memo23/google-flights-scraper`) Actor \[πŸ’°$2/1K] Google Flights scraper for fare monitoring and price comparison. One-way, round-trip & multi-city from airports, cities or countries, with every Google filter. Explore cheapest trips anywhere, price graph, return flights, CO2, layovers, bags, booking options & a link per flight. - **URL**: https://apify.com/memo23/google-flights-scraper.md - **Developed by:** [Muhamed Didovic](https://apify.com/memo23) (community) - **Categories:** Travel, Agents, MCP servers - **Features:** Limited permissions - **Stats:** 914 total users, 128 monthly users, 99.9% runs succeeded, 1 bookmarks - **User rating**: 5.00 out of 5 stars ## Pricing from $2.00 / 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. 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 API β€” Fares, Itineraries & Multi-City

Google Flights Scraper

### How It Works ![How the Google Flights Scraper works](https://raw.githubusercontent.com/muhamed-didovic/muhamed-didovic.github.io/main/assets/how-it-works-google-flights.png) 1. **Your input** β€” origin and destination (airport, city or country), dates, passengers, cabin, Google's filters, multi-city legs, market/currency/language. Or paste a Google Flights URL from your browser instead. 2. **Search** β€” the Actor runs your search on Google Flights and returns Google's **full** sorted result set (~150 itineraries on busy routes) plus price insights. No login or API key needed. 3. **Your dataset** β€” flat rows or nested JSON with price, carrier, stops, duration, per-segment aircraft/flight-number/legroom/times, a booking token, and optional booking options β€” CSV-ready or JSON. **Scrape flight itineraries, fares, schedules and routes from Google Flights β€” by route + dates β€” at $2 per 1,000 results.** One-way, round-trip and multi-city all supported, from airports, cities or whole countries, with every filter the site has. Each itinerary carries price, airline, stops, total duration, exact times, **layovers, CO2 emissions, included bags, aircraft type, flight number, legroom**, full airport names, a booking token and a **Google Flights link that opens that exact flight** β€” plus, optionally, **the airlines/OTAs selling each fare with their prices, fare names and booking links**, **the return flights for each outbound** and **Google's price graph** (cheapest fare per date). Pure HTTP β€” no browser, no CAPTCHA solver (a residential proxy is recommended and on by default, since Google serves empty results to datacenter IPs). Output is CSV-ready flat rows or nested JSON, straight into your Apify dataset. ### Why Use This Scraper? - **$2 / 1,000 results** β€” flat, simple pricing. No opaque per-page math. - **No login or API key needed** β€” fast, lightweight runs. Residential proxy recommended; the default works out of the box. - **Full trip coverage** β€” one-way, round-trip, and multi-city priced as one ticket, the way Google Flights prices it (or as separate one-ways per leg, if you prefer). - **Airports, cities or countries** β€” `From: "Los Angeles"`, `To: "United Kingdom"` searches every airport Google lists for them, as the site does. - **Every Google Flights filter** β€” stops, airlines and alliances (include or exclude), price cap, departure/arrival time windows, max duration, connecting airports (only via / never via), layover length, bags, no basic economy, less emissions only, and the sort order. - **Return flights per outbound** β€” for round trips, list the returns for the top outbound flights, each with its round-trip price and booking link. - **Price graph** β€” the cheapest fare for each departure date over up to 330 days, from the same search. - **Explore anywhere** β€” the cheapest trip from your city to every destination Google Flights Explore shows, worldwide or by region, for set or flexible dates. - **Many searches per run** β€” paste several URLs or list several routes; one startup fee, one dataset. - **A Google Flights link per flight** β€” opens Google's booking page for that exact itinerary. - **Deep itinerary data** β€” per-segment airport codes + full names, departure/arrival timestamps, duration, **aircraft model, flight number, legroom**, layovers (airport, city, minutes), CO2 emissions vs typical, bags included in the fare, plus carrier and booking token. - **Booking options (who sells it & for how much)** β€” optionally resolve, per itinerary, the airlines/OTAs selling the fare with **per-option price, fare name (e.g. "Blue Basic"), baggage fee, booking domain and a click-through URL**. No login needed. - **Price insights** β€” current vs typical price and the delta, straight from Google. - **Best & other flights** β€” every row is tagged `best` or `other` so you can rank instantly. - **Global** β€” any market, currency and language (`gl` / `curr` / `hl`). - **Spreadsheet or JSON** β€” flat dashed columns (`price-usd`, `segments-0-aircraft`…) for Excel/Sheets, or nested objects for pipelines. ### The sticker price vs your final bill Cheaper-looking Google Flights actors exist on the Store. Two cost lines never show on a listing's price tag, so check them before comparing per-row prices: | | This Actor | A typical "$0.20/1k" listing | |---|---|---| | **Proxy cost** | **Included for paying runs** β€” nothing extra is metered to your Apify account. (Free-plan runs use your own Apify proxy.) | Runs through **your** `proxyConfiguration`, so the proxy traffic each search needs is billed to your Apify plan **on top of** the row price. | | **What one row holds** | A whole itinerary: per-segment aircraft, flight number, legroom, times, layovers, CO2, bags in the fare, booking token, a link to that exact flight β€” plus optional booking options, return flights and price-graph rows. | Row depth varies between actors. Compare an actual output row, not the price alone. | | **Filters and your bill** | Every Google filter runs inside the search (stops, airlines and alliances with return-leg overrides, time windows, duration, connecting airports, layover length, bags, basic economy, emissions), so non-matching flights are never delivered or billed. | Fewer server-side filters mean more rows you did not want, delivered and billed. | | **Track record** | On the Store since June 2026, 71,000+ runs. | β€” | For one small unfiltered search, a cheaper sticker can genuinely cost less in total. For filtered, scheduled or bulk work, the included proxy and server-side filters usually turn the comparison around. The test that settles it: run the same search on both and read the two bills. ### Overview This Actor runs Google Flights searches for a route, date and passenger mix and returns the sorted result set (best + other flights) plus price insights as structured itineraries. Output is **one row per itinerary**. Each itinerary nests its flight segments (with per-segment aircraft, flight number, legroom and times). For multi-city, each row is a first-leg flight priced as the whole ticket, and the top rows carry the later legs in `leg-2-…`, `leg-3-…` columns. Optional return-flight, price-graph and Explore rows sit in the same dataset, told apart by `record-type`. One run can hold many searches: every URL in `startUrls` and every entry of `searches` is searched, and rows carry `search-index`. ### Supported Inputs | Input | What it does | |---|---| | **Google Flights URL** | `startUrls`: paste a Google Flights link instead of filling the route fields. Both shapes work: the address-bar URL after a search (`…/travel/flights/search?tfs=…`) and a text-query URL (`…/travel/flights?q=Flights+from+DPS+to+LGK+on+2026-11-03`). Route, dates, cabin, passengers, the link's filters (airlines, connecting airports, layovers, stops) and the URL's `curr`/`hl`/`gl` are read from it. **Each URL is its own search**; the route fields are ignored when URLs are given. Explore links (`/travel/explore?tfs=…`) run as Explore searches, and a round-trip link with the outbound already picked lists that flight's return flights. A city in the link is searched as that city, the way the site does, not as a list of its airports: Google's Explore answers differ between the two. | | **Several searches per run** | `searches`: a list of objects with the same fields as the form, e.g. `[{"origin":"LAX","destination":"JFK","departDate":"2026-11-10"},{"origin":"Paris","destination":"Tokyo","departDate":"2026-12-01"}]`. Each entry needs its own route; everything else it leaves out comes from the form. Startup is charged once per run. | | **Explore (anywhere)** | `exploreDestinations`: list the cheapest trip from `origin` to every destination Google Flights Explore shows, cheapest first, worldwide or in one region (`exploreRegion`), for your dates or for flexible dates (`exploreMonth`, `exploreTripLength`). | | **Route + dates** | `origin`, `destination`, `departDate` (+ optional `returnDate`). IATA codes, e.g. `LAX`, `JFK`; **comma-separate for multi-airport search**, e.g. `LAX,BUR` β†’ `JFK,EWR`. **City, region or country names** work too (`Paris`, `New York`, `United Kingdom`): Google searches all their airports. Separate several names with `;`. | | **Stops filter** | `maxStops`: `0` = nonstop only, `1` = ≀1 stop, `2` = ≀2 stops. | | **Airlines filter** | `airlines`: include only these airlines, by code or by name as Google Flights shows them, e.g. `["DL"]` or `["Air France","KLM"]`. `alliances`: `ONEWORLD`, `SKYTEAM`, `STAR_ALLIANCE`. `excludeAirlines`: codes or alliances to leave out. | | **Max price** | `maxPrice`: only itineraries at or below this price (in the selected currency). | | **Times & duration** | `outboundDepartureTime`, `outboundArrivalTime`, `returnDepartureTime`, `returnArrivalTime` as hour windows like `6-12`; `maxDurationHours`. | | **Connections** | `connectOnlyVia` / `neverConnectVia` (airport codes), `minLayoverHours`, `maxLayoverHours`. | | **Fare filters** | `checkedBags` (0-2) and `carryOnBags` (0-1) price the fare with bags; `excludeBasicEconomy`; `lessEmissionsOnly`. | | **Sort** | `sortBy`: `top` (Google's order), `price`, `departure`, `arrival`, `duration`, `emissions`. | | **Price graph** | `priceGraphDays`: also return the cheapest fare per departure date for this many days (up to 330), one row per date, ranked by `price-rank`. | | **Date grid** | `dateGridDays`: round trips get Google's date grid, the cheapest price for every departure date Β±N days Γ— return date Β±N days around yours (3 β†’ 7 Γ— 7 = 49 prices). `priceCalendarOnly` writes just the graph and grid, no flights. | | **Relative dates** | `departDaysAhead` (depart N days after the run day), `tripLengthDays` (return N days later) and `departDateWindowDays` (also search the next N dates). Saved and scheduled runs keep searching ahead instead of a fixed date. | | **Return flights** | `returnFlightsTop` + `returnFlightsPerOutbound`: round trips list the return flights for the top N outbound flights. | | **Booking options** | `resolveBookingOptions`: for each itinerary, fetch who sells the fare (airline/OTA) with price, fare name, baggage fee and a booking URL. Capped by `maxBookingItineraries`. One-way, round-trip & multi-city. `resolveBookingUrls` also follows each link to the seller's own booking page (e.g. a jetblue.com or aa.com link with the flights filled in). | | **Multi-city** | `multiCityLegs`: one entry per leg as `ORIGIN-DEST-DATE` (e.g. `LAX-JFK-2026-08-04`). Priced as one ticket by default (`multiCityPricing: single_ticket`); the top `multiCityCompleteTop` rows get their later legs picked. `separate_tickets` searches each leg as its own one-way. | | **Return-only filters** | `returnMaxStops`, `returnAirlines`, `returnExcludeAirlines`: round trips can filter the return differently, e.g. nonstop out and up to 1 stop back. | | **Explore a country** | `exploreCountry`: Explore limited to one country (e.g. `Italy`), with the map zoomed onto it so smaller towns show up. Pasted Explore links limited to a country work too. | | **Passengers & cabin** | `adults`, `children`, `infantsInSeat`, `infantsOnLap`, `cabinClass`. | | **Locale** | `market` (gl), `currency` (curr), `language` (hl). `market` takes an ISO country code; `UK` and country names are converted (UK β†’ GB). | **Not supported:** hotels or car hire, live booking/checkout, seat selection. This Actor is flights-only. ### Use Cases | Audience | What they do with it | |---|---| | **Travel aggregators / OTAs** | Power a fare-comparison page across many routes and dates. | | **Fare-alert products** | Track a route + date daily and notify when the cheapest fare drops. | | **Revenue / pricing teams** | Snapshot competitor fares and price bands over time. | | **Data & ML pipelines** | Ingest multi-route fare data daily to model price movement. | | **Travel agencies** | Export structured itineraries for clients on demand. | | **Researchers** | Build open fare/route datasets for connectivity analysis. | ### Input Configuration | Field | Type | Required | Notes | |---|---|---|---| | `startUrls` | array | β€” | Google Flights URLs (`tfs=` or `q=` links). Each URL is a search of its own; route, dates, cabin, passengers and `curr`/`hl`/`gl` come from it, and the route fields below are ignored. | | `searches` | array | β€” | More searches in the same run: objects with the form's fields, each with its own route. | | `origin` | string | β€” | Airport code (`LAX`), codes (`LAX,BUR`), or a city/region/country name (`Los Angeles`, `United Kingdom`; several names separated by `;`). Defaults to `LAX`. | | `destination` | string | β€” | Same forms as `origin`. Defaults to `JFK`. | | `departDate` | string | β€” | `YYYY-MM-DD`. Defaults to ~30 days out if empty. | | `returnDate` | string | β€” | Omit for one-way; set for round-trip. | | `multiCityLegs` | array | β€” | List of `ORIGIN-DEST-DATE` strings, e.g. `["LAX-JFK-2026-08-04","JFK-MIA-2026-08-10"]`. Overrides the single-route fields. | | `multiCityPricing` | enum | β€” | `single_ticket` (default): the whole trip as one ticket, as Google prices it. `separate_tickets`: each leg as its own one-way search (often cheaper in total, but separate bookings). | | `multiCityCompleteTop` | integer | β€” | One-ticket multi-city: how many first-leg flights get their later legs picked. Default `5`. | | `departDaysAhead` | integer | β€” | Depart this many days after the day the run starts. Wins over `departDate`. | | `tripLengthDays` | integer | β€” | Return this many days after departure. Wins over `returnDate`. | | `departDateWindowDays` | integer | β€” | Also search each of the next N departure dates (max 30), each as its own search, trip length kept. | | `adults` | integer | β€” | Default 1. Google's limits apply: at most 9 travellers, no more lap infants than adults, at most 2 infants per adult (the run stops with a message past them, since Google would quietly price a different search). | | `children` / `infantsInSeat` / `infantsOnLap` | integer | β€” | Default 0. | | `cabinClass` | enum | β€” | `economy` Β· `premium_economy` Β· `business` Β· `first`. | | `maxStops` | integer | β€” | `0` = nonstop only, `1` = ≀1 stop, `2` = ≀2 stops. Empty = any. | | `airlines` | array | β€” | Include only these airlines: codes or names, e.g. `["DL","AA"]` or `["Air France","KLM"]`. Empty = all. | | `maxPrice` | integer | β€” | Only itineraries at or below this price, in the selected currency. Empty = no cap. | | `alliances` | array | β€” | `ONEWORLD`, `SKYTEAM`, `STAR_ALLIANCE`. Joins `airlines` (either matches). | | `excludeAirlines` | array | β€” | Airline codes and/or alliances to leave out. | | `outboundDepartureTime` / `outboundArrivalTime` | string | β€” | Hour window, 24-hour clock, e.g. `6-12`. Multi-city legs all use the outbound window. | | `returnDepartureTime` / `returnArrivalTime` | string | β€” | Round trips: hour window for the return. | | `returnMaxStops` / `returnAirlines` / `returnExcludeAirlines` | integer / array | β€” | Round trips: the return's own stops and airlines, over the trip-wide filters. | | `maxDurationHours` | integer | β€” | Longest journey per direction, layovers included. | | `connectOnlyVia` / `neverConnectVia` | array | β€” | Airport codes where connections must / must never happen. | | `minLayoverHours` / `maxLayoverHours` | integer | β€” | Allowed connection time. | | `checkedBags` / `carryOnBags` | integer | β€” | Price fares with bags, as Google's Bags filter does: totals for the whole party, at most one of each per traveller with a seat. | | `excludeBasicEconomy` | boolean | β€” | Leave out basic-economy fares. | | `lessEmissionsOnly` | boolean | β€” | Only flights Google marks as lower emissions. | | `sortBy` | enum | β€” | `top` Β· `price` Β· `departure` Β· `arrival` Β· `duration` Β· `emissions`. Default `top`. | | `priceGraphDays` | integer | β€” | Days of price graph from the departure date (0-330). One row per date. Default `0` (off). | | `dateGridDays` | integer | β€” | Round trips: date grid of departure Β±N Γ— return Β±N days (0-7). One row per date pair. Default `0` (off). | | `priceCalendarOnly` | boolean | β€” | Only the price-graph and date-grid rows, no flight rows. Default `false`. | | `searchSummaryRow` | boolean | β€” | One `search-summary` row per search: flights found, cheapest price and flight, cheapest nonstop, price level, typical range, price history. Default `false`. | | `returnFlightsTop` | integer | β€” | Round trips: list return flights for the first N outbound flights. Default `0` (off). | | `returnFlightsPerOutbound` | integer | β€” | Return flights listed per outbound flight. Default `5`. | | `exploreDestinations` | boolean | β€” | Explore mode: cheapest trips from `origin` to anywhere instead of flights to `destination`. Default `false`. | | `exploreCountry` | string | β€” | Explore: only destinations in this country, as Google names it (`Italy`, `Japan`, `United States`). | | `exploreRegion` | enum | β€” | `anywhere` Β· `europe` Β· `asia` Β· `middle_east` Β· `africa` Β· `north_america` Β· `central_america_caribbean` Β· `south_america` Β· `oceania`. Default `anywhere`. | | `exploreMonth` | enum | β€” | Flexible dates: `next_6_months` or a month name (`january` … `december`). Used when no `departDate` is set. | | `exploreTripLength` | enum | β€” | Flexible dates: `weekend` Β· `1_week` Β· `2_weeks` Β· `one_way`. Used when no `departDate` is set. | | `resolveBookingOptions` | boolean | β€” | Resolve per-itinerary booking options (airlines/OTAs + price, fare name, baggage, URL). Default `false`. One-way, round-trip & multi-city. | | `maxBookingItineraries` | integer | β€” | When the above is on, how many top itineraries to resolve (one extra request each). Default `10`. | | `includeRawData` | boolean | β€” | Attach Google's own itinerary array to each flight row as `raw-google`. Default `false`. | | `resolveBookingUrls` | boolean | β€” | Also follow each booking link to the seller's own page, as `booking-option-{n}-final-url`. One extra request per option. Default `false`. | | `currency` | string | β€” | ISO 4217, e.g. `USD`, `EUR`. Default `USD`. When Google doesn't price in it for the market, rows carry the currency Google actually used. | | `market` | string | β€” | ISO country code, e.g. `US`, `GB`. `UK` and country names are converted (UK β†’ GB). Default `US`. | | `language` | string | β€” | e.g. `en`, `de`. Default `en`. | | `maxItems` | integer | β€” | Max itineraries to return. Default 100. | | `proxy` | object | β€” | Residential proxy, **on by default** and recommended. The default works out of the box. | Everything is optional β€” run it with no input at all and it searches **LAX β†’ JFK ~30 days out** as a sane default. Provide `origin`/`destination`/`departDate` (+ optional `returnDate`) for a normal search, `multiCityLegs` for multi-city, or a Google Flights URL in `startUrls`. #### Example input ```json { "origin": "LAX", "destination": "JFK", "departDate": "2026-08-04", "adults": 1, "cabinClass": "economy", "currency": "USD", "market": "US", "maxItems": 50 } ``` Multi-city: ```json { "multiCityLegs": ["LAX-JFK-2026-08-04", "JFK-MIA-2026-08-10"], "adults": 1, "maxItems": 40 } ``` City to country, with filters, a price graph and the return flights for the top 3 outbound flights: ```json { "origin": "Los Angeles", "destination": "United Kingdom", "departDate": "2026-11-10", "returnDate": "2026-11-17", "maxStops": 1, "alliances": ["ONEWORLD"], "outboundDepartureTime": "6-14", "carryOnBags": 1, "sortBy": "price", "priceGraphDays": 60, "returnFlightsTop": 3, "returnFlightsPerOutbound": 5, "maxItems": 50 } ``` Explore β€” the cheapest weekend trips from Chicago to Europe in December: ```json { "origin": "Chicago", "exploreDestinations": true, "exploreRegion": "europe", "exploreMonth": "december", "exploreTripLength": "weekend", "maxItems": 50 } ``` Several searches in one run: ```json { "searches": [ { "origin": "LAX", "destination": "JFK", "departDate": "2026-11-10" }, { "origin": "Paris", "destination": "Tokyo", "departDate": "2026-12-01", "returnDate": "2026-12-15" } ], "maxItems": 50 } ``` From a Google Flights URL: ```json { "startUrls": ["https://www.google.com/travel/flights?q=Flights+from+DPS+to+LGK+on+2026-11-03+oneway&curr=INR&hl=en&gl=IN"], "maxItems": 50 } ``` ### Output Overview One row per **itinerary**, tagged `best` or `other`. Each itinerary nests its **segments** (dashed columns like `segments-0-aircraft`) and its **layovers** (`layovers-0-airport-code`, …). A nonstop itinerary has one segment; connections have more. Multi-city rows also carry `multi-city-leg`. Every row has a `record-type`: | `record-type` | What it is | |---|---| | `flight` | An itinerary from the search (for round trips, the outbound flight with the cheapest round-trip price). | | `return-flight` | Only with `returnFlightsTop`: a return flight for the outbound row whose `index` equals its `outbound-index`. `price` is the total round-trip price for that pair, and `google-flights-url` opens the booking page for both flights. | | `price-graph` | Only with `priceGraphDays`: one departure date with its cheapest fare (`depart-date`, `return-date` for round trips, `price`, `cheapest-in-range`, `price-rank`). | | `date-grid` | Only with `dateGridDays`: one departure/return date pair with its cheapest round-trip price (`depart-date`, `return-date`, `trip-length-days`, `price`, `price-rank`, `cheapest-in-grid`). | | `search-summary` | Only with `searchSummaryRow`: one row per search with `flights-found`, `cheapest-price`, `cheapest-flight-numbers`, `cheapest-nonstop-price`, `price-level`, `typical-price`, the typical range and `price-history` (a list of `{date, price}`). | | `explore-destination` | Only with `exploreDestinations`: one destination with its cheapest trip (`destination-name`, `destination-country`, `to-code`, `price`, dates, `trip-length-days`, `carrier-code`, `stops`, `duration-minutes`, `hotel-price-per-night`, `latitude`/`longitude`, `image-url`, `google-flights-url`). | ### Output Samples Real row from a test run (LAXβ†’JFK with one stop, abbreviated): ```jsonc { "index": 11, "source": "google-flights", "record-type": "flight", "price": 214, "price-usd": 214, "currency": "USD", "bucket": "other", "carrier-code": "AS", "carrier-name": "Alaska", "from-code": "LAX", "to-code": "JFK", "depart-date": "2026-10-31", "depart-time": "07:00", "arrive-date": "2026-10-31", "arrive-time": "19:25", "stops": 1, "duration-minutes": 565, "co2-grams": 431000, "co2-typical-grams": 334000, "co2-vs-typical-percent": 29, "co2-label": "higher", "checked-bags-included": 0, "carry-on-bags-included": 1, "booking-token": "CjRINVp0Q3ZtRkZpYzBB…", "layovers-0-airport-code": "PDX", "layovers-0-airport-name": "Portland International Airport", "layovers-0-city": "Portland", "layovers-0-minutes": 77, "segments-0-from-code": "LAX", "segments-0-to-code": "PDX", "segments-0-depart": "2026-10-31T07:00", "segments-0-arrive": "2026-10-31T09:31", "segments-0-duration-minutes": 151, "segments-0-airline": "Alaska", "segments-0-flight-number": "AS668", "segments-0-aircraft": "Boeing 737MAX 9 Passenger", "segments-0-legroom": "31 in", "segments-1-from-code": "PDX", "segments-1-to-code": "JFK", "segments-1-flight-number": "AS18", "google-flights-url": "https://www.google.com/travel/flights/booking?tfs=CBwQAhpfEgoyMDI2LTEwLTMx…" } ``` A price-graph row (JFKβ†’LHR round trip, 7 nights): ```json { "record-type": "price-graph", "source": "google-flights", "from-code": "JFK", "to-code": "LHR", "depart-date": "2026-11-10", "return-date": "2026-11-17", "price": 899, "currency": "USD", "cheapest-in-range": false, "google-flights-url": "https://www.google.com/travel/flights?q=Flights%20from%20JFK%20to%20LHR%20on%202026-11-10%20through%202026-11-17&curr=USD&hl=en&gl=US" } ``` ### Key Output Fields **Itinerary** - `price` (in the run's `currency`), `currency`, `bucket` (`best` / `other`). `price-usd` holds the same number for older integrations, whatever the currency. - `carrier-code`, `carrier-name` - `record-type` β€” `flight`, `return-flight`, `price-graph` or `explore-destination` (see above) - `search-index`, `search-label` β€” which search of the run the row belongs to, e.g. `link 2` or `Paris β†’ Tokyo` (only on runs with several searches) - `trip-type`, `cabin-class`, `passengers` β€” what was searched (Explore rows too, with `trip-type: explore`) - `origin-searched`, `destination-searched` β€” what each typed or linked place matched, e.g. `Paris, France` or `Chicago` - `search-url` β€” this whole search on Google Flights - `price-level` (`low` / `typical` / `high`), `typical-price`, `typical-price-low`, `typical-price-high` β€” Google's price insights for the search; the first row also carries `price-history` (`date:price|…`, Google's recent cheapest price per day) - `data-source` β€” which Google results view the row came from: the full results list (the normal case) or `search-page`, Google's first results page, used when the full list didn't come through (see the FAQ) - `filters-applied` β€” the filters this search sent to Google (only when it set any) - `filter-warnings` β€” filters this route can't satisfy, e.g. a connecting airport Google doesn't offer on the route, an airline with no flights there, or a maximum duration below the quickest trip - `from-code`, `to-code`, `stops`, `duration-minutes` (the whole journey, layovers included) - `depart-date` / `depart-time` / `arrive-date` / `arrive-time` - `co2-grams`, `co2-typical-grams`, `co2-vs-typical-percent`, `co2-label` (`lower` / `typical` / `higher`) β€” Google's emissions estimate - `checked-bags-included`, `carry-on-bags-included` β€” bags the shown fare includes, for the whole party - `google-flights-url` β€” opens Google's booking page for this itinerary (a round trip's outbound row opens the list of its return flights) - `booking-token` β€” Google's booking-handoff token - `labels` β€” `best` (Google's top flights), `cheapest`, `fastest` across the search's whole result list; also as `is-cheapest` / `is-fastest` - `raw-google` β€” with `includeRawData`: Google's own itinerary array, for fields this Actor doesn't map - `multi-city-pricing` (`single-ticket` / `separate-tickets`), `multi-city-legs` β€” on multi-city runs; one-ticket rows' `price` is the whole trip - `leg-{k}-…` β€” one-ticket multi-city rows whose later legs were picked: `from-code`, `to-code`, `depart-date`, `depart-time`, `arrive-date`, `arrive-time`, `duration-minutes`, `stops`, `carrier-code`, `carrier-name`, `flight-numbers`; plus `ticket-price` and a `google-flights-url` that opens the whole ticket - `multi-city-leg` β€” separate-tickets multi-city runs: which leg the row belongs to - `return-flights-count` β€” on outbound rows that got their returns listed **Layovers** (`layovers-{n}-…`) - `airport-code`, `airport-name`, `city`, `minutes`; `depart-airport-code` when the connection changes airport **Return flights** (`record-type: return-flight`) - the itinerary fields above for the return flight, plus `outbound-index`, `return-index`, `outbound-flight-numbers`; `data-source: search-page` when they came from Google's results page because the return-flights request was declined **Segments** (`segments-{n}-…`) - `from-code` / `from-name` / `to-code` / `to-name` - `depart` / `arrive` β€” ISO timestamps - `duration-minutes`, `airline`, `flight-number` - `aircraft`, `legroom` - `operated-by` β€” the airline that flies it when another sells it (e.g. "SkyWest DBA United Express") - `co2-grams` β€” this flight's CO2 estimate - `amenities` β€” on-board amenities as Google lists them, e.g. "free Wi-Fi; in-seat power & USB outlets; live TV"; `wifi` (`free` / `fee`); `legroom-rating` (`below average` / `average` / `above average`) **Booking options** (only when `resolveBookingOptions` is on) - `booking-options-count` β€” number of bookable options found - `cheapest-booking-price-usd` / `cheapest-booking-provider` β€” the cheapest option at a glance - `booking-option-{n}-…` β€” per option: `provider`, `price-usd`, `fare-name` (e.g. "Blue Basic"), `domain`, `url` (click-through booking link; it opens the seller's page with a plain click), `final-url` (with `resolveBookingUrls`: the seller's own booking page), `provider-code`, `is-airline` (airline or agency), `fare-code`, `flight-numbers`, `basic-economy` (Google's basic-economy flag), `legroom`, `first-bag-fee` / `second-bag-fee` (checked bags, when Google lists them), `fare-features` (the fare's conditions as Google lists them, e.g. "1 free carry-on; no seat selection; changes for a fee; no refunds"), `changes` / `refunds` / `seat-selection` / `carry-on` (`free`, `fee`, `partial` or `none`), `booking-method` (`online` / `phone`), `phone` and `fee-included` (e.g. an airline's phone-booking fee already in the price) - `bag-policy-links` β€” each airline's baggage-policy page, as Google links it under the booking options - `booking-options-for-return` / `booking-options-round-trip-price` β€” round trips: the return flight the options were priced with (the cheapest return, which gives the trip's lowest total); up to 20 offers are listed per flight - `booking-options-error`, `return-flights-error` β€” why a flight has no booking options or return flights, when it doesn't - `booking-options-source` β€” `booking-page` when Google declined the booking request and the options were read from its booking page instead (same sellers, fares, prices and conditions, but no booking links); absent in the normal case - `booking-option-{n}-separate-tickets` β€” `true` when the offer is several tickets bought one by one ### FAQ **Is this an official Google API?** No. It's an independent scraper that reads publicly available Google Flights search results. Not affiliated with or endorsed by Google. **Do I need a proxy?** Yes β€” a residential proxy is on by default and recommended for reliable results, and the default works out of the box. If you run from your own residential connection you can turn it off. **Does it do multi-city?** Yes. Set `multiCityLegs` to a list of `ORIGIN-DEST-DATE` strings (e.g. `["LAX-JFK-2026-08-04","JFK-MIA-2026-08-10"]`). By default the trip is priced as one ticket, exactly as Google Flights shows it: each row is a first-leg flight with the whole ticket's price, and the top `multiCityCompleteTop` rows get the cheapest flight on each later leg (`leg-2-…` columns) and a link to the full ticket. With `multiCityPricing: separate_tickets`, each leg is searched as its own one-way instead (rows tagged `multi-city-leg`, `maxItems` split across legs), which can be cheaper in total but means separate bookings. **Can I paste a Google Flights link instead of filling the fields?** Yes. Put the URL in `startUrls`: either the address-bar URL after you search on google.com/travel/flights (it contains `tfs=`), or a text-query URL like `https://www.google.com/travel/flights?q=Flights+from+DPS+to+LGK+on+2026-11-03`. The route, dates, cabin, passengers and the URL's currency, language and country are read from it. When a URL is given, the From/To and date fields are ignored, so you don't have to clear them. Paste as many URLs as you like: each one is its own search in the same run, and its rows carry `search-index`. **Can I run several routes in one run?** Yes. Paste several URLs, or list the searches in `searches` (each entry takes the same fields as the form, with its own route). The run's startup fee is charged once, and every search's rows land in the same dataset with `search-index`. **Can I search "anywhere", like Google Flights Explore?** Yes. Set `exploreDestinations: true` and `origin`. The run lists the cheapest trip to every destination Explore shows, cheapest first, worldwide or in one region (`exploreRegion`). "Anywhere" reads Google's own map around your origin (the nearby, often cheapest places) plus the world and every region map, typically 400-500 destinations. Give dates for those exact dates, or leave them empty and pick a month and trip length (weekend, 1 week, 2 weeks, one-way). **What does `data-source: search-page` mean?** When the full results list doesn't come through for a search, the run delivers the rows from Google's first results page instead of ending empty. Those rows carry `data-source: search-page`. On busy US routes the page holds the whole list; on other routes it can hold fewer itineraries, though every nonstop and the cheapest fare stay, and a few prices (about 4%) are a first draft that Google updates moments later. Your price cap, duration and time windows are applied to those rows too. Searches with lap infants, bags, basic economy left out or the emissions filter don't use the page. **What about the "Cheapest" tab on Google Flights?** It re-ranks the same itineraries by price; Google's data behind it is the same set this actor returns. Set `sortBy: "price"` to get that order. **One-way vs round-trip?** Omit `returnDate` for one-way; include it for round-trip. Round-trip rows are the outbound flights, priced as the cheapest round trip, the same as the first page on Google Flights. Set `returnFlightsTop` to also get the return flights for the top outbound flights. **Can I search from a city or a whole country?** Yes. Type the name in From or To (`Paris`, `New York`, `Japan`, `United Kingdom`). It is looked up in Google Flights' own place search and searched the way the site does, across every airport Google lists for it. Three-letter values are read as airport codes, and several names go in one field separated by `;`. **What is the price graph?** Google's cheapest fare for each departure date. Set `priceGraphDays` (up to 330) and the run adds one `price-graph` row per date, starting at your departure date, with the cheapest date flagged by `cheapest-in-range`. Round trips keep your trip length. Each date counts as one result. **Can I open a result on Google Flights?** Yes. Every flight row has `google-flights-url`, which opens Google's booking page for that exact itinerary, with your passengers and cabin, and the airlines and agencies selling it. **What currency / market?** `currency` (ISO 4217), `market` (country), `language`. Defaults USD / US / en. Use an ISO country code for `market` (GB for the United Kingdom); `UK` and country names are converted automatically. **How many results per search?** The Actor requests Google's **full** result set (the same as clicking "View more flights") β€” typically **~100–150 itineraries** across best + other on a busy route, controlled by `maxItems`. Run many routeΓ—date searches to build an even larger dataset. **Why are some itineraries `best` and others `other`?** Google groups its top recommendations as "best" and the rest as "other". Both are returned and tagged. **Can I get who sells the ticket and for how much?** Yes β€” set `resolveBookingOptions: true`. For each itinerary (up to `maxBookingItineraries`), the Actor resolves the bookable options β€” the airline and/or OTAs selling that fare β€” with each option's price, fare name (e.g. "Blue Basic"), first checked-bag fee, booking domain and a click-through URL. It adds extra requests per itinerary (one for one-way/multi-city; round-trip does a select-outbound β†’ pick-return β†’ book flow), so it's capped and off by default. Supported for one-way, round-trip and multi-city. ### Support Found a bug or need a field that isn't exposed? Open an issue on the Actor's **Issues** tab on Apify, or reach out via the Apify Store profile. Include your input JSON and the run ID. ### Additional Services Need a custom flight or travel data pipeline β€” a different source, a bespoke schema, scheduled delivery to S3/BigQuery, or fare monitoring with alerts? Custom scraping and data-engineering work is available via the Apify Store profile. ### Explore More Scrapers **✈️ More flight scrapers:** - [Skyscanner Flight Scraper](https://apify.com/memo23/skyscanner-scraper) β€” 180+ fields per itinerary, Best/Cheapest/Fastest tags, OTA aggregation - [Ryanair Scraper](https://apify.com/memo23/ryanair-scraper) β€” budget fares & the cheapest routes Google misses - [Award Flights Scraper](https://apify.com/memo23/award-flights-scraper) β€” miles & points award availability (Flightpoints + Roame) Also: [Expedia & Hotels.com Scraper](https://apify.com/memo23/expedia-scraper) Β· [140+ other scrapers](https://apify.com/memo23) ### πŸ€– For AI Agents & LLM Apps Compact reference for AI agents calling this actor via the [Apify MCP server](https://mcp.apify.com) or the Apify API (actor: `memo23/google-flights-scraper`). **Purpose:** Scrapes Google Flights search results β€” one dataset row per itinerary (price, carrier, stops, times, layovers, CO2, included bags, per-segment aircraft/flight number/legroom, booking token, Google Flights link) for one-way, round-trip and multi-city routes from airports, cities or countries, with Google's filters, and optionally the airlines/OTAs selling each fare, return flights per outbound and the price graph. **Minimal input:** ```json { "origin": "LAX", "destination": "JFK", "departDate": "2026-08-04", "maxItems": 50 } ``` Multi-city variant: `{ "multiCityLegs": ["LAX-JFK-2026-08-04", "JFK-MIA-2026-08-10"], "maxItems": 40 }`. Add `returnDate` for round-trip. **Output:** one dataset row per itinerary β€” `record-type` (`flight`; `return-flight`, `price-graph` and `explore-destination` rows appear only when asked for), `price`, `price-usd` (same number), `currency`, `bucket` (`best` / `other`), `carrier-code`, `carrier-name`, `from-code`, `to-code`, `stops`, `duration-minutes`, `depart-date`, `depart-time`, `arrive-date`, `arrive-time`, `co2-grams`, `co2-typical-grams`, `co2-vs-typical-percent`, `co2-label`, `checked-bags-included`, `carry-on-bags-included`, `google-flights-url`, `booking-token`, `multi-city-leg` (multi-city runs only), `layovers-{n}- {airport-code, airport-name, city, minutes}`, `segments-{n}- {from-code, from-name, to-code, to-name, depart, arrive, duration-minutes, airline, flight-number, aircraft, legroom}`; with `resolveBookingOptions` also `booking-options-count`, `cheapest-booking-price-usd`, `cheapest-booking-provider`, `booking-option-{n}- {provider, price-usd, fare-name, domain, url}`. **Behaviors an agent should know:** - Always set `maxItems` (default 100) β€” a busy route returns ~100–150 itineraries; one-ticket multi-city lists the first leg's flights (often 10-40). - Scheduled price tracking: use `departDaysAhead` + `tripLengthDays` instead of fixed dates, and `searchSummaryRow` or `priceCalendarOnly` for compact output. - `multiCityLegs` overrides `origin`/`destination`/`departDate`/`returnDate`; omit `returnDate` for one-way. - `startUrls` (Google Flights `tfs=` or `q=` URLs) overrides all route fields, `multiCityLegs` included; each URL is its own search. `searches` (a list of form-shaped objects, each with its own route) adds more searches to the same run. Rows of multi-search runs carry `search-index`. - `exploreDestinations: true` with `origin` lists the cheapest trips to anywhere (`exploreRegion`, `exploreMonth`, `exploreTripLength`), one `explore-destination` row per place. - Residential proxy is on by default and recommended. Keep it on. - `resolveBookingOptions` is off by default and adds extra requests per itinerary; capped by `maxBookingItineraries` (default 10). - `origin`/`destination` accept city or country names; `priceGraphDays` and `returnFlightsTop` add extra rows, filter them with `record-type`. - Billing: $2 per 1,000 results (every row, extras included). - Flights only β€” no hotels, car hire, live booking/checkout or seat selection. ### ⚠️ Disclaimer This Actor accesses publicly available flight search data on Google Flights for legitimate research, market-intelligence and business-analysis purposes. It is **not affiliated with, endorsed by, or sponsored by Google LLC.** "Google Flights" is a trademark of Google LLC; it is used here only to describe the data source. Use of this Actor must comply with Google's Terms of Service and all applicable laws, including data-protection regulations (GDPR, CCPA, etc.). The Actor's authors are not responsible for any misuse. Users must: - Respect rate limits and avoid overloading Google's infrastructure - Not use scraped data to violate user privacy or terms - Use the data in compliance with applicable jurisdictions - Not republish scraped content in violation of copyright We do not store any scraped data; the Actor returns it directly to your Apify dataset for your authorized use. ### SEO Keywords google flights scraper, google flights api, google flights data, google flights price graph, flight emissions data, flights from city or country, google flights explore scraper, cheapest flights anywhere, flight price scraper, airfare scraper, flight scraper, flight itinerary scraper, multi-city flight scraper, round-trip flight scraper, cheapest flight finder, flight price monitoring, fare alert data, travel data api, airline schedule scraper, flight comparison data, google flights json export, google flights csv export, flight deals scraper, apify flight scraper, flight price tracker, airfare monitoring api, flight route scraper, booking token scraper, flight segment data # Actor input Schema ## `startUrls` (type: `array`): Paste Google Flights URLs instead of filling the route fields β€” either the address-bar URL after a search (with tfs=…) or a query URL like https://www.google.com/travel/flights?q=Flights+from+DPS+to+LGK+on+2026-11-03 (city names work too: q=Flights+from+Paris+to+New+York+on+2026-11-03). Each URL is its own search: route, dates, cabin, passengers and the URL's curr/hl/gl are read from it, and the From/To, date and multi-city fields below are ignored, so you don't need to clear them. The link's own filters come along too (airlines, connecting airports, layover length, stops). An Explore link (google.com/travel/explore?tfs=…) runs as an Explore search, and a round-trip link with the outbound flight already picked lists that flight's return flights, as the site does. The settings below still apply. ## `searches` (type: `array`): Run several searches in one run. Each entry is an object with the same fields as this form (origin, destination, departDate, returnDate, multiCityLegs, exploreDestinations, filters…). Anything an entry leaves out comes from the form, except the route: give each entry its own origin/destination/dates. Rows carry search-index (1, 2, …) so you can tell the searches apart. Startup is charged once per run, not per search. ## `origin` (type: `string`): Where the trip starts: an airport IATA code (LAX), several codes comma-separated (LAX,BUR,LGB), or a city, region or country name as Google Flights spells it ("Los Angeles", "Paris, France", "United Kingdom"). A name searches every airport Google lists for it. Separate several names with ";". Defaults to LAX if left empty. ## `destination` (type: `string`): Where the trip goes: an airport IATA code (JFK), several codes comma-separated (JFK,EWR,LGA), or a city, region or country name ("New York", "Japan"). Separate several names with ";". Defaults to JFK if left empty. ## `departDate` (type: `string`): Departure date. Leave empty to default to ~30 days from today (so the Actor always runs out of the box). Format YYYY-MM-DD, e.g. 2026-08-04. ## `returnDate` (type: `string`): Return date for a round trip. Leave empty for one-way. Format YYYY-MM-DD, e.g. 2026-08-11. ## `departDaysAhead` (type: `integer`): Instead of a fixed date: depart this many days after the day the run starts (e.g. 30). Wins over the departure date, so a saved or scheduled run keeps searching ahead. ## `tripLengthDays` (type: `integer`): Return this many days after departure (e.g. 7). Wins over the return date; works with either a fixed or a relative departure. ## `departDateWindowDays` (type: `integer`): Searches the departure date plus each of the next N days as separate searches (max 30), keeping the trip length. Rows carry search-label with the dates. Each date is a search of its own. ## `multiCityLegs` (type: `array`): For multi-city trips only. Add one row per leg as ORIGIN-DESTINATION-DATE, e.g. LAX-JFK-2026-08-04. Origin and destination take airport codes or names (Paris-Tokyo-2026-08-04). When set, this overrides the From / To / dates above. Leave empty for one-way or round-trip. ## `multiCityPricing` (type: `string`): single_ticket (default): the whole trip as one ticket, priced the way Google Flights shows it; each row is a first-leg flight with the ticket price, and the top rows get their later legs picked (leg-2-…, leg-3-… columns). separate_tickets: each leg searched on its own as a one-way, rows tagged multi-city-leg. ## `multiCityCompleteTop` (type: `integer`): With one-ticket pricing, how many of the cheapest-listed first-leg flights get their later legs picked (the cheapest flight on each later leg). Each takes one extra request per later leg. ## `adults` (type: `integer`): Number of adult passengers (12+). ## `children` (type: `integer`): Number of child passengers (2-11). ## `infantsInSeat` (type: `integer`): Infants with their own seat. ## `infantsOnLap` (type: `integer`): Infants on an adult's lap. ## `cabinClass` (type: `string`): Cabin class for the search. ## `currency` (type: `string`): ISO 4217 currency code for prices, e.g. USD, EUR, GBP. If Google doesn't price in it for the chosen market, the run says so and labels prices with the currency Google actually used. ## `market` (type: `string`): Country/market code, e.g. US, GB, DE. Affects pricing and availability. UK and country names such as Germany are accepted and converted (UK becomes GB). ## `language` (type: `string`): Language code, e.g. en, de, fr. ## `maxItems` (type: `integer`): Maximum number of itineraries to return. Default 100; a busy route typically has ~100-150. On multi-city runs the cap is split evenly across the legs. ## `maxStops` (type: `integer`): Filter by number of stops: 0 = nonstop only, 1 = up to 1 stop, 2 = up to 2 stops. Leave empty for any number of stops. ## `airlines` (type: `array`): Only flights from these airlines: two-letter codes or names as Google Flights shows them, e.g. \["DL"], \["Air France", "KLM"]. Leave empty for all airlines. ## `alliances` (type: `array`): Only flights from these alliances: ONEWORLD, SKYTEAM, STAR_ALLIANCE. Combines with Airlines above (either matches). ## `excludeAirlines` (type: `array`): Leave out these airlines (codes or names, e.g. \["Spirit", "F9"]) and/or alliances (\["SKYTEAM"]). ## `returnMaxStops` (type: `integer`): Round trips only: the return's own stops limit (0 = nonstop, 1, 2), over 'Max stops' above. E.g. nonstop out, up to 1 stop back. ## `returnAirlines` (type: `array`): Round trips only: airlines (codes or names) or alliances for the return flight, over the airlines above. ## `returnExcludeAirlines` (type: `array`): Round trips only: airlines or alliances to leave out of the return flight. ## `maxPrice` (type: `integer`): Only return itineraries at or below this price, in the selected currency. Leave empty for no price cap. ## `outboundDepartureTime` (type: `string`): Hour window for the outbound departure, 24-hour clock, e.g. 6-12 for morning departures or 18-24 for evening. Multi-city legs all use this window. ## `outboundArrivalTime` (type: `string`): Hour window for the outbound arrival, e.g. 8-20. ## `returnDepartureTime` (type: `string`): Round trips: hour window for the return departure, e.g. 12-24. ## `returnArrivalTime` (type: `string`): Round trips: hour window for the return arrival, e.g. 0-23. ## `maxDurationHours` (type: `integer`): Longest journey per direction, layovers included. ## `connectOnlyVia` (type: `array`): Connections must change planes at one of these airports, e.g. \["ORD","DFW"]. Nonstop flights still show. ## `neverConnectVia` (type: `array`): Never change planes at these airports, e.g. \["JFK"]. ## `minLayoverHours` (type: `number`): Shortest connection time allowed. Half hours work too, e.g. 1.5. ## `maxLayoverHours` (type: `number`): Longest connection time allowed. Half hours work too, e.g. 1.5. ## `checkedBags` (type: `integer`): Price fares with checked bags, as Google's Bags filter does: the total for the whole party, at most one per traveller with a seat (more makes Google refuse the search, so it is capped). Google adds the airline's bag fee to each price where it knows it. ## `carryOnBags` (type: `integer`): Price fares with carry-on bags: the total for the whole party, at most one per traveller with a seat (lap infants don't count). Each bag adds the airline's fee, e.g. 2 adults with 2 carry-ons pay two fees. ## `excludeBasicEconomy` (type: `boolean`): Leave out basic-economy fares (US carriers). ## `lessEmissionsOnly` (type: `boolean`): Only flights Google marks as lower emissions. ## `sortBy` (type: `string`): Order of the results: Google's top flights, or by price, departure time, arrival time, duration or emissions. ## `priceGraphDays` (type: `integer`): Also return Google's price graph: the cheapest fare for each departure date, starting at your departure date, for this many days (up to 330). Round trips keep your trip length. Each day is one row (record-type "price-graph"). 0 = off. ## `dateGridDays` (type: `integer`): Round trips only. Adds Google's date grid: the cheapest price for every departure date within Β±N days of yours paired with every return date within Β±N days of yours (3 β†’ a 7 Γ— 7 grid of 49 prices). One row per date pair, record-type date-grid, with price-rank (1 = cheapest). ## `priceCalendarOnly` (type: `boolean`): Write only the price-graph and date-grid rows, not the flights. A cheap way to watch prices across dates. Needs 'Price graph' days or a date grid. ## `searchSummaryRow` (type: `boolean`): Adds one row per search (record-type search-summary): flights found, the cheapest price and flight, the cheapest nonstop, Google's price level and typical range, and its recent price history as a list. Handy for price trackers. Counts as one result. ## `includeRawData` (type: `boolean`): Attach Google's own itinerary array to each flight row as raw-google (nested JSON), for fields this Actor doesn't map. Makes rows much larger. ## `returnFlightsTop` (type: `integer`): Round trips: list the return flights for the first N outbound flights, each with its round-trip price and a booking link (rows with record-type "return-flight", linked by outbound-index). 0 = off. ## `returnFlightsPerOutbound` (type: `integer`): How many return flights to list for each of those outbound flights. ## `resolveBookingOptions` (type: `boolean`): For each itinerary, fetch the bookable options β€” online travel agencies and airlines selling the fare, with per-option price, fare name (e.g. "Blue Basic"), booking domain and a booking URL. Adds extra requests per itinerary (more for round-trip), so it's capped by 'Max itineraries to resolve'. Works for one-way, round-trip and multi-city. ## `maxBookingItineraries` (type: `integer`): When 'Resolve booking options' is on, only the first N itineraries get their booking options resolved (each is an extra request). Default 10. ## `resolveBookingUrls` (type: `boolean`): With 'Resolve booking options' on, also follow each option's Google link to the airline's or agency's own booking page and add it as booking-option-N-final-url (e.g. an aa.com link with your flights filled in). One extra request per option. ## `bookingConcurrency` (type: `integer`): How many booking-option lookups to run in parallel when 'Resolve booking options' is on. Higher is faster but sends more concurrent requests through one IP; 1 = the old one-at-a-time behaviour. Default 6. ## `includeLccFares` (type: `boolean`): Also append the direct Ryanair fares that Google Flights structurally under-shows. For the same route and date(s), adds extra rows tagged source="ryanair" so you get the budget-airline prices Google misses. Works for the single origin/destination case (not multi-city). ## `exploreDestinations` (type: `boolean`): Instead of flights to one destination, list the cheapest trip from From to every destination Google Flights Explore shows (one row per destination, record-type "explore-destination", cheapest first). To is ignored. With a departure date (and return date) the trips use those dates; without, Google picks the cheapest dates for the month and trip length below. ## `exploreRegion` (type: `string`): Where to look. Anywhere searches the world map plus every region map, which lists the most places. ## `exploreCountry` (type: `string`): With Explore on: list only destinations in this country, as Google Flights names it (e.g. "Italy", "Japan", "United States"). The run also zooms the map onto the country, so smaller towns show up. ## `exploreMonth` (type: `string`): Without a departure date: when to travel. ## `exploreTripLength` (type: `string`): Without a departure date: the trip length, or one-way. ## `proxy` (type: `object`): Residential proxies recommended (on by default). The default works out of the box. ## Actor input object example ```json { "startUrls": [ "https://www.google.com/travel/flights?q=Flights+from+DPS+to+LGK+on+2026-11-03+oneway&curr=INR&hl=en&gl=IN" ], "searches": [ { "origin": "LAX", "destination": "JFK", "departDate": "2026-11-10" }, { "origin": "Paris", "destination": "Tokyo", "departDate": "2026-12-01", "returnDate": "2026-12-15" } ], "origin": "LAX", "destination": "JFK", "departDate": "2026-08-04", "departDateWindowDays": 0, "multiCityLegs": [ "LAX-JFK-2026-08-04", "JFK-MIA-2026-08-10" ], "multiCityPricing": "single_ticket", "multiCityCompleteTop": 5, "adults": 1, "children": 0, "infantsInSeat": 0, "infantsOnLap": 0, "cabinClass": "economy", "currency": "USD", "market": "US", "language": "en", "maxItems": 100, "airlines": [ "Air France", "KL" ], "alliances": [ "STAR_ALLIANCE" ], "excludeAirlines": [ "NK", "F9" ], "returnAirlines": [ "AA" ], "returnExcludeAirlines": [ "NK" ], "outboundDepartureTime": "6-12", "outboundArrivalTime": "8-20", "returnDepartureTime": "12-24", "returnArrivalTime": "0-23", "connectOnlyVia": [ "ORD", "DFW" ], "neverConnectVia": [ "JFK" ], "excludeBasicEconomy": false, "lessEmissionsOnly": false, "sortBy": "top", "priceGraphDays": 0, "dateGridDays": 0, "priceCalendarOnly": false, "searchSummaryRow": false, "includeRawData": false, "returnFlightsTop": 0, "returnFlightsPerOutbound": 5, "resolveBookingOptions": false, "maxBookingItineraries": 10, "resolveBookingUrls": false, "bookingConcurrency": 6, "includeLccFares": false, "exploreDestinations": false, "exploreRegion": "anywhere", "exploreMonth": "next_6_months", "exploreTripLength": "1_week", "proxy": { "useApifyProxy": true, "apifyProxyGroups": [ "RESIDENTIAL" ] } } ``` # Actor output Schema ## `results` (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 '' with your token const client = new ApifyClient({ token: '', }); // Prepare Actor input const input = { "origin": "LAX", "destination": "JFK" }; // Run the Actor and wait for it to finish const run = await client.actor("memo23/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 = { "origin": "LAX", "destination": "JFK", } # Run the Actor and wait for it to finish run = client.actor("memo23/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 '{ "origin": "LAX", "destination": "JFK" }' | apify call memo23/google-flights-scraper --silent --output-dataset ``` ## MCP server setup ```json { "mcpServers": { "apify": { "type": "http", "url": "https://mcp.apify.com/?tools=fetch-actor-details,memo23/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/ulPbFXCmcjxx3iPnp/builds/zBHArZhq8PNQmuAIh/openapi.json