Flight API benchmark 2026: four Google Flights APIs, same three searches

Published October 7, 2026

Short answer: we ran the same three flight searches through FlightPowers, SerpApi, SearchApi and HasData in the same hour on 2026-10-07. All four returned the same cheapest fare to the dollar on every search, with the same Google price range, because all four read Google Flights. What differs is the shape of the answer and what it costs: a round trip with both legs is one request on FlightPowers and two on the other three, SearchApi and SerpApi put the first price on the table faster, SerpApi has the biggest free tier, and FlightPowers and SearchApi both come to $4.00 per 1,000 searches on their entry plans.

Disclosure: I run FlightPowers, one of the four rows. So the method, the places where my API loses and the timing of every single call (benchmark JSON) are all public, and the test gets re-run every month.

Results

All times are medians of 3 runs, measured from a server in Iowa (GCP us-central1) between 13:52 and 14:03 UTC on 2026-10-07. Prices are USD, 1 adult, economy.

Two tail events are in those medians and worth naming: on SearchApi one of the seven scan calls took about 28 seconds in two of the three runs (the median call was 1.9 s), and on HasData one call took 16 to 22 seconds in two of the three runs (median call 3.0 s). A parallel scan waits for its slowest call, so that is what the row shows.

The three searches

1. Q1, a round trip: JFK to LHR, out Wednesday 18 November 2026, back Wednesday 25 November.
2. Q2, a one way: TLV to BKK on Thursday 3 December 2026.
3. Q3, a flexible scan: LHR to BCN, any departure from 10 to 16 November 2026, 3 nights. Seven date pairs. Where the API takes a range in one call we ran that too; everywhere else it is seven requests.

The cheapest results, for the record: Q1 was Aer Lingus out and SWISS back with one stop each way, above Google's usual $480 to $670 for those dates, so every API marked it "high". Q2 was Aegean and Qatar Airways with two stops, inside the $440 to $620 band. Q3's cheapest was $93 leaving Saturday 14 November and back Tuesday 17 November; the dearest date pair, leaving Monday 16 November, was $158.

How we measured

• Same hour, same machine. Every call went out from one VM in GCP us-central1 between 13:52 and 14:03 UTC, three runs per search per API, two seconds apart. Wall time runs from sending the request to reading the last byte of the body, so it includes the network.
• Round trips, counted fairly. SerpApi, SearchApi and HasData answer a round trip with the outbound options, each already priced as a round-trip total. The return flight's details need a second request with a departure token, which their own docs state (quoted below). We timed both the first answer and the first answer plus the return-leg request for the top itinerary. FlightPowers returns both legs paired in the first answer.
• Fresh results. SerpApi was called with no_cache=true. FlightPowers keeps no cache. SearchApi and HasData document no cache switch for Google Flights.
• Defaults. Each API ran with its documented defaults apart from the route, dates and currency. FlightPowers ran twice on Q1 and Q3, at its default of 10 itineraries and at limit: 100. More results exist behind SerpApi's show_hidden and HasData's showHidden and deepSearch; we did not test those.
• Free tiers only. Every rival account was a free account created for this test, and no card was entered anywhere.
• Every call is published. Status, seconds, itinerary count and cheapest fare for each of the calls behind the table are in the benchmark JSON.

What each vendor's own docs say about the return leg, verbatim:

• SerpApi Google Flights API: "To obtain the returning flight information for Round Trip (1), you need to make another request using a departure_token."
• SearchApi Google Flights API: "A departure_token is used to select an individual flight. For example, in a round_trip, you use it to select the outbound flight before obtaining a booking_token for the return flight."
• HasData Google Flights API: "For round trips, retrieve return flight details with a separate request using departureToken."

Prices of the plans were read from serpapi.com/pricing, searchapi.io/pricing, hasdata.com/prices (Google Flights costs 15 credits a request) and our pricing page, all on 2026-10-07.

What the numbers say

The fare is not a reason to pick one. Every API returned the same cheapest price on all nine price points we compared (Q1, Q2 and each of Q3's seven date pairs) and the same Google price range. The one difference was a label: SearchApi's price_level read "high" on two of the seven Q3 dates (10 and 16 November) in all three runs, where the other three said "typical". If a vendor tells you its Google Flights prices are better, ask it for the request that shows it.

The round trip is where they really differ. If you need the return flight, not only the round-trip total, the other three cost two requests and one to four seconds more than ours, and a search per itinerary you want to inspect. FlightPowers pairs both legs in one answer, which is why a round trip with both legs costs $4.00 per 1,000 here against $8.00 to $50.00 elsewhere.

Date scans run in parallel, and the slowest call decides. Seven requests at once came back in 3.1 s on FlightPowers and 4.5 s on SerpApi. SearchApi and HasData each had one slow call in two of the three runs. If you scan a month of dates, plan for the tail, not the median.

A range in one call exists in two places. FlightPowers' paid MCP server takes a date range and a list of trip lengths in one call (3.24 s here) but still bills one request per date pair. SearchApi's calendar engine returns every date pair's lowest price for one billed search, with no itinerary details. If a price grid is all you need, that is cheaper than ours.

Where FlightPowers loses

This is the part a benchmark written by a vendor usually leaves out.

• The first price is slower. SearchApi (1.98 s) and SerpApi (2.26 s) give you a round-trip total before we do (3.27 s). On the one way, SerpApi (1.34 s) and SearchApi (1.50 s) edged our 1.56 s. If you only ever need the total, they are quicker.
• Asking for every itinerary is slow. With limit: 100 our round trip took 15.68 s, because each extra outbound needs its own return-leg page, and one scan call in the first run took 59 s.
• The free tier is small. Ten requests a month on the API key, against SerpApi's 250 a month and HasData's 67. Our bigger free path is the ad-supported MCP server (50 searches a day), which needs a Google sign-in and an MCP client such as Claude or Cursor.
• No price history. The other three return a price_history series. We return Google's band and its low, typical or high verdict, without the series.
• The entry price is not unique. SearchApi's entry plan is also $4.00 per 1,000, and HasData's annual billing works out at $3.69. "About a sixth of SerpApi's price per search" is the only large entry-price gap.
• Breadth. SerpApi, SearchApi and HasData do multi-city and dozens of non-travel engines on one key. We do one way and round trip, plus Booking.com hotels.
• Billing. The other three count successful searches only. On RapidAPI every request that reaches our listing is counted against the plan, a request we reject as invalid (422) included.

APIs we could not run

FAQ

What is the best API for live flight prices? It depends on the shape of your searches, because the fares were identical. For round trips with both legs in one request and a $10 entry plan, FlightPowers (mine). For the fastest first price and a date grid in one billed search, SearchApi. For the biggest free tier and many non-travel engines on one key, SerpApi. HasData sits between them on price and was the slowest on the round trip and the one way.

What is a good Google Flights API alternative? Google has had no public flights API since QPX Express closed in April 2018 (the long version). The self-serve APIs that return live Google Flights fares today are the four in the table above.

Do different Google Flights APIs return different prices? Not in this test: same cheapest fare to the dollar on all nine price points, same price range.

Which Google Flights API is fastest? For the first round-trip price, SearchApi and SerpApi. For a round trip with both legs, FlightPowers. On a one way the top three were within a quarter of a second.

Re-running it

The numbers on this page are from 2026-10-07 and fares move within minutes, so the benchmark is re-run every month with the same three searches, moved forward by a month, and this page is updated with the date. If you run it yourself and get something different, the request that shows it is welcome at our contact page.

To try the paired round trip on your own routes: a key from the RapidAPI listing (10 free requests a month, then $10 for 2,500), or the free ad-supported MCP server at free-trial.flightpowers.com/mcp with a Google sign-in.

curl -X POST https://api.flightpowers.com/v1/flights/roundtrip \
  -H "x-api-key: $FLIGHTPOWERS_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"from_airport":"JFK","to_airport":"LHR","departure_date":"2026-11-18","return_date":"2026-11-25","currency":"USD"}'

Related

• The best flight data APIs in 2026: the wider field, with dated prices
• SerpApi alternative for Google Flights: moving a workload, parameter by parameter
• Round-trip prices in one request: the paired-leg model
• All comparisons: SerpApi, SearchApi, HasData, FlightAPI.io, Duffel, Amadeus, Kiwi.com, Skyscanner