Google Flights Scraper — Real-Time Fares, Routes & Booking Links

Scrape Google Flights at scale for one-way and round-trip itineraries with prices, airlines, stops, layovers, aircraft, carbon emissions, and direct booking deeplinks. HTTP-only via a reverse-engineered protobuf URL parameter — no browser overhead, no Selenium, no JavaScript rendering. Built for travel apps, fare-monitoring pipelines, AI travel agents, and analysts who need real-time Google Flights data without a Skyscanner/Amadeus enterprise contract.

What does Google Flights Scraper do?

This actor turns a single search query — origin, destination, dates, passengers — into a clean JSON dataset of every flight option Google Flights would show a human user. Each record includes the full route (with layovers), every segment's airline and flight number, aircraft type, cabin, total duration, current fare, carbon emissions, and a deeplink back into Google Flights so you can review the exact itinerary.

It supports one-way and round-trip searches in all four cabin classes (Economy, Premium Economy, Business, First), 9 adults + 8 children + lap and seated infants, 30+ currencies, 30+ countries, and 29+ languages. Behind the scenes it constructs the same protobuf-encoded tfs URL parameter Google's own frontend uses, fetches the response over Apify's residential proxy pool, and parses the embedded AF_initDataCallback payload — so a typical run finishes in well under 15 seconds and costs roughly for a full LAX→JFK round-trip.

Why use Google Flights Scraper?

• AI-agent ready (MCP-first): designed so Claude, ChatGPT, and Gemini can pick this tool and call it cleanly. The tool description, input fields, and output keys are all written for an LLM reader, not for a human PM. Typical agent run costs under .25 — well below the x402 default prepay.
• Premium reliability target: residential proxy pool, session-consistent cookies, exponential-backoff retries, and an automatic HTML snapshot saved to the Key-Value Store whenever the parser fails so we can diagnose Google-side drift fast.
• No browser, no Playwright tax: the protobuf URL approach is roughly 10–20x faster and far cheaper than headful-browser scrapers. Most runs finish in 5–15 seconds.
• Richer defaults than the market: carbon emissions, aircraft type, layover airport + duration, cabin per segment, and a stable searchId hash are all returned by default — never gated behind a "premium" flag.
• Per-itinerary pay-per-event (PPE): you pay only for flights actually returned to your dataset, not for failed pages, blocked requests, or empty responses. Predictable cost-per-search for production planning.

How to use Google Flights Scraper

1. Open the actor on Apify Store and click Try for free.
2. Fill the Input form:
   • origin — 3-letter IATA code (e.g., LAX).
   • destination — 3-letter IATA code (e.g., JFK).
   • departureDate — YYYY-MM-DD (must be in the future).
   • returnDate — YYYY-MM-DD for round-trip, leave empty for one-way.
   • Optional: adults, children, infantsInSeat, infantsOnLap, cabinClass, maxStops, currency, country, language, maxResults.
3. Start the run. Cost is .005 per flight returned + .00005 start fee. Typical LAX→JFK round-trip returning 40 itineraries: about .20.
4. Read the dataset in the Output tab. Export as JSON, CSV, Excel, RSS, or HTML — or hit the Apify API directly for programmatic access.
5. Schedule it to run daily, hourly, or every 15 minutes via Apify Schedules to track fare changes over time.
6. From Claude / ChatGPT / Gemini: the actor is automatically exposed via Apify MCP as apify--google-flights-scraper. Tool description, input fields, and output shape are all LLM-tuned.

Input

The full input schema is on the Input tab. Required fields are origin, destination, departureDate. Everything else has a sensible default.

Minimal JSON example:

{
    "origin": "LAX",
    "destination": "JFK",
    "departureDate": "2026-08-15",
    "returnDate": "2026-08-22",
    "adults": 1,
    "cabinClass": "economy",
    "currency": "USD",
    "country": "us",
    "maxResults": 30
}

Multi-passenger business-class one-way example:

{
    "origin": "SFO",
    "destination": "NRT",
    "departureDate": "2026-09-10",
    "adults": 2,
    "children": 1,
    "infantsOnLap": 1,
    "cabinClass": "business",
    "maxStops": 1,
    "currency": "USD",
    "country": "jp",
    "language": "en"
}

Output

Each dataset row is a single flight itinerary. Multi-segment flights and layovers are nested inside outbound and return. Keys are stable across runs; nulls are explicit (we do not omit fields).

{
    "searchId": "a1b2c3d4e5f6",
    "tripType": "round_trip",
    "origin": "LAX",
    "destination": "JFK",
    "departureDate": "2026-08-15",
    "returnDate": "2026-08-22",
    "price": 487,
    "currency": "USD",
    "isBestFlight": true,
    "cabinClass": "economy",
    "totalDurationMinutes": 720,
    "stops": 0,
    "airlines": ["Delta"],
    "outbound": {
        "origin": "LAX",
        "destination": "JFK",
        "departureTime": "2026-08-15T08:30:00",
        "arrivalTime": "2026-08-15T17:00:00",
        "durationMinutes": 330,
        "stops": 0,
        "segments": [
            {
                "airline": "Delta",
                "airlineCode": "DL",
                "flightNumber": "DL 423",
                "aircraft": "Boeing 767",
                "origin": "LAX",
                "destination": "JFK",
                "departureTime": "2026-08-15T08:30:00",
                "arrivalTime": "2026-08-15T17:00:00",
                "durationMinutes": 330,
                "cabin": null
            }
        ],
        "layovers": []
    },
    "return": {
        "origin": "JFK",
        "destination": "LAX",
        "stops": 0,
        "segments": [],
        "layovers": []
    },
    "carbonKg": 412,
    "carbonVsTypical": null,
    "bookingUrl": null,
    "googleFlightsUrl": "https://www.google.com/travel/flights/search?tfs=...",
    "scrapedAt": "2026-05-16T18:00:00.000Z"
}

Download the dataset as JSON, CSV, Excel, RSS, or HTML from the Output tab.

Data table

Field	Type	Description
searchId	string	Stable 12-char hash of search inputs — groups runs of the same query
tripType	enum	one_way or round_trip
origin, destination	string	IATA codes for the full trip
departureDate, returnDate	string|null	YYYY-MM-DD; returnDate is null on one-way
price	number	Total trip price for selected passengers
currency	string	ISO 4217
isBestFlight	boolean	True if Google placed this in the Best Flights block
cabinClass	enum	economy, premium_economy, business, first
totalDurationMinutes	number	Sum of leg + layover durations
stops	number	Total stops across the itinerary
airlines[]	string[]	Distinct airline names
outbound, return	object	Per-leg detail with segments + layovers
outbound.segments[].flightNumber	string	e.g., DL 423
outbound.segments[].aircraft	string	e.g., Boeing 767
outbound.layovers[].airport	string	IATA code
outbound.layovers[].durationMinutes	number	Layover duration
outbound.layovers[].overnight	boolean	True if the layover spans midnight
carbonKg	number	Estimated CO2 per passenger
bookingUrl	string|null	Direct booking deeplink (may be null on some runs)
googleFlightsUrl	string	Search URL — open in your browser to verify
scrapedAt	string	ISO 8601 UTC timestamp

Pricing — how much does it cost to scrape Google Flights?

Two pay-per-event line items, no monthly subscription, no rental tier:

Event	Price	Triggered
apify-actor-start	.00005	Once per run
flight-result	.005	Per flight itinerary saved to the dataset

Typical run costs:

• LAX→JFK round-trip, 40 itineraries: about .20
• SFO→NRT one-way business class, 20 itineraries: about .10
• 100 daily fare-tracking runs across 10 routes (≈30 itineraries each): about ** per day = /month**

Failed pages, blocked requests, and empty responses are not charged. You pay only when flight data lands in your dataset.

The Pay-Per-Usage tier is also enabled alongside PPE — large jobs (millions of itineraries) can opt for compute + proxy passthrough billing if that fits better.

Tips & advanced options

• Lower maxResults for cheaper, faster runs. The default 50 typically covers Google's "Best flights" plus the first page of "Other flights". Push 100–200 only if you need long-tail itineraries.
• Country + currency matter. Search market (country) affects which OTAs and airlines appear; currency affects display price (Google converts at its own rate). For local fares, match country and currency to the search market.
• maxStops=0 for nonstop-only — typically halves the result set and the cost.
• Run via Schedules with a JSON template for fare-tracking pipelines. Each scheduled invocation gets its own dataset.
• Webhook integration — fire on completion to push fares into Slack, a database, or a downstream actor (for example pair with email-address-validator for outreach).
• Multi-city is on the v0.2 roadmap — for now use multiple one-way searches and join on searchId.

FAQ, disclaimers, and support

Is scraping Google Flights legal? This actor scrapes only public-facing flight pricing data. Public-data scraping has been upheld in U.S. courts (hiQ Labs v. LinkedIn, Meta v. Bright Data). You are responsible for complying with Google's Terms of Service and any local regulations in your jurisdiction. Do not use this actor for any purpose prohibited by Google's TOS or applicable law.

Why are some runs returning fewer flights than I see in my browser? Google Flights occasionally A/B-tests result-set sizes by region and account. Try changing country and currency to widen the pool. If you see zero results, the most common cause is a past departureDate.

Why is bookingUrl sometimes null? Direct booking links require an extra request per itinerary; for cost reasons v0.1 returns the search-level googleFlightsUrl and leaves bookingUrl for an opt-in event in v0.2.

Does this work for multi-city trips? v0.1 supports one-way and round-trip. Multi-city is on the v0.2 roadmap.

How reliable is it? Target is 95%+ success rate across diverse routes. We use Apify residential proxies, session-consistent cookies, exponential-backoff retries, and a circuit breaker. When Google updates its internal data structure, the parser returns zero results and saves a snapshot to the Key-Value Store — open an issue and we'll patch within 24–48 hours.

Need help or have feedback? Use the Issues tab on the actor page. Custom features, schema additions, or higher-volume contracts: reach out via Apify's contact form on the actor page.