How to Scrape Google Flights Search Data with TalorData

Google Flights search data is useful when you need fresh information about routes, airlines, prices, stops, duration, departure times, arrival times, booking options, and fare changes.

For travel platforms, OTAs, pricing teams, market researchers, and AI travel agents, this data can support workflows like:

The key is structure. Browser pages are hard to store, compare, or feed into systems. JSON data is much easier to use in dashboards, alerts, reports, and AI workflows.

In this guide, we will build a Python workflow that sends Google Flights requests through TalorData, parses the response, extracts flight data, and exports clean tables.

The basic workflow looks like this:

Route + date + passenger settings
   ↓
TalorData SERP API
   ↓
Google Flights data in JSON
   ↓
Parse flights, prices, airlines, stops, duration
   ↓
Save to CSV or database
   ↓
Use for monitoring, dashboards, or AI agents

What flight data can you collect?

For a Google Flights workflow, the most useful fields are usually route, date, schedule, airline, price, and booking context. A typical structured flight response can include departure and arrival airports, flight duration, layovers, carbon emissions, prices, and price insights.

For price monitoring, timestamp is not optional. A fare collected today may not match the fare shown tomorrow.

Core Google Flights parameters

A Google Flights request usually starts with route, date, passenger, localization, and output settings. Airport IDs are commonly three-letter IATA airport codes such as JFK, LAX, LHR, or SIN, and some APIs also allow location identifiers for broader city or region searches.

For a one-way search, departure_id, arrival_id, and outbound_date are the core inputs. For a round trip, add return_date. For multi-city itineraries, use a multi-city payload instead of one simple route.

Basic request structure

Use the endpoint and authentication format from your TalorData account. The request body below shows the shape of a simple one-way flight search.

{
  "engine": "google_flights",
  "departure_id": "JFK",
  "arrival_id": "LAX",
  "outbound_date": "2026-08-15",
  "flight_type": "one_way",
  "adults": 1,
  "currency": "USD",
  "hl": "en",
  "gl": "us",
  "no_cache": true
}

For a round trip:

{
  "engine": "google_flights",
  "departure_id": "JFK",
  "arrival_id": "LAX",
  "outbound_date": "2026-08-15",
  "return_date": "2026-08-22",
  "flight_type": "round_trip",
  "adults": 1,
  "currency": "USD",
  "hl": "en",
  "gl": "us",
  "no_cache": true
}

Step 1: Set up your API key

Store your TalorData API key and endpoint as environment variables.

export TALORDATA_API_KEY="your_api_key_here"
export TALORDATA_SERP_ENDPOINT="your_talordata_serp_endpoint_here"

On Windows PowerShell:

setx TALORDATA_API_KEY "your_api_key_here"
setx TALORDATA_SERP_ENDPOINT "your_talordata_serp_endpoint_here"

Install the dependencies:

pip install requests pandas

Step 2: Create a reusable Python client

This function sends a Google Flights request and returns JSON.

import os
import requests
from typing import Any, Dict, Optional


TALORDATA_API_KEY = os.getenv("TALORDATA_API_KEY")
TALORDATA_SERP_ENDPOINT = os.getenv("TALORDATA_SERP_ENDPOINT")


def fetch_google_flights(
    departure_id: str,
    arrival_id: str,
    outbound_date: str,
    return_date: Optional[str] = None,
    flight_type: str = "one_way",
    adults: int = 1,
    children: int = 0,
    currency: str = "USD",
    hl: str = "en",
    gl: str = "us",
    travel_class: str = "economy",
    no_cache: bool = True,
    extra_params: Optional[Dict[str, Any]] = None
) -> Dict[str, Any]:
    """
    Fetch Google Flights search data with TalorData SERP API.

    Adjust parameter names if your TalorData account uses numeric values
    for type, travel_class, or stops.
    """
    if not TALORDATA_API_KEY:
        raise RuntimeError("Missing TALORDATA_API_KEY environment variable.")

    if not TALORDATA_SERP_ENDPOINT:
        raise RuntimeError("Missing TALORDATA_SERP_ENDPOINT environment variable.")

    payload: Dict[str, Any] = {
        "engine": "google_flights",
        "departure_id": departure_id,
        "arrival_id": arrival_id,
        "outbound_date": outbound_date,
        "flight_type": flight_type,
        "adults": adults,
        "children": children,
        "currency": currency,
        "hl": hl,
        "gl": gl,
        "travel_class": travel_class,
        "no_cache": no_cache
    }

    if return_date:
        payload["return_date"] = return_date

    if extra_params:
        payload.update(extra_params)

    response = requests.post(
        TALORDATA_SERP_ENDPOINT,
        json=payload,
        headers={
            "Authorization": f"Bearer {TALORDATA_API_KEY}",
            "Content-Type": "application/json"
        },
        timeout=45
    )

    response.raise_for_status()
    return response.json()

Run a basic search:

if __name__ == "__main__":
    data = fetch_google_flights(
        departure_id="JFK",
        arrival_id="LAX",
        outbound_date="2026-08-15",
        flight_type="one_way",
        adults=1,
        currency="USD"
    )

    print(data)

Step 3: Inspect the raw response

Before building a parser, inspect the first response.

import json

print(json.dumps(data, indent=2, ensure_ascii=False)[:6000])

Common top-level containers in Google Flights-style responses include:

best_flights
other_flights
flights
price_insights
airports
search_parameters

The exact shape can vary by request type, route, and result mode. Do not chisel the parser into granite too early. First read the JSON cave wall with a flashlight.

Step 4: Parse flight results

A Google Flights response often groups results into best_flights and other_flights. Each itinerary may contain one or more flight segments.

Here is a defensive parser:

from typing import Any, Dict, List


def get_flight_groups(data: Dict[str, Any]) -> List[Dict[str, Any]]:
    groups = []

    for group_name in ["best_flights", "other_flights", "flights"]:
        value = data.get(group_name)

        if isinstance(value, list):
            for item in value:
                item["_group"] = group_name
                groups.append(item)

    return groups


def parse_google_flights(data: Dict[str, Any]) -> List[Dict[str, Any]]:
    itineraries = get_flight_groups(data)
    rows = []

    for position, itinerary in enumerate(itineraries, start=1):
        segments = itinerary.get("flights", [])

        first_segment = segments[0] if segments else {}
        last_segment = segments[-1] if segments else {}

        departure_airport = first_segment.get("departure_airport", {})
        arrival_airport = last_segment.get("arrival_airport", {})

        airlines = sorted({
            segment.get("airline")
            for segment in segments
            if segment.get("airline")
        })

        flight_numbers = [
            segment.get("flight_number")
            for segment in segments
            if segment.get("flight_number")
        ]

        rows.append({
            "position": position,
            "group": itinerary.get("_group"),
            "airlines": ", ".join(airlines),
            "flight_numbers": ", ".join(flight_numbers),
            "departure_airport_name": departure_airport.get("name"),
            "departure_airport_id": departure_airport.get("id"),
            "departure_time": departure_airport.get("time"),
            "arrival_airport_name": arrival_airport.get("name"),
            "arrival_airport_id": arrival_airport.get("id"),
            "arrival_time": arrival_airport.get("time"),
            "duration": itinerary.get("total_duration") or itinerary.get("duration"),
            "stops": max(len(segments) - 1, 0),
            "price": itinerary.get("price"),
            "extracted_price": itinerary.get("extracted_price"),
            "currency": itinerary.get("currency"),
            "booking_token": itinerary.get("booking_token"),
            "departure_token": itinerary.get("departure_token"),
            "carbon_emissions": itinerary.get("carbon_emissions"),
            "layovers": itinerary.get("layovers"),
        })

    return rows

Use it:

data = fetch_google_flights(
    departure_id="JFK",
    arrival_id="LAX",
    outbound_date="2026-08-15"
)

rows = parse_google_flights(data)

for row in rows[:5]:
    print(row["position"], row["airlines"], row["price"], row["stops"])

Step 5: Save flight data to CSV

import pandas as pd


data = fetch_google_flights(
    departure_id="JFK",
    arrival_id="LAX",
    outbound_date="2026-08-15",
    flight_type="one_way",
    adults=1,
    currency="USD"
)

rows = parse_google_flights(data)

df = pd.DataFrame(rows)
df.to_csv("google_flights_results.csv", index=False)

print(df.head())

A clean CSV may look like this:

Step 6: Add search context

Flight results without search context are hard to compare later. Always store route, date, passenger, currency, language, country, and timestamp.

from datetime import datetime, timezone


def add_search_context(
    rows: List[Dict[str, Any]],
    departure_id: str,
    arrival_id: str,
    outbound_date: str,
    return_date: Optional[str],
    flight_type: str,
    adults: int,
    currency: str,
    hl: str,
    gl: str
) -> List[Dict[str, Any]]:
    collected_at = datetime.now(timezone.utc).isoformat()

    for row in rows:
        row["departure_id"] = departure_id
        row["arrival_id"] = arrival_id
        row["outbound_date"] = outbound_date
        row["return_date"] = return_date
        row["flight_type"] = flight_type
        row["adults"] = adults
        row["currency"] = currency
        row["hl"] = hl
        row["gl"] = gl
        row["collected_at"] = collected_at

    return rows

Usage:

departure_id = "JFK"
arrival_id = "LAX"
outbound_date = "2026-08-15"
return_date = None
flight_type = "one_way"
adults = 1
currency = "USD"
hl = "en"
gl = "us"

data = fetch_google_flights(
    departure_id=departure_id,
    arrival_id=arrival_id,
    outbound_date=outbound_date,
    return_date=return_date,
    flight_type=flight_type,
    adults=adults,
    currency=currency,
    hl=hl,
    gl=gl
)

rows = parse_google_flights(data)
rows = add_search_context(
    rows,
    departure_id=departure_id,
    arrival_id=arrival_id,
    outbound_date=outbound_date,
    return_date=return_date,
    flight_type=flight_type,
    adults=adults,
    currency=currency,
    hl=hl,
    gl=gl
)

pd.DataFrame(rows).to_csv("google_flights_snapshot.csv", index=False)

Step 7: Track prices over time

For fare monitoring, you usually care about the lowest price per route and date.

df["price_num"] = pd.to_numeric(df["extracted_price"], errors="coerce")

cheapest = df.sort_values(
    by=["price_num", "stops"],
    ascending=[True, True]
).head(10)

cheapest.to_csv("cheapest_google_flights.csv", index=False)

print(cheapest[[
    "position",
    "airlines",
    "departure_airport_id",
    "arrival_airport_id",
    "stops",
    "duration",
    "price",
    "price_num"
]])

Useful signals:

For recurring jobs, append every snapshot to a database or daily CSV file instead of overwriting old data.

Step 8: Monitor multiple routes

Travel teams often monitor many routes at once.

routes = [
    {"departure_id": "JFK", "arrival_id": "LAX"},
    {"departure_id": "SFO", "arrival_id": "SEA"},
    {"departure_id": "LHR", "arrival_id": "CDG"},
]

all_rows = []

for route in routes:
    data = fetch_google_flights(
        departure_id=route["departure_id"],
        arrival_id=route["arrival_id"],
        outbound_date="2026-08-15",
        flight_type="one_way",
        adults=1,
        currency="USD"
    )

    rows = parse_google_flights(data)
    rows = add_search_context(
        rows,
        departure_id=route["departure_id"],
        arrival_id=route["arrival_id"],
        outbound_date="2026-08-15",
        return_date=None,
        flight_type="one_way",
        adults=1,
        currency="USD",
        hl="en",
        gl="us"
    )

    all_rows.extend(rows)

pd.DataFrame(all_rows).to_csv("multi_route_google_flights.csv", index=False)

This supports:

Step 9: Handle round trips

Round-trip data can be more complex because the outbound selection may determine available return options.

A simple round-trip request starts like this:

data = fetch_google_flights(
    departure_id="JFK",
    arrival_id="LAX",
    outbound_date="2026-08-15",
    return_date="2026-08-22",
    flight_type="round_trip",
    adults=1,
    currency="USD"
)

If the response includes departure_token, you may need a second request to fetch return-flight options for a selected outbound itinerary. Flight APIs commonly use departure or booking tokens to continue from initial flight results to the next leg or booking options.

A continuation function can look like this:

def fetch_google_flights_with_token(
    departure_token: Optional[str] = None,
    booking_token: Optional[str] = None,
    extra_params: Optional[Dict[str, Any]] = None
) -> Dict[str, Any]:
    if not departure_token and not booking_token:
        raise ValueError("Provide departure_token or booking_token.")

    payload: Dict[str, Any] = {
        "engine": "google_flights"
    }

    if departure_token:
        payload["departure_token"] = departure_token

    if booking_token:
        payload["booking_token"] = booking_token

    if extra_params:
        payload.update(extra_params)

    response = requests.post(
        TALORDATA_SERP_ENDPOINT,
        json=payload,
        headers={
            "Authorization": f"Bearer {TALORDATA_API_KEY}",
            "Content-Type": "application/json"
        },
        timeout=45
    )

    response.raise_for_status()
    return response.json()

Use this pattern when you need full round-trip or booking-option data.

Step 10: Multi-city flight search

For multi-city itineraries, use a structured list of flight segments.

multi_city_json = [
    {
        "departure_id": "JFK",
        "arrival_id": "LHR",
        "date": "2026-08-15"
    },
    {
        "departure_id": "LHR",
        "arrival_id": "CDG",
        "date": "2026-08-20"
    },
    {
        "departure_id": "CDG",
        "arrival_id": "JFK",
        "date": "2026-08-25"
    }
]

data = fetch_google_flights(
    departure_id="",
    arrival_id="",
    outbound_date="",
    flight_type="multi_city",
    adults=1,
    currency="USD",
    extra_params={
        "multi_city_json": multi_city_json
    }
)

Multi-city workflows are useful for:

Step 11: Add filters

Filters make the data more useful.

Example:

data = fetch_google_flights(
    departure_id="JFK",
    arrival_id="LAX",
    outbound_date="2026-08-15",
    flight_type="one_way",
    adults=1,
    currency="USD",
    extra_params={
        "stops": "nonstop",
        "travel_class": "economy",
        "max_duration": 420,
        "include_airlines": "DL,B6,AA"
    }
)

For production, keep filters explicit. A fare alert without saved filters is a tiny weather report with no city name.

Complete script

Here is a complete one-way route script.

import os
import json
import requests
import pandas as pd
from datetime import datetime, timezone
from typing import Any, Dict, List, Optional


TALORDATA_API_KEY = os.getenv("TALORDATA_API_KEY")
TALORDATA_SERP_ENDPOINT = os.getenv("TALORDATA_SERP_ENDPOINT")


def fetch_google_flights(
    departure_id: str,
    arrival_id: str,
    outbound_date: str,
    return_date: Optional[str] = None,
    flight_type: str = "one_way",
    adults: int = 1,
    children: int = 0,
    currency: str = "USD",
    hl: str = "en",
    gl: str = "us",
    travel_class: str = "economy",
    no_cache: bool = True,
    extra_params: Optional[Dict[str, Any]] = None
) -> Dict[str, Any]:
    if not TALORDATA_API_KEY:
        raise RuntimeError("Missing TALORDATA_API_KEY environment variable.")

    if not TALORDATA_SERP_ENDPOINT:
        raise RuntimeError("Missing TALORDATA_SERP_ENDPOINT environment variable.")

    payload: Dict[str, Any] = {
        "engine": "google_flights",
        "departure_id": departure_id,
        "arrival_id": arrival_id,
        "outbound_date": outbound_date,
        "flight_type": flight_type,
        "adults": adults,
        "children": children,
        "currency": currency,
        "hl": hl,
        "gl": gl,
        "travel_class": travel_class,
        "no_cache": no_cache
    }

    if return_date:
        payload["return_date"] = return_date

    if extra_params:
        payload.update(extra_params)

    response = requests.post(
        TALORDATA_SERP_ENDPOINT,
        json=payload,
        headers={
            "Authorization": f"Bearer {TALORDATA_API_KEY}",
            "Content-Type": "application/json"
        },
        timeout=45
    )

    response.raise_for_status()
    return response.json()


def get_flight_groups(data: Dict[str, Any]) -> List[Dict[str, Any]]:
    groups = []

    for group_name in ["best_flights", "other_flights", "flights"]:
        value = data.get(group_name)

        if isinstance(value, list):
            for item in value:
                item["_group"] = group_name
                groups.append(item)

    return groups


def parse_google_flights(data: Dict[str, Any]) -> List[Dict[str, Any]]:
    itineraries = get_flight_groups(data)
    rows = []

    for position, itinerary in enumerate(itineraries, start=1):
        segments = itinerary.get("flights", [])
        first_segment = segments[0] if segments else {}
        last_segment = segments[-1] if segments else {}

        departure_airport = first_segment.get("departure_airport", {})
        arrival_airport = last_segment.get("arrival_airport", {})

        airlines = sorted({
            segment.get("airline")
            for segment in segments
            if segment.get("airline")
        })

        flight_numbers = [
            segment.get("flight_number")
            for segment in segments
            if segment.get("flight_number")
        ]

        rows.append({
            "position": position,
            "group": itinerary.get("_group"),
            "airlines": ", ".join(airlines),
            "flight_numbers": ", ".join(flight_numbers),
            "departure_airport_name": departure_airport.get("name"),
            "departure_airport_id": departure_airport.get("id"),
            "departure_time": departure_airport.get("time"),
            "arrival_airport_name": arrival_airport.get("name"),
            "arrival_airport_id": arrival_airport.get("id"),
            "arrival_time": arrival_airport.get("time"),
            "duration": itinerary.get("total_duration") or itinerary.get("duration"),
            "stops": max(len(segments) - 1, 0),
            "price": itinerary.get("price"),
            "extracted_price": itinerary.get("extracted_price"),
            "currency": itinerary.get("currency"),
            "booking_token": itinerary.get("booking_token"),
            "departure_token": itinerary.get("departure_token"),
            "carbon_emissions": itinerary.get("carbon_emissions"),
            "layovers": itinerary.get("layovers"),
        })

    return rows


def add_search_context(
    rows: List[Dict[str, Any]],
    departure_id: str,
    arrival_id: str,
    outbound_date: str,
    return_date: Optional[str],
    flight_type: str,
    adults: int,
    currency: str,
    hl: str,
    gl: str
) -> List[Dict[str, Any]]:
    collected_at = datetime.now(timezone.utc).isoformat()

    for row in rows:
        row["departure_id"] = departure_id
        row["arrival_id"] = arrival_id
        row["outbound_date"] = outbound_date
        row["return_date"] = return_date
        row["flight_type"] = flight_type
        row["adults"] = adults
        row["currency"] = currency
        row["hl"] = hl
        row["gl"] = gl
        row["collected_at"] = collected_at

    return rows


def main() -> None:
    departure_id = "JFK"
    arrival_id = "LAX"
    outbound_date = "2026-08-15"
    return_date = None
    flight_type = "one_way"
    adults = 1
    currency = "USD"
    hl = "en"
    gl = "us"

    raw_data = fetch_google_flights(
        departure_id=departure_id,
        arrival_id=arrival_id,
        outbound_date=outbound_date,
        return_date=return_date,
        flight_type=flight_type,
        adults=adults,
        currency=currency,
        hl=hl,
        gl=gl
    )

    rows = parse_google_flights(raw_data)
    rows = add_search_context(
        rows,
        departure_id=departure_id,
        arrival_id=arrival_id,
        outbound_date=outbound_date,
        return_date=return_date,
        flight_type=flight_type,
        adults=adults,
        currency=currency,
        hl=hl,
        gl=gl
    )

    pd.DataFrame(rows).to_csv("google_flights_results.csv", index=False)

    with open("raw_google_flights_response.json", "w", encoding="utf-8") as file:
        json.dump(raw_data, file, ensure_ascii=False, indent=2)

    print(f"Saved {len(rows)} rows to google_flights_results.csv")
    print("Saved raw_google_flights_response.json")


if __name__ == "__main__":
    main()

What fields should you store?

Start with this schema:

{
  "search": {
    "departure_id": "JFK",
    "arrival_id": "LAX",
    "outbound_date": "2026-08-15",
    "return_date": null,
    "flight_type": "one_way",
    "adults": 1,
    "currency": "USD",
    "hl": "en",
    "gl": "us",
    "collected_at": "2026-06-30T09:00:00Z"
  },
  "flight": {
    "position": 1,
    "airlines": "JetBlue",
    "flight_numbers": "B6 123",
    "departure_airport_id": "JFK",
    "arrival_airport_id": "LAX",
    "departure_time": "2026-08-15 08:29",
    "arrival_time": "2026-08-15 11:25",
    "duration": 356,
    "stops": 0,
    "price": "$248",
    "extracted_price": 248,
    "currency": "USD",
    "booking_token": "..."
  }
}

For advanced workflows, also store:

Common mistakes

Mistake 1: Not storing timestamps

Flight prices change often. Every snapshot needs a collection time.

Mistake 2: Comparing different passenger settings

One adult and two adults may return different total prices. Store passenger counts.

Mistake 3: Mixing currencies

Always store currency and normalize prices before comparison.

Mistake 4: Treating price alone as best result

A cheaper flight with two long layovers may not be better than a slightly more expensive nonstop flight.

Mistake 5: Ignoring route context

JFK → LAX and NYC → Los Angeles area are not the same search. Airport selection changes the result set.

Mistake 6: Overwriting old data

For price monitoring, append snapshots instead of replacing them.

Final thoughts

Scraping Google Flights search data with TalorData is about turning flight search into structured, repeatable data. Start free trial of Google Flights API>>

Start with route and date parameters: departure_id, arrival_id, outbound_date, and return_date when needed. Add passenger count, currency, language, country, travel class, and filters. Then parse the response into clean fields: airline, flight number, price, duration, stops, airports, times, and booking tokens.

Once the data is structured, you can build price alerts, fare dashboards, airline visibility reports, travel market analysis, and AI travel agents.

Google Flights data is a moving departure board. A good API workflow turns it into a dataset your systems can board on time.

FAQ

Can I scrape Google Flights search data with TalorData?

Yes. Use the Google Flights engine with route, date, passenger, localization, and currency parameters, then parse the structured JSON response into flight records.

What parameters should I start with?

Start with engine, departure_id, arrival_id, outbound_date, return_date for round trips, adults, currency, hl, gl, and no_cache.

Can I track flight prices over time?

Yes. Save every response with route, date, passenger settings, currency, and timestamp. Then compare the lowest price or selected itinerary across snapshots.

What should I parse first?

Start with airline, flight number, departure airport, arrival airport, departure time, arrival time, duration, stops, price, currency, and booking token.