Google Flights Prices API

What is Google Flights Prices API?

Google Flights Prices API collects live Google Flights prices and schedules as clean, structured data for travel startups, fare sites, travel agencies, analysts and developers, so you can work with flight fares the way you would with a Google Flights API. Paste one or many Google Flights links (or type a route) and get one row per flight option with price, airlines, flight numbers, times, stops, layovers, duration, cabin and carbon estimate. No coding is needed: the input is prefilled with one Los Angeles to New York search, so you can click Start right away; on the Apify Free plan you get up to 10 flights per run, shared by all searches.

⚠️ Apify Free plan: a run saves up to 10 flights in total, shared by all searches in that run. If you add several routes, the first ones can use up the 10 flights and the rest end as skipped. Test one route first.

You get airfare data as JSON, CSV or Excel instead of copying it from a browser by hand.

• ✈️ Flight price monitoring tool: schedule runs for the routes you care about and compare fares over time in your own sheet or database.
• 📱 Travel apps and fare sites: use it as a flight fare API and feed fares, airlines, durations and stops straight into your product.
• 📊 Route and airline research: flight price comparison across airlines, nonstop options, cabins and markets, plus Google's price level for each route.
• 🧳 Travel agencies and corporate travel: check fares and where to book them for many routes in one run.
• 🌱 Sustainability reporting: compare the Google Flights carbon emissions estimate of each flight with what is typical for the route.
• 🤖 AI agents and assistants: give trip-planning agents a flight price data API through the Apify API or MCP.

Google offers no public Google Flights API (its QPX Express flight search API was shut down on April 10, 2018). Google Flights Prices API is an independent Apify Actor, not an official Google product: you run it in Apify Console or through the Apify API.

What can Google Flights Prices API do?

• 🔗 Bulk input: many Google Flights links, a list of routes and a single route typed in the form, all in one run. Each one becomes its own search.
• 🧭 Any trip type: one-way, round trip and multi-city searches, in any cabin (economy, premium economy, business, first) for up to 9 passengers.
• 🎯 Filters: maximum stops, maximum price, airlines or alliances, and Exclude Basic Economy.
• 🌍 Markets: choose the currency, country and language Google Flights should use.
• 📈 Google Flights price insights: lowest price, price level (low, typical or high), typical price range and the price history Google shows.
• 🎫 Booking options (optional): see which airlines and travel sites sell each flight and at what price.
• ⚡ Live output: each flight is saved the moment it is read, so rows appear while the run is still going.
• 📦 Export and automate: download JSON, CSV, Excel, XML or HTML, run it via API, schedule runs, monitor them and connect other tools on the Apify platform.

---

What data can Google Flights Prices API extract?

Every flight option becomes one row in the Flights table. These are the Google Flights data fields you get, with the exact field names:

💲 Price and currency: price, currency	⭐ Google's top picks (best) or the rest (other): category
✈️ Airlines and logo: airlines, airline_logo	🔢 Flight numbers: flight_numbers
📍 Route and airports: route, departure_airport, arrival_airport	📅 Local times: departure_time, arrival_time
🔁 Stops: stops, stops_label, layover_airports	⏱️ Duration: duration_minutes, duration
💺 Cabin: travel_class	📅 Search dates: outbound_date, return_date
🌙 Overnight flag: overnight	⚠️ Often delayed by over 30 minutes: often_delayed
🌱 Carbon estimate in grams: carbon_emissions_g	🌱 This flight vs typical for the route: carbon_emissions
🧭 Each leg with airplane, legroom, Wi-Fi and power: flights	🛬 Layover duration and airport: layovers
🔑 Tokens for later runs: booking_token, departure_token	🔎 Trip type and search: trip_type, search_number, page_number
🔗 Source link: source_url	🕒 Search time (UTC): search_timestamp

Each run also fills four more tables:

Table	What it contains
📈 Price insights	One row per search: lowest_price, price_level (low / typical / high), typical_price_low, typical_price_high, price_history
🛬 Airports	The airports and cities of each search with airport_name, city, country, country_code, image and thumbnail
🎫 Booking options	Only when you turn them on: book_with, airline, price, option_title, marketed_as, display_url, booking_request
🧾 Search summary	One row per search: status, stopped_reason, flights_saved, booking_options, search_parameters, source

Note: Some fields are empty (null) when Google Flights doesn't show them for a flight. For example, layover_airports is null for nonstop flights, return_date is null for one-way trips, and booking_token is only set on one-way or final-leg results while departure_token is set on round-trip outbound results. Price insights appear only when Google provides them for the search.

What data can't Google Flights Prices API extract?

• Seat maps, baggage fees or fare rules
• Price history beyond the price_history series Google shows in its price insights
• Flexible-date, calendar or "explore anywhere" searches: each search is one route with fixed dates
• More than 2 result pages per search (top results and the longer "more flights" list)
• Hotel or car rental data (for hotel prices, see Google Hotels Scraper)
• Ticket purchases: booking options only point you to the seller

---

How to scrape Google Flights data

Google Flights Prices API is designed for an easy start, even if you've never extracted data from the web before. For your first run, use the prefilled search and a small limit.

1. Create a free Apify account using your email.
2. Open Google Flights Prices API.
3. Keep the prefilled link in Google Flights URLs as it is (Los Angeles to New York, May 10 to 17, 2027) and set Maximum flights per search (maxResults) to 10 for a cheap first test.
4. Click Start and watch the flights appear in the Output tab.
5. Download your data in JSON, CSV, Excel, XML or HTML. To export Google Flights to Excel as a flat sheet, pick Excel and the Flights overview view.

When the test looks right, replace the link with your own: run a search on Google Flights, copy the address bar and paste it into Google Flights URLs. Have several routes? Add more links or use Bulk routes. On the Free plan, remember that the 10 flights per run are shared by all searches.

---

How much does it cost to scrape Google Flights?

Google Flights scraping with Google Flights Prices API uses pay-per-event pricing. Your cost has three parts:

1. Apify platform usage: the compute, data transfer and (if the run uses it) Apify Proxy traffic of your run. It depends on the run, so it isn't included in the examples below. You see the exact amount on each run's page in Apify Console. The Actor starts without a proxy, but it switches to Apify Proxy on its own if requests are blocked or fail, which adds proxy traffic to your platform usage. Do a small test run first to see what your routes cost.
2. Results: $3.50 per 1,000 flight rows saved to the Flights table on the Free plan (lower on paid plans, see below).
3. Start fee: $0.00005 per run at the default 1 GB of memory. The fee is $0.00005 per GB, so it only changes if you give the run more memory.

💲 Event	Price	When it is charged
Result	$3.50 per 1,000 results ($0.0035 per result) on the Free plan (lower on paid plans, see below)	Once for each flight row saved to the Flights table
Actor start	$0.00005 per GB of run memory	Once per run. At the default 1 GB memory that's $0.00005 per run

Apify plan	Price per flight	Price per 1,000 flights
Free	$0.0035	$3.50
Starter	$0.00315	$3.15
Scale	$0.0028	$2.80
Business and higher	$0.00245	$2.45

Paid Apify plans get a lower price per flight. The plan discount applies to that price only. The start fee is the same on every plan, and platform usage is billed at your Apify plan's own rates.

• Only Flights rows are charged. Rows in the Price insights, Airports, Booking options and Search summary tables are free.
• Result fees grow with searches × maxResults. maxResults is a cap per search, so 3 routes at the default 100 can save up to 300 rows, which is up to $1.05 in result fees at the Free plan price.

Example costs for results at the Free plan price (platform usage not included):

Flights saved	Result cost	Plus start fee at 1 GB
10	$0.035	$0.00005
100 (the default maxResults for one search)	$0.35	$0.00005
1,000	$3.50	$0.00005

See the pricing tab for the current event list.

Is scraping Google Flights free?

You can try it for free. On the Apify Free plan you get monthly platform credit, and a run saves up to 10 flights in total, shared by all searches in that run. When the 10th flight is saved, the run stops cleanly: searches still running end early, and searches that haven't started yet are marked skipped in the Search summary. Paid Apify plans have no free-plan cap.

---

Google Flights API input

You need at least one search: a Google Flights link in urls, a route in searches, or the single-route fields (departure_id, arrival_id, outbound_date). Everything else is optional and has sensible defaults. If the input contains no valid search, the run fails with a message that explains what to add.

Here's an example that gets the top results for a Los Angeles to New York round trip, May 10 to 17, 2027, capped at 10 flights:

{
  "urls": [
    { "url": "https://www.google.com/travel/flights?q=Flights%20from%20LAX%20to%20JFK%20on%202027-05-10%20through%202027-05-17" }
  ],
  "maxResults": 10,
  "max_pages": 1
}

See the input tab for a full description of all fields.

Google Flights URLs (urls)

Paste one or many real Google Flights search links. The Actor reads the route, dates, trip type, cabin and passengers from each link. It supports links with ?tfs=… (copied from the address bar after a search), ?q=Flights from LAX to JFK on 2027-05-10 (add through <date> for a round trip) and #flt=LAX.JFK.2027-05-10.

• ✅ Good: https://www.google.com/travel/flights?q=Flights%20from%20LAX%20to%20JFK%20on%202027-05-10%20through%202027-05-17
• ❌ Bad: https://www.google.com/travel/flights (the home page has no search in it) or ?q=Flights from Paris to London (?q= links need 3-letter airport codes and a YYYY-MM-DD date)

⚠️ Settings stored in a link (route, dates, trip type, cabin, passengers, stops, airlines, and currency, language or country when the link has them) override the same settings in the form for that search.

Bulk routes (searches)

Add several routes in one run. In Apify Console, each item has four boxes: From (departure_id), To (arrival_id), Outbound date (outbound_date) and an optional Return date (return_date). Leave the return date empty for a one-way trip. All other settings in the form (cabin, passengers, filters, market) apply to every route. Through the API, each item is a JSON object:

• ✅ Good: { "departure_id": "SFO", "arrival_id": "SEA", "outbound_date": "2027-05-01" }
• ❌ Bad: { "departure_id": "SFO", "arrival_id": "SFO", "outbound_date": "2020-01-01" } (same airport twice and a date in the past)

⚠️ Invalid items are skipped and listed in the Search summary with the status invalid_input. The other searches still run.

Single route and Google Flights multi city trips

departure_id and arrival_id take IATA airport codes like LAX, or several codes separated by commas (LAX,BUR). They also accept a Google city id such as /m/030qb3t, but airport codes are all most searches need. outbound_date and return_date use the YYYY-MM-DD format and must be today or later, and no more than 329 days (about 11 months) ahead. With trip_type set to auto, a return date makes it a round trip, and no return date makes it one-way.

For Google Flights multi city trips, put the legs in multi_city_json as a JSON list in travel order:

• ✅ Good: [{"departure_id":"LAX","arrival_id":"JFK","date":"2027-05-10"},{"departure_id":"JFK","arrival_id":"LHR","date":"2027-05-14"}]
• ❌ Bad: LAX-JFK 2027-05-10, JFK-LHR 2027-05-14 (not JSON)

⚠️ trip_type and multi_city_json apply only to the single-route form, not to urls or searches items. To run several multi-city trips at once, paste multi-city Google Flights links.

Filters: stops, price and airlines

• Google Flights nonstop only: set max_stops to nonstop (other options: any, 1_stop, 2_stops).
• Airlines or alliances: airlines takes codes like DL,B6 or STAR_ALLIANCE, SKYTEAM, ONEWORLD.
• Exclude Basic Economy: exclude_basic works for the economy cabin only.
• Maximum price: max_price in your selected currency.

⚠️ max_price is a filter sent to Google Flights. If Google still returns flights above your cap, they are saved and a warning appears in the log.

Maximum flights per search (maxResults) and result pages (max_pages)

maxResults (default 100) caps the flights per search, not per run. max_pages (default 2) sets how many result pages each search reads: 1 gets the top results, 2 also gets the longer "more flights" list. Flights that appear on both pages are saved once.

Google Flights booking options

Turn on fetch_booking_options to see where each flight can be booked: airlines and travel sites, with price and fare name. max_booking_lookups (default 10, up to 200) sets how many of the first saved flights per search get booking options. This adds extra requests and run time.

How to get return flights for a Google Flights round trip

The Flights table of a round-trip search lists the outbound options, and price is the price of the full trip for that outbound choice. To get the matching return flights:

1. Run the round-trip search (a link, a bulk route with a return date, or the single-route fields with a return date).
2. In the Flights table (the itinerary view shows the tokens), copy the departure_token of the outbound flight you want.
3. Start a new run with exactly one search: the same link, or the same route and dates, and paste the token into Departure token (departure_token).
4. The new run returns the return flights for that outbound choice. Their rows carry a booking_token.
5. Optional: to see where that trip can be booked, start one more single-search run with the same route and dates and paste the booking_token into Booking token (booking_token). That run returns only booking options.

⚠️ Tokens work only when the run has a single search. When the run has more than one search (several links, bulk routes, or a link plus the route form), the tokens are ignored, so you need one run per outbound flight. Only tokens from this Actor are accepted. The same steps work for the next leg of a multi-city trip.

Proxy and retries

By default, the Actor starts without a proxy. It switches to Apify Proxy on its own if requests are blocked or fail, which adds proxy traffic to your platform usage. You can also choose Apify Proxy or your own proxies from the start in proxyConfiguration. maxRetries (default 3) sets how often a failing request is retried, and maxConcurrency (1 to 5, default 2) sets how many searches run at the same time.

---

Google Flights API output

Results are stored in the Output or Storage tab. Open the Flights table as an overview, itinerary or carbon emissions view, pick only the fields you need, and download your Google Flights export as JSON, CSV, Excel, XML or HTML. The Price insights, Airports, Booking options and Search summary tables are separate datasets of the same run, and a short run summary is saved in the key-value store as OUTPUT.

Spreadsheets: flights, layovers and carbon_emissions are nested fields. In CSV and Excel they are split into many columns (for example flights/0/airline). For a flat sheet, download the overview view (12 main columns) or select only the top-level fields you need.

Google Flights JSON example

The flight below shows the shape of one row for the input example above. The values are illustrative only (not real output), and the token and leg details are shortened with "…":

{
  "category": "best",
  "price": 384,
  "currency": "USD",
  "airlines": "American",
  "airline_logo": "https://www.gstatic.com/flights/airline_logos/70px/AA.png",
  "route": "LAX-JFK",
  "departure_airport": "LAX",
  "departure_time": "2027-05-10 08:00",
  "arrival_airport": "JFK",
  "arrival_time": "2027-05-10 16:17",
  "stops": 0,
  "stops_label": "Nonstop",
  "layover_airports": null,
  "duration_minutes": 317,
  "duration": "5h 17m",
  "travel_class": "Economy",
  "flight_numbers": "AA 307",
  "outbound_date": "2027-05-10",
  "return_date": "2027-05-17",
  "overnight": false,
  "often_delayed": false,
  "carbon_emissions_g": 274000,
  "booking_token": null,
  "departure_token": "…",
  "trip_type": "Round trip",
  "search_number": 1,
  "page_number": 1,
  "source_url": "https://www.google.com/travel/flights?q=Flights%20from%20LAX%20to%20JFK%20on%202027-05-10%20through%202027-05-17",
  "flights": [
    {
      "departure_airport": { "name": "Los Angeles International Airport", "id": "LAX", "time": "2027-05-10 08:00" },
      "arrival_airport": { "name": "John F. Kennedy International Airport", "id": "JFK", "time": "2027-05-10 16:17" },
      "duration": 317,
      "airline": "American",
      "travel_class": "Economy",
      "flight_number": "AA 307",
      "extensions": ["…"]
    }
  ],
  "layovers": [],
  "carbon_emissions": { "this_flight": 274000, "typical_for_this_route": 290000, "difference_percent": -6 },
  "search_timestamp": "2026-10-08T10:00:00Z"
}

For a round trip, price is the price of the full trip for this outbound choice. See How to get return flights for the matching return legs.

Price insights example

One illustrative row from the Price insights table for the same search:

{
  "search_number": 1,
  "route": "LAX-JFK",
  "outbound_date": "2027-05-10",
  "return_date": "2027-05-17",
  "currency": "USD",
  "lowest_price": 384,
  "price_level": "typical",
  "typical_price_low": 340,
  "typical_price_high": 520,
  "price_history": [[1791000000, 410], [1791086400, 395]],
  "search_timestamp": "2026-10-08T10:00:00Z"
}

price_history is a list of [unix timestamp, price] pairs, the same Google Flights price history Google shows in its price insights, when Google provides it.

---

Tips and advanced usage

How many results can you scrape with Google Flights Prices API?

The number depends on the route, dates and filters. Each search stops at whichever comes first:

• the maxResults cap for that search (100 by default);
• the end of the result pages it reads (max_pages, 2 by default: top results and "more flights");
• the Free plan's 10 flights per run, shared by all searches;
• your run's spending limit;
• repeated connection failures, after which the run stops sending requests and keeps what it saved.

Invalid or duplicate searches are skipped. The best way to know for your routes is a quick test run with maxResults set to 10.

How to get faster or cheaper results

• Set max_pages to 1 if Google's top results are enough.
• Lower maxResults to pay only for the flights you need.
• Use filters (max_stops, airlines, exclude_basic) so Google Flights returns fewer, more relevant flights.
• Leave fetch_booking_options off unless you need sellers. It adds requests and run time (booking options rows are not charged as results).
• Put many routes in one run with searches or several links, and raise maxConcurrency (up to 5) to run more searches at the same time.

Monitor fares with scheduled runs

The Actor has no built-in price alerts, but it works well for travel price monitoring. Create an Apify schedule that runs your routes every day, send each run's results to Google Sheets or your database, and compare price and lowest_price over time to build your own Google Flights dataset. A webhook can notify you when a run finishes.

Known issues

• Duplicate check: searches that differ only in country (gl), language (hl), max_price, exclude_basic or max_pages count as duplicates, and the later one is skipped. To compare markets, also change the currency or the route.
• Failed searches: if a search fails unexpectedly, its Search summary row shows flights_saved 0, even if some of its flights were already saved (and charged). The Flights table (filter by search_number) and the run's status message show the true number of saved flights.
• Booking options after the cap: once a run stops (the Free plan's 10-flight cap or your spending limit), no more booking options are fetched.
• Past dates: dates must be today or later, so update old links and routes before you reuse them.

---

Google Flights API integrations

Can I use Google Flights Prices API as an API?

Yes. The Apify API lets you start runs, schedule them and fetch results, so you can use the Actor as a Google Flights price API in your own app. Use the apify-client NPM package for Node.js or the apify-client PyPI package for Python. The API tab has ready-to-use code. You authenticate with your Apify API token; no Google Flights API key or Google account is needed.

Google Flights API Python example

from apify_client import ApifyClient

client = ApifyClient("<YOUR_API_TOKEN>")

run_input = {
    "urls": [
        {"url": "https://www.google.com/travel/flights?q=Flights%20from%20LAX%20to%20JFK%20on%202027-05-10%20through%202027-05-17"}
    ],
    "maxResults": 10,
    "max_pages": 1,
}

run = client.actor("insights_data/google-flights-prices-api").call(run_input=run_input)

# Flights table (the run's default dataset)
for flight in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(flight["route"], flight["airlines"], flight["price"], flight["currency"])

# Other tables of the same run: priceInsights, airports, bookingOptions, searchSummary
tables = run["storageIds"]["datasets"]
for row in client.dataset(tables["priceInsights"]).iterate_items():
    print(row["route"], row["lowest_price"], row["price_level"])

# Short run summary
summary = client.key_value_store(run["defaultKeyValueStoreId"]).get_record("OUTPUT")

This example uses the Actor as a Google Flights data API: it starts a run, waits for it to finish and reads the tables. The run object lists the dataset ID of every table under storageIds.datasets; you can also copy a table's dataset ID from the run's Storage tab. If you were looking for a Google Flights live API, note that each run reads current prices from Google Flights when it runs; there is no streaming.

Can I integrate Google Flights Prices API with other apps?

Yes. Connect it with almost any cloud service through Apify integrations: Make, Zapier, Slack, Google Sheets, Google Drive, Airbyte, GitHub, LangChain and more. Use webhooks to trigger actions when a run finishes. For example: run your routes every morning, add the new fares to a Google Sheet, and post the run's lowest price to a Slack channel.

Can I use Google Flights Prices API with AI agents (MCP)?

Yes. Connect it to Claude and other AI assistants through the Apify MCP server, so an agent can look up flights and get structured results. Open the MCP tab for the Google Flights API MCP setup steps.

---

Other Google and data scrapers

These Actors from the same team cover other travel, data and research tasks, from Google Hotels prices and Google ads to Flipkart product prices, stock sentiment and Y Combinator companies:

🏨 Google Hotels Scraper: hotel prices, ratings, star class, amenities, coordinates, photos and booking links for any city or hotel; compare rates by dates, guests and currency	🔍 Google Ads Transparency Center Scraper & API: extract ads across Search, YouTube, Shopping, Maps and Play by brand, domain or advertiser ID
🛒 Flipkart Product Scraper: Flipkart prices, discounts, ratings, specs, sellers and offers for price monitoring	📈 Stocktwits Scraper: stock and crypto messages, sentiment, price targets and trending symbols
🚀 Y Combinator Scraper: company profiles, founders, open roles and Launch YC posts

---

❓ FAQ

Is there a Google Flights API?

No, Google doesn't offer a public Google Flights API. There has been no public Google flight search API since QPX Express was shut down on April 10, 2018. Google Flights Prices API is a Google Flights API alternative: an Apify Actor that collects the same flight results you see on Google Flights and returns them as data you can call through the Apify API. Google Flights is part of Google Travel, so the Actor can also stand in for a Google Travel flights API when you need flight results.

Is it legal to scrape Google Flights?

Flight prices and schedules on Google Flights are public, non-personal data. Whether collecting them is fine for your project depends on your country, how you use the data and Google's Terms of Service. Respect intellectual property rules and have a legitimate reason for your project. If you're unsure, ask a lawyer: this answer is not legal advice.

How does Google Flights Prices API work?

It's a Google Flights web scraper that reads the same results you see in your browser. For each search, it reads the route, dates, cabin and passengers from your link or the form, checks them, and loads the Google Flights results: first the top results, then (with max_pages 2) the longer "more flights" list. Each flight option becomes a flat row that is saved right away, together with Google's price insights and the airports of the search. If booking options are on, it then looks up where the first flights can be booked, and a Search summary row records the status of each search.

How is Google Flights Prices API different from checking Google Flights by hand?

Feature	Google Flights Prices API	Checking Google Flights by hand
Many routes in one go	✅ Links, route lists and a single route in one run	❌ One search at a time
Structured data	✅ JSON, CSV, Excel, XML or HTML	❌ Copy and paste
Price insights, airports and booking options in tables	✅	❌ Only on screen
Scheduled runs and integrations	✅ Through the Apify platform	❌
Cost	Pay per flight saved, plus a start fee and platform usage (see pricing)	Free, but manual

Do I need a Google account or a Google Flights API key?

No. You don't need a Google account, login or Google Flights API key. You only need an Apify account, and an Apify API token if you call it from code.

Can I use it as a cheap flights API?

Yes, within the routes and dates you search. Sort the Flights table by price, or read lowest_price and price_level in the Price insights table. It doesn't search flexible dates or "anywhere" destinations: each search is one route with fixed dates.

Can it track prices or send price alerts?

Not on its own. There are no built-in alerts or comparisons over time. To use it for flight price monitoring, schedule runs on Apify and compare the results in a sheet or database, as described in Monitor fares with scheduled runs.

Why use a Google Flights scraper?

A Google Flights scraper turns fares you would otherwise copy by hand into rows you can sort, filter and analyze. You can check many routes in one run, keep a travel product's fares fresh, and compare airline prices over time without manual work. Because it's a hosted Google Flights API scraper, you also don't have to keep your own code up to date when the site changes.

Why am I getting fewer results than expected?

1. Check the Search summary table: invalid_input means the input needs fixing, skipped means the run had already stopped (the Free plan cap or your spending limit was reached), and no_results means no flights came back for that search: either Google Flights lists no flights for that route, dates and filters, or it returned an empty answer for that search (check the log).
2. Look at stopped_reason: max_results, free_limit or spend_limit show why a search stopped.
3. For a search with status failed, count its rows in the Flights table by search_number: its flights_saved shows 0 even if some flights were saved.
4. Loosen your filters (max_stops, airlines, exclude_basic) or raise maxResults and set max_pages to 2.
5. Make sure the dates are today or later (and no more than 329 days ahead) and the airport codes are right. Searches differing only in gl, hl, max_price, exclude_basic or max_pages count as duplicates.

What does a failed run look like?

• No valid search in the input: the run ends with the status Failed and the message "No valid flight search to run. Paste Google Flights URLs, add searches, or fill the route fields." Fix the input and start again.
• Google Flights can't be reached: the log says that many requests in a row could not reach Google Flights. The Actor stops sending requests, keeps everything it saved, marks the affected searches as failed in the Search summary, and finishes with a status message like "Done: 0 flights saved." If you set your own proxies, check them, or select Apify Proxy in proxyConfiguration, then try again. A search where none of the result pages could be loaded usually ends as failed too, so check the log for pages that could not be loaded.
• One search fails: the log says that search failed unexpectedly and the run continues with the others.

First check the run's status message, then the Search summary table, then the log. If the problem repeats, report it on the Issues tab with a link to the run.

Do I have to maintain my own Google Flights crawler?

No. Google Flights Prices API is a hosted Google Flights extractor on Apify. You don't install or update anything: you set the input, run it, and get the data. If something breaks, report it on the Issues tab.

---

Support and feedback

We're always working on improving Google Flights Prices API. Found a bug or have a feature request? Please create an issue on the Issues tab.

Need a custom solution, a different output format or more travel data? Contact us at hello.insights.data@gmail.com.

Built and maintained by Insights Data.