Google Flights API

Live Google Flights fares as JSON. Every itinerary carries Google's own low | typical | high verdict, the historical price band, a working buy_link, and an X-Search-Status so an empty dataset is never confused with a failed search.

This Actor is the Apify Store door for FlightPowers. The same live backend is also billed as an HTTP API on RapidAPI and as a hosted MCP server. Pick the door that matches your stack; the payload is the same.

Same product, three doors

• This Actor (pay-per-event on Apify)
• RapidAPI listing: Google Flights Live API — 368 public subscribers as of 2026-09-01 (RapidAPI Hub subscriptionsCount; the public page does not split paid vs free)
• Hosted MCP (ad-free, bring your RapidAPI key): https://google-flights-mcp.flightpowers.com/mcp

Why this Google Flights API

Google does not ship a public Flights API. What you need from a hosted one is not another list of prices. It is a way to judge a fare and a way to trust an empty result.

• Google's verdict, on every row. price_range_in_relation_to_other_periods is low, typical, or high. price_insights_low / price_insights_high are Google's band for that route and those dates. Your product can say this is cheap for JFK-LHR in late November, not just quote a number.
• X-Search-Status on every run. The backend sets ok, empty, partial, or degraded. An Actor has no HTTP headers to forward, so the same signal is written to the run status message, a SEARCH_OUTCOME record in the key-value store, and the run log. empty means Google really has nothing. degraded means the search did not finish — retry it, do not record "no flights."
• Round-trip is one search. Paired outbound + return, one total_price, one buy_link. Not two one-ways you have to stitch.
• Filters split per leg. Nonstop out, one stop home. A morning window on the outbound. That maps onto travel-policy rules, not just a max-stops knob.
• No second bill. Residential proxy routing is on by default. No extra SERP key and no separate proxy account.

Features

Search

• One-way and round-trip
• IATA airport codes (JFK, LHR) and city codes where Google accepts them (NYC, LON)
• Economy or business (seat_type 1 or 3)
• Adults, children, infants-on-lap, infants-in-seat
• Currency, price cap, Google's own sort (Overall, Price, Duration)
• One-way: max stops, include/exclude airlines, departure and arrival hour windows
• Round-trip: the same filters, independently, on each leg

Result quality

• Flat JSON, one dataset row per itinerary
• Numeric prices (price_as_number / total_price_as_number) you can sort on
• Layovers as stops_info[] with airport and duration
• Deep buy_link into Google Flights for that exact itinerary
• Unreadable pages (consent wall, bot check, truncated markup) are retried; a genuine Google "no flights" page is not
• strict: true fails the run (and is not charged) when the search did not complete, instead of finishing with an empty dataset

Usage examples

Dates below are in late 2026 so a Console try-run still has inventory. Swap them for your own.

Example 1 — JFK to LHR round-trip, nonstop out

{
  "endpoint": "roundtrip",
  "from_airport": "JFK",
  "to_airport": "LHR",
  "departure_date": "2026-11-24",
  "return_date": "2026-12-01",
  "max_departure_stops": 0,
  "max_return_stops": 1,
  "currency": "usd",
  "limit": 10
}

Example 2 — one-way, cheapest nonstop JFK-LAX

{
  "endpoint": "oneway",
  "from_airport": "JFK",
  "to_airport": "LAX",
  "departure_date": "2026-12-01",
  "max_stops": 0,
  "sort_type": "Price",
  "currency": "usd"
}

Example 3 — business class LHR-SIN, morning departures, selected airlines

{
  "endpoint": "oneway",
  "from_airport": "LHR",
  "to_airport": "SIN",
  "departure_date": "2026-12-10",
  "airline_codes": ["SQ", "BA"],
  "departure_time_min": 6,
  "departure_time_max": 12,
  "seat_type": 3,
  "limit": 20
}

Example 4 — family of four, EUR, budget cap

{
  "endpoint": "roundtrip",
  "from_airport": "BER",
  "to_airport": "CDG",
  "departure_date": "2026-12-01",
  "return_date": "2026-12-05",
  "passengers": [1, 1, 2, 2],
  "max_price": 400,
  "currency": "eur"
}

Example 5 — fail loud if the search did not complete

{
  "endpoint": "oneway",
  "from_airport": "JFK",
  "to_airport": "LHR",
  "departure_date": "2026-11-24",
  "strict": true,
  "currency": "usd"
}

Python

from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")

run = client.actor("mtnrabi/google-flights-real-time-api").call(run_input={
    "endpoint": "roundtrip",
    "from_airport": "JFK",
    "to_airport": "LHR",
    "departure_date": "2026-11-24",
    "return_date": "2026-12-01",
    "currency": "usd",
})

items = client.dataset(run["defaultDatasetId"]).list_items().items
for trip in sorted(items, key=lambda t: t["total_price_as_number"]):
    print(
        trip["total_price"],
        trip["price_range_in_relation_to_other_periods"],
        trip["price_insights_low"],
        trip["price_insights_high"],
        trip["buy_link"],
    )

JavaScript

import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: '<YOUR_APIFY_TOKEN>' });

const run = await client.actor('mtnrabi/google-flights-real-time-api').call({
    endpoint: 'oneway',
    from_airport: 'JFK',
    to_airport: 'LHR',
    departure_date: '2026-11-24',
    currency: 'usd',
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.sort((a, b) => a.price_as_number - b.price_as_number);
console.log(items[0].price, items[0].price_range_in_relation_to_other_periods, items[0].buy_link);

REST

curl -X POST "https://api.apify.com/v2/acts/mtnrabi~google-flights-real-time-api/run-sync-get-dataset-items" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $APIFY_TOKEN" \
  -d '{
    "endpoint": "roundtrip",
    "from_airport": "JFK",
    "to_airport": "LHR",
    "departure_date": "2026-11-24",
    "return_date": "2026-12-01",
    "currency": "usd"
  }'

After the run, read SEARCH_OUTCOME from the default key-value store. That is the Actor-side copy of X-Search-Status.

Input parameters

Parameter	Type	Required	Default	Description
endpoint	string	yes	oneway	oneway or roundtrip
from_airport	string	yes	JFK	Departure IATA (or a Google city code)
to_airport	string	yes	LAX	Arrival IATA
departure_date	string	yes		Outbound date, YYYY-MM-DD
return_date	string	round-trip		Return date, YYYY-MM-DD
limit	integer		10	Rows to return (this is what a search costs)
currency	string		usd	Price currency
seat_type	integer		1	1 Economy, 3 Business
passengers	integer[]		[1]	1 adult, 2 child, 3 infant on lap, 4 infant in seat
max_price	integer			Cap in the selected currency
sort_type	string		Overall	Overall, Price, or Duration. Google's order is not a strict numeric sort — sort on price_as_number yourself if you need that
strict	boolean		false	Fail the run when the search did not complete
use_ext_proxy	boolean		true	Residential proxy routing
use_fallback	boolean		false	Accepted; currently a no-op on this backend
max_stops	integer	one-way		0 = nonstop
airline_codes / exclude_airline_codes	string[]	one-way		Carrier include / exclude
departure_time_min / _max	integer	one-way		Departure hour window, 0-23
arrival_time_min / _max	integer	one-way		Arrival hour window, 0-23
max_departure_stops / max_return_stops	integer	round-trip		Max stops per leg
departure_airline_codes / return_airline_codes	string[]	round-trip		Carriers per leg
departure_exclude_airline_codes / return_exclude_airline_codes	string[]	round-trip		Exclusions per leg
departure_departure_time_min / _max	integer	round-trip		Outbound departure window
departure_arrival_time_min / _max	integer	round-trip		Outbound arrival window
return_departure_time_min / _max	integer	round-trip		Return departure window
return_arrival_time_min / _max	integer	round-trip		Return arrival window

return_date is required only when endpoint is roundtrip.

Output format

One dataset row per itinerary. limit caps how many rows a search produces.

One-way

{
  "price_range_in_relation_to_other_periods": "low",
  "price_insights_low": 65,
  "price_insights_high": 135,
  "from_airport": "New York (JFK)",
  "to_airport": "London (LHR)",
  "departure_date": "2026-11-24",
  "price": "$412",
  "price_as_number": 412,
  "duration": "7 hr 10 min",
  "duration_seconds": 25800,
  "buy_link": "https://www.google.com/travel/flights?tfs=...&curr=usd",
  "airline": "British Airways",
  "stops": 0,
  "stops_info": [],
  "departure_description": "8:15 AM on Tue, Nov 24",
  "arrival_description": "8:25 PM on Tue, Nov 24"
}

stops_info is empty on nonstop flights. Otherwise each layover is { "stop_airport": "AUH", "stop_duration_seconds": 5700 }.

Round-trip

Round-trip rows add total_price, total_price_as_number, total_duration_seconds, total_stops, and paired departure_flight_* / return_flight_* fields (airline, stops, duration, descriptions, layover arrays). One buy_link covers the whole itinerary.

SEARCH_OUTCOME (key-value store)

This is the Actor translation of the backend X-Search-Status header. Read it before you treat an empty dataset as a fact.

status	Meaning
ok	Search finished; rows are a complete answer
empty	Search finished; Google has no flights for this route/date. Do not retry
partial	Some combinations answered; some did not. Rows exist but the list may be short
degraded	Search did not complete. Zero rows here say nothing about availability. Retry
unreported	Backend sent no X-Search-Status. Do not treat empty as "no flights"

X-Search-Reason (when present) records the first failure the backend saw (blocked_page, unreadable_prices, search_truncated, and others). Always decide from status, not from reason alone.

Use cases

• Fare-alert bots that fire when the verdict flips to low
• Cheapest-month calendars: one search per date, fan out (backend accepts up to 150 requests/minute)
• AI travel agents that need a verdict and a buy_link in one hop
• Affiliate / metasearch pages that cannot reconstruct a booking URL
• Corporate policy filters (airline + time-of-day + stops, per leg)

Integrations

Schedules. Save the input as a Task and run it on a cron. Each run appends a dataset plus SEARCH_OUTCOME.

Webhooks. On ACTOR.RUN.SUCCEEDED, fetch the dataset and SEARCH_OUTCOME.

Automation. Use Apify connectors in n8n, Make, or Zapier to run the Actor and filter on the verdict field.

Clients. Use apify-client for Python or JavaScript.

MCP and AI agents

Hosted FlightPowers MCP (RapidAPI key, no Actor run):

https://google-flights-mcp.flightpowers.com/mcp

Add it in Claude with transport http and header x-rapidapi-key set to your RapidAPI key. Clients that cannot set headers can put rapidapi_key as a query parameter. Registry id: com.flightpowers/google-flights-mcp.

This Actor via Apify MCP:

https://mcp.apify.com/?tools=actors,docs,mtnrabi/google-flights-real-time-api

Also available as a hosted HTTP API

The same backend is optional on RapidAPI and on the product playground. This Actor does not require those doors.

• Product and live demo: https://flightpowers.com
• RapidAPI listing: https://rapidapi.com/mtnrabi/api/google-flights-live-api
• Public RapidAPI subscribers: 368 as of 2026-09-01 (Hub subscriptionsCount; public page does not split paid vs free)

Notes

• Results are live. Trunk hubs return fast; thin regional routes take longer.
• sort_type Price is Google order, not a numeric sort. Sort on price_as_number.
• Dates are YYYY-MM-DD. Airports are IATA (or Google city codes).
• limit is the row cap and the cost knob. Default 10.
• use_fallback currently changes nothing on this backend. Leave it off.

Frequently asked questions

Does Google Flights have an API?

No official one. Google retired QPX Express in 2018 and has not replaced it for general use. There is no public key to request. This Actor reads live Google Flights and returns fares, the low/typical/high verdict, the price band, a buy_link, and X-Search-Status as JSON.

Does Google Flights have a public API I can get a key for?

No. Use this Actor on Apify (pay-per-event, one flight_search per run) or the RapidAPI listing of the same backend. BASIC on RapidAPI is 10 requests per month at zero dollars with a hard cap. Playground: https://flightpowers.com

How do I scrape Google Flights with Python?

Call this Actor with apify-client (example above), or call the RapidAPI HTTP endpoint with the same JSON. Maintaining your own browser, proxies, and parser is the work this already does.

Can Claude or Cursor call this as MCP?

Yes. Point an MCP client at https://google-flights-mcp.flightpowers.com/mcp with a RapidAPI key, or at the Apify MCP URL above to run this Actor. Do not treat ad-supported demo MCP hosts as the production server.

How do I tell no flights from a blocked page?

Read SEARCH_OUTCOME.status (the Actor copy of X-Search-Status). empty is a real Google answer; do not retry. degraded, partial, and unreported are not. Set strict true if an incomplete search should fail the run. Incomplete searches reported by the backend are not charged.

Does it return booking links?

Every row has buy_link, a deep link into Google Flights for that itinerary. It does not ticket, hold a seat, or take payment.

How much does one search cost?

Pay-per-event. The primary event is one flight_search per run, regardless of how many rows limit returns, plus a small Actor-start fee. The Store pricing tab is authoritative. limit default is 10.

Can I scan a whole month of dates?

Yes. One run per date, in parallel. The backend takes up to 150 concurrent requests per minute. Check SEARCH_OUTCOME on each run before charting a hole as no flights that day.

Which airport codes work?

Three-letter IATA (JFK, LHR, CDG, TLV, SIN). City codes such as NYC and LON work where Google Flights accepts them.

Featured tasks

One-click clones on this Actor (created 2026-09-01):

• JFK to LHR round-trip
• Cheapest one-way nonstop (JFK to LAX)
• Search JFK to LHR from Claude via MCP

After you clone a task, save it, put it on a schedule, and read SEARCH_OUTCOME on each run.

Related

• Booking.com live rates, hotel_by_name and proxy_country: https://apify.com/mtnrabi/booking-real-time-api
• Product and playground: https://flightpowers.com
• RapidAPI: https://rapidapi.com/mtnrabi/api/google-flights-live-api
• Hosted MCP: https://google-flights-mcp.flightpowers.com/mcp

Using this Actor? A rating helps other developers find it. Found a bug or need a field? Open an issue with the input you used and the output you got.

Last Updated: 2026.09.01