Round trip doesn't seem to return what it should

[vjarysta]

Hello,

I'm using get_flights with round-trip and it doesn't seem to return what a normal round trip should represent.

Code

for from_airport in departure_airports:
  for to_airport in arrival_airports:
    for ret_date in return_dates:
      flight_data = [
        FlightData(
          date=departure_date,
          from_airport=from_airport,
          to_airport=to_airport
        ),
        FlightData(
          date=ret_date,
          from_airport=to_airport,
          to_airport=from_airport
        )
      ]

      try:
        result: Result = get_flights(
          flight_data=flight_data,
          trip="round-trip",
          seat="economy",
          passengers=passengers,
          fetch_mode="fallback",
        )

        flight_dicts = [
          {**flight.__dict__, "departure_airport": from_airport, "arrival_airport": to_airport}
          for flight in result.flights
        ]

        raw_flight_data.append(flight_dicts)
      except Exception as e:
        print(f"[WARN] Impossible de récupérer les vols pour {from_airport} -> {to_airport} ({departure_date} / {ret_date}), erreur : {e}")
        continue

with open(json_file_path, "w") as json_file:
  json.dump(raw_flight_data, json_file, indent=4)

Actual result

{
    "is_best": true,
    "name": "Ryanair",
    "departure": "9:50 AM on Wed, Feb 5",
    "arrival": "11:05 AM on Wed, Feb 5",
    "arrival_time_ahead": "",
    "duration": "2 hr 15 min",
    "stops": 0,
    "delay": null,
    "price": "$48",
    "departure_airport": "BVA",
    "arrival_airport": "OPO"
},
{
    "is_best": true,
    "name": "Ryanair",
    "departure": "9:45 PM on Wed, Feb 5",
    "arrival": "11:00 PM on Wed, Feb 5",
    "arrival_time_ahead": "",
    "duration": "2 hr 15 min",
    "stops": 0,
    "delay": null,
    "price": "$61",
    "departure_airport": "BVA",
    "arrival_airport": "OPO"
},
{
    "is_best": true,
    "name": "Self transferThis trip includes tickets from multiple airlines. Missed connections may be protected by the booking provider.",
    "departure": "9:15 AM on Wed, Feb 5",
    "arrival": "8:50 AM on Thu, Feb 6",
    "arrival_time_ahead": "+1",
    "duration": "24 hr 35 min",
    "stops": 2,
    "delay": null,
    "price": "$200",
    "departure_airport": "BVA",
    "arrival_airport": "OPO"
},

Expected result

{
    "is_best": true,
    "name_outbound": "Ryanair",
    "departure_outbound": "9:50 AM on Wed, Feb 5",
    "arrival_outbound": "11:05 AM on Wed, Feb 5",
    "arrival_time_ahead_outbound": "",
    "duration_outbound": "2 hr 15 min",
    "stops_outbound": 0,
    "name_return": "Ryanair",
    "departure_return": "9:50 AM on Wed, Feb 5",
    "arrival_return": "11:05 AM on Wed, Feb 5",
    "arrival_time_ahead_return": "",
    "duration_return": "2 hr 15 min",
    "stops_return": 0,
    "delay": null,
    "price": "$48",
    "departure_airport": "BVA",
    "arrival_airport": "OPO"
},
{
    "is_best": true,
    "name_outbound": "Ryanair",
    "departure_outbound": "9:45 PM on Wed, Feb 5",
    "arrival_outbound": "11:00 PM on Wed, Feb 5",
    "arrival_time_ahead_outbound": "",
    "duration_outbound": "2 hr 15 min",
    "stops_outbound": 0,
    "name_return": "Ryanair",
    "departure_return": "9:45 PM on Wed, Feb 5",
    "arrival_return": "11:00 PM on Wed, Feb 5",
    "arrival_time_ahead_return": "",
    "duration_return": "2 hr 15 min",
    "stops_return": 0,
    "delay": null,
    "price": "$61",
    "departure_airport": "BVA",
    "arrival_airport": "OPO"
},
{
    "is_best": true,
    "name_outbound": "Self transferThis trip includes tickets from multiple airlines. Missed connections may be protected by the booking provider.",
    "departure_outbound": "9:15 AM on Wed, Feb 5",
    "arrival_outbound": "8:50 AM on Thu, Feb 6",
    "arrival_time_ahead_outbound": "+1",
    "duration_outbound": "24 hr 35 min",
    "stops_outbound": 2,
    "name_return": "Self transferThis trip includes tickets from multiple airlines. Missed connections may be protected by the booking provider.",
    "departure_return": "9:15 AM on Wed, Feb 5",
    "arrival_return": "8:50 AM on Thu, Feb 6",
    "arrival_time_ahead_return": "+1",
    "duration_return": "24 hr 35 min",
    "stops_return": 2,
    "delay": null,
    "price": "$200",
    "departure_airport": "BVA",
    "arrival_airport": "OPO"
},

TL;DR: Maybe I'm missing something, but to me there should be a way to access the outbound flight data and the return flight data

[dosubot]

Hey @vjarysta! 👋 I'm here to help you with your coding adventures. I can assist in solving bugs, answering questions, and even becoming a contributor. Let's squash those bugs together!

To correctly return both outbound and return flight data for a round trip using the get_flights function, ensure that the function is set up to handle and differentiate between the outbound and return flights. The Result object returned by get_flights should contain a list of Flight objects, but it seems like your current implementation is not distinguishing between outbound and return flights in the expected result format.

Here's a suggestion to modify your code to achieve the expected result:

1. Modify the flight_dicts creation: You need to pair the outbound and return flights together. This can be done by iterating over the result.flights list in pairs, assuming the list is structured such that each pair of flights corresponds to an outbound and return flight.

2. Adjust the JSON structure: Create a dictionary that separates the outbound and return flight details.

Here's an example of how you might adjust your code:

for from_airport in departure_airports:
    for to_airport in arrival_airports:
        for ret_date in return_dates:
            flight_data = [
                FlightData(
                    date=departure_date,
                    from_airport=from_airport,
                    to_airport=to_airport
                ),
                FlightData(
                    date=ret_date,
                    from_airport=to_airport,
                    to_airport=from_airport
                )
            ]

            try:
                result: Result = get_flights(
                    flight_data=flight_data,
                    trip="round-trip",
                    seat="economy",
                    passengers=passengers,
                    fetch_mode="fallback",
                )

                # Assuming flights are returned in pairs (outbound, return)
                for i in range(0, len(result.flights), 2):
                    outbound_flight = result.flights[i]
                    return_flight = result.flights[i + 1]

                    flight_dict = {
                        "is_best": outbound_flight.is_best,
                        "name_outbound": outbound_flight.name,
                        "departure_outbound": outbound_flight.departure,
                        "arrival_outbound": outbound_flight.arrival,
                        "arrival_time_ahead_outbound": outbound_flight.arrival_time_ahead,
                        "duration_outbound": outbound_flight.duration,
                        "stops_outbound": outbound_flight.stops,
                        "name_return": return_flight.name,
                        "departure_return": return_flight.departure,
                        "arrival_return": return_flight.arrival,
                        "arrival_time_ahead_return": return_flight.arrival_time_ahead,
                        "duration_return": return_flight.duration,
                        "stops_return": return_flight.stops,
                        "delay": outbound_flight.delay,  # Assuming delay is the same for both
                        "price": outbound_flight.price,  # Assuming price is the same for both
                        "departure_airport": from_airport,
                        "arrival_airport": to_airport
                    }

                    raw_flight_data.append(flight_dict)

            except Exception as e:
                print(f"[WARN] Impossible de récupérer les vols pour {from_airport} -> {to_airport} ({departure_date} / {ret_date}), erreur : {e}")
                continue

with open(json_file_path, "w") as json_file:
    json.dump(raw_flight_data, json_file, indent=4)

This approach assumes that the result.flights list contains flights in pairs, with each pair representing an outbound and return flight. Adjust the logic if the structure of result.flights differs.

To continue talking to Dosu, mention @dosu.

---

^{Help Dosu learn! Give it feedback: Great Response | Irrelevant Answer | Incorrect Sources | Too Verbose | Hallucination | Other}

[AWeirdDev]

I'm sorry, I don't quite understand. Is there something expected didn't display properly?
I checked the source code and the schema is defined here:

https://github.com/AWeirdDev/flights/blob/main/fast_flights/schema.py#L13-L23

I'm guessing this is a feature request? I'll admit that I am a bit clueless when it comes to scraping the web ;)

JC

[vjarysta]

Sorry if I was not being clear.

To me, a one-way trip should return one Flight, but a round-trip should return 2 flights.
If I'm looking for a LAX-SFO round trip, I want to be able to check the departure property from the LAX-SFO flight , but from the SFO-LAX return flight as well.

At the moment it seems like I'm able to search for a round trip, but can only access to data from the "outbound" trip (the first one)

[AWeirdDev]

Ah, I see. I'll check that on desktop later.

[esalonico]

I have the same issue/question. Basically, when I query a round-trip, I would expect a tuple of len 2 of flights where the first item is the outbound flight (LAX-SFO) and the second one is the return flights on the return date I specify (SFO-LAX). The price for these 2 flights would be the same, and Google Flights already shows it on the outbound flight (see EUR 513 in screenshot).

A further thing to keep in mind is that for each outbound round-trip flight, there can be 1 or more return flights with different prices, which are visible once you click on the outbound flight (see second screenshot or visit this link).

In other words, for a round-trip search, this is the output I would expect:

• outbound_1 / return_1_1
• outbound_1 / return_1_2
• outbound_1 / return_1_3
• outbound_2 / return_2_1
• outbound_2 / return_2_2....

@AWeirdDev Please let me know if this is clear, happy to help with the implementation if needed :)

[AWeirdDev]

I'm guessing this requires two requests: one for selecting the departing flight, and the other for parsing the returning flight.

When querying returning flights, the query data may be present in the tfs or tfu query parameter... which means there's more data guessing game 😱

I'll keep y'all updated if I find any pattern there.

[esalonico]

This is the tfs field (decoded) when I click on a departing flight (if it helps).

https://www.google.com/travel/flights/search?tfs=CBwQAhpBEgoyMDI1LTAxLTIwIh8KA0ZDTxIKMjAyNS0wMS0yMBoDTVVDKgJBWjIDNDM2KAFqBwgBEgNGQ09yBwgBEgNNVUMaIBIKMjAyNS0wMS0yNSgBagcIARIDTVVDcgcIARIDRkNPQAFIAXABggELCP___________wGYAQE&tfu=CmxDalJJY1ROMmIwVTJZakUwVFZWQlFtSlhVbmRDUnkwdExTMHRMUzB0TFhCbVpYa3lOVUZCUVVGQlIyVkNUbkJGU2kxMVlYZEJFZ1ZCV2pRek5ob0xDSXlTQVJBQ0dnTkZWVkk0SEhEbGxRRT0SAggAIgMKATA&hl=en&curr=EUR

[aerospeace]

Not sure it makes any help or provide any encouragement, but I would also be highly interested in getting this "feature": to be fair a non-single-route query at the moment is not returning anything useful at this stage).
Sorry I cannot help with the implementation, protobuf is way above my skill set!

[vjarysta]

@AWeirdDev requesting the departing and returning flights is not the same as selecting a round trip.

Most companies will apply a discount if you are flying with a round trip, so departingFlight.price + returnFlight.price > roundTrip.price most of the time.

Thanks for your updates 🙏

[mtnrabi]

I'm guessing this requires two requests: one for selecting the departing flight, and the other for parsing the returning flight.

When querying returning flights, the query data may be present in the tfs or tfu query parameter... which means there's more data guessing game 😱

I'll keep y'all updated if I find any pattern there.

Hi Man!

Gotta say I love this repo and love the way you wrote the readme 😆

I came up with this project while trying to understand myself how to "reverse engineer" their API instead of using scraping (because of one word - slow haha).

I wonder if you had any progress with integrating the returning flights into this package (even if not final state).
Maybe I could chime in and help

[mtnrabi]

@AWeirdDev @vjarysta Hi folks, so I made some progress with parsing roundtrip flights.

To get the returning flight options, you need to have an additional request - specifying which departure flight you're taking.
The reason being that google-flights round-trip API works in a way where it returns the returning flights based on the departure flight you've chosen - specifically the airline (I guess because those airlines offer meaningful discounts on booking round-trip with them).

Google will even go as far as not show you other options from other airlines in the returning flights, if a returning flight with the same airline exists (which I found quite weird).

Anyways - to the fun part.

So I grabbed the tfs url param after choosing a specific flight in a round-trip, decoded it using https://protobuf-decoder.netlify.app/ and found the differences from a regular one-way flight search structure.

Here's the protobuf:

syntax = "proto3";

message Flight {
  string from_airport = 1;
  string date = 2;
  string to_airport = 3;
  string airline = 5;
  string flight_number = 6;
}

message AirportCode {
    string path = 2;
}

message FlightData {
  string date = 2;
  Flight flight = 4;
  AirportCode airport_from = 13;
  AirportCode airport_to = 14;
}

enum Seat {
  UNKNOWN_SEAT = 0;
  ECONOMY = 1;
  PREMIUM_ECONOMY = 2;
  BUSINESS = 3;
  FIRST = 4;
}

enum Trip {
  UNKNOWN_TRIP = 0;
  ROUND_TRIP = 1;
  ONE_WAY = 2;
  MULTI_CITY = 3; // not implemented
}

enum Passenger {
  UNKNOWN_PASSENGER = 0;
  ADULT = 1;
  CHILD = 2;
  INFANT_IN_SEAT = 3;
  INFANT_ON_LAP  = 4;
}

message RoundTripData {
  repeated FlightData flights_data = 3;
  repeated Passenger passengers = 8;
  Seat seat = 9;
  Trip trip = 19;
}

And here's how I crafted a custom tfs for getting return flight options:

import base64
from schema_pb2 import RoundTripData


def parse_proto() -> bytes:
    round_trip_data = RoundTripData()

    departure_flight = round_trip_data.flights_data.add()
    departure_flight.date = "2025-09-01"
    departure_flight.flight.from_airport = "TLV"
    departure_flight.flight.date = "2025-09-01"
    departure_flight.flight.to_airport = "RHO"
    departure_flight.flight.airline = "LY"
    departure_flight.flight.flight_number = "5221"
    departure_flight.airport_from.path = "/m/07qzv"
    departure_flight.airport_to.path = "/m/06ky_"

    return_flight = round_trip_data.flights_data.add()
    return_flight.airport_from.path = "/m/06ky_"
    return_flight.airport_to.path = "/m/07qzv"

    round_trip_data.passengers.append(1)
    round_trip_data.seat = 1
    round_trip_data.trip = 1

    return round_trip_data.SerializeToString()


def get_tfs() -> str:
    binary = parse_proto()
    return base64.urlsafe_b64encode(binary).decode('utf-8').rstrip('=')


generated = get_tfs()
print("Generated:", generated)

But - the effort is not finished yet.

Flights-API does not return 3 values that seems to be required by the returning flights round-trip API:

1. Flight airline code (i.e. for "El Al" the code is "LY")
2. Flight number (i.e. "5221"). The full value of this would be "LY 5221", but the API splits them into airline code and flight number
3. That's a weird one - there seems to a "code / path" for an airport that google is using. i.e. for Rhodes (RHO) - it's "/m/06ky_", fo Tel Aviv (TLV) it's "/m/07qzv". Not sure where it's coming from

I'll keep digging on finishing this effort, just wanted to let you guys know (especially the senior stuff principal protobuf developer amongst us from whom I took great inspiration - @AWeirdDev) that I've started and made some progress on properly getting the returning flights in a round-trip search.

[esalonico]

@mtnrabi thanks a lot for this!!

While playing around with round trips, I was able to find a workaround to get the complete flight number (airline code + flight number) that you mention in your points 1 and 2.

If you look at the HTML property data-travelimpactmodelwebsiteurl of class NZRfve, you will basically see that Google Flights leaves an external URL from which it retreives emission data for a specific flight. In this URL, you can find the airline code and the flight number (sometimes there is more that one flight in the case of non-direct flights, see screenshot for more details) and they can be easily extracted with a regex (see below).

For example: https://www.travelimpactmodel.org/lookup/flight?itinerary=MUC-FCO-AZ-437-20250331

Let me know if this helps or you need some help to integrate this into your solution ;)

def extract_airline_code_and_flight_number(s: str) -> Optional[List[Tuple[str, str]]]:
        """
        Extracts the airline code and flight number from a string.

        :param s: The string to extract the airline code and flight number from.
        :return: A list of tuples containing the airline code and flight number. Returns [] if no matches are found.

        Example:
        https://www.travelimpactmodel.org/lookup/flight?itinerary=FCO-FLR-AZ-1679-20250120,FLR-MUC-EN-8191-2025012
        [("AZ", "1679"), ("EN", "8191")]

        Special cases:
        - A3 1234 (number in flight code)
        - FV 12 (flight code has only 2 digits)
        """
        pattern = r"-([A-Z0-9]{2})-(\d{2,4})-"
        result = re.findall(pattern, s)
        if not result:
            print("No airline code and flight number found in:", s)
        return result

[AWeirdDev]

Hi it's me again.

If you searched /m/06ky_ directly on Google, you'd see some interesting results poppin' up:

• https://wikidata.org/wiki/Q43048

That's Rhodes. If you scroll down a little bit further, you should see a "Freebase ID" column:

Apparently, Google's using Freebase for the geonames and more.

Not sure if this helps, but I'm happy to do some goofy researches.

[mtnrabi]

@AWeirdDev @esalonico I was able to use both of your researches to create a custom parser, that would fetch the needed fields:

[It's a draft so still a bit ugly]

def extract_airport_path(s: str) -> str:
    pattern = r";(.*?);"
    result = re.findall(pattern, s)
    if not result:
        print("No airport path found in:", s)
    return result[0]


def extract_airline_code_and_flight_number(s: str) -> Optional[List[Tuple[str, str]]]:
    """
    Extracts the airline code and flight number from a string.

    :param s: The string to extract the airline code and flight number from.
    :return: A list of tuples containing the airline code and flight number. Returns [] if no matches are found.

    Example:
    https://www.travelimpactmodel.org/lookup/flight?itinerary=FCO-FLR-AZ-1679-20250120,FLR-MUC-EN-8191-2025012
    [("AZ", "1679"), ("EN", "8191")]

    Special cases:
    - A3 1234 (number in flight code)
    - FV 12 (flight code has only 2 digits)
    """
    pattern = r"-([A-Z0-9]{2})-(\d{2,4})-"
    result = re.findall(pattern, s)
    if not result:
        print("No airline code and flight number found in:", s)
    return result


def custom_response_parser(res):
    # Changes from original:
    # Adds fields to each flight:
    # - Flight airline code (i.e. for "El Al" the code is "LY")
    # - Flight number (i.e. "5221")
    # - Airport path (i.e. for Rhodes (RHO) - it's "/m/06ky_")

    class _blank:
        def text(self, *_, **__):
            return ""

        def iter(self):
            return []

    blank = _blank()

    def safe(n: Optional[LexborNode]):
        return n or blank

    parser = LexborHTMLParser(res.text)
    flights = []

    for i, fl in enumerate(parser.css('div[jsname="IWWDBc"], div[jsname="YdtKid"]')):
        is_best_flight = i == 0

        for item in fl.css("ul.Rk10dc li")[
                    : (None if i == 0 else -1)
                    ]:
            # Flight name
            name = safe(item.css_first("div.sSHqwe.tPgKwe.ogfYpf span")).text(
                strip=True
            )
            print(name)

            # Get departure & arrival time
            dp_ar_node = item.css("span.mv1WYe div")
            try:
                departure_time = dp_ar_node[0].text(strip=True)
                arrival_time = dp_ar_node[1].text(strip=True)
            except IndexError:
                # sometimes this is not present
                departure_time = ""
                arrival_time = ""

            # Get arrival time ahead
            time_ahead = safe(item.css_first("span.bOzv6")).text()

            # Get duration
            duration = safe(item.css_first("li div.Ak5kof div")).text()

            # Get flight stops
            stops = safe(item.css_first(".BbR8Ec .ogfYpf")).text()

            # Get delay
            delay = safe(item.css_first(".GsCCve")).text() or None

            # Get prices
            price = safe(item.css_first(".YMlIz.FpEdX")).text() or "0"

            # Stops formatting
            try:
                stops_fmt = 0 if stops == "Nonstop" else int(stops.split(" ", 1)[0])
            except ValueError:
                stops_fmt = "Unknown"

            try:
                airline_code, flight_number = extract_airline_code_and_flight_number(
                    item.css_first(".NZRfve").attributes["data-travelimpactmodelwebsiteurl"])[0]
            except Exception:
                airline_code, flight_number = None, None

            try:
                airport_from_path = extract_airport_path(
                    parser.css_first('div[jsname="FDWhSe"]').attributes["data-initial"])
                airport_to_path = extract_airport_path(
                    parser.css_first('div[jsname="iOyk4d"]').attributes["data-initial"])
            except:
                airport_from_path, airport_to_path = None, None

            flights.append(
                {
                    "is_best": is_best_flight,
                    "name": name,
                    "departure": " ".join(departure_time.split()),
                    "arrival": " ".join(arrival_time.split()),
                    "arrival_time_ahead": time_ahead,
                    "duration": duration,
                    "stops": stops_fmt,
                    "delay": delay,
                    "price": price.replace(",", ""),
                    "airline_code": airline_code,
                    "flight_number": flight_number,
                    "airport_from_path": airport_from_path,
                    "airport_to_path": airport_to_path
                }
            )

    current_price = safe(parser.css_first("span.gOatQ")).text()
    return {"current_price": current_price, "flights": flights}

The intention is for custom_response_parser to replace parse_response method in fast_flights.core.

It works, here's an example of what it returns:

    "flights": [
        {
            "is_best": true,
            "name": "Bluebird Airways",
            "departure": "2:20 PM on Mon, Sep 1",
            "arrival": "4:00 PM on Mon, Sep 1",
            "arrival_time_ahead": "",
            "duration": "1 hr 40 min",
            "stops": 0,
            "delay": null,
            "price": "$79",
            "airline_code": "BZ",
            "flight_number": "694",
            "airport_from_path": "/m/07qzv",
            "airport_to_path": "/m/07yfd0"
        },
        {
            "is_best": true,
            "name": "Bluebird Airways",
            "departure": "9:10 AM on Mon, Sep 1",
            "arrival": "10:50 AM on Mon, Sep 1",
            "arrival_time_ahead": "",
            "duration": "1 hr 40 min",
            "stops": 0,
            "delay": null,
            "price": "$88",
            "airline_code": "BZ",
            "flight_number": "692",
            "airport_from_path": "/m/07qzv",
            "airport_to_path": "/m/07yfd0"
        },
...

But, it's still not complete -

1. Im not sure if when parsing data from the google flights HTML response, it's better to rely on css class or jsname.
   Currently, for airline code & flight number Im relying on a class, while for airport paths Im relying on jsname (I really just chose randonly).
   Maybe @AWeirdDev could share from his experience, what's better to rely on when fetching data

2. For the getting the roundtrip results, the example I demonstrated here when I was successful in creating a custom TFS for getting the roundtrip flights - was when the first chosen flight (departure flight) had no stops.
   Im not sure what google's API expects when the departure flight has stops, I'll have to dig in some research on that

Anyways - I'll continue working on those points and keep you guys posted.

@AWeirdDev @esalonico Thanks for your help, I love this team effort ! We're cracking this shit