Using Skyscanner Flight Search API with Dark Sky API and City Geo-Location Lookup [Tutorial]

What are APIs?

Application programming interfaces (APIs) are the tools which can be used by developers to perform specific tasks needed in their apps. We like to think about APIs as of the building blocks of applications. When you need to do something in your application, you can develop the component by yourself; however, if there is a corresponding API, all you need to do is to connect to this API and make your application able to send requests and receive responses. Moreover, many modern APIs provide a vast range of ways of customization.

APIs are perfect to fasten the development cycle. Also, they help to simplify debugging and maintenance. At the same time, some problems are coming from the fact that too many APIs were created by now. It is hard to find something that perfectly meets your needs. In addition, each API may have its own interface and documentation.

Fortunately, there are services that can mitigate these problems. RapidAPI is an API marketplace. It provides a unified interface of communication with many different APIs. It is easy to find the needed API: you can search for it or browse the APIs categories on the website. Once you find what you need, you can immediately test it right in your browser or learn more about that API on the RapidAPI website. The billing for the APIs usage is also concentrated in one place. Moreover, you can manage and monitor all used APIs with the RapidAPI dashboards which display information about API usage, errors, latency, billing, etc.

Quick References

In this article, we are going to use 3 different APIs from the RapidAPI marketplace:

1. Skyscanner Flight Search API
2. Dark Sky API
3. City Geo-Location Lookup.

We will briefly go over the basic features of these APIs and then build a simple model application demonstrating how to use them in practice. It will show information about the weather in the departure and arrival points when searching for flights.

Skyscanner Flight Search API

Connect to APIThere are a few ways to find this API. First of all, this API is completely free, so, you can browse the list of free APIs and select Skyscanner API. Also, the API belongs to the category of “Travel, Transportations”, so you can browse this category too. Finally, all the APIs could be found directly by searching the API name from the home page of the RapidAPI website.

Once you are on the API’s page, you can start exploring it. The list of possible endpoints is located on the left side of the page:

If you select a particular endpoint, the middle and the right side of the screen will be updated. In the middle, you can see the description of the endpoint and the form where you should add the required and optional parameters for the request. The code for the request on the right side of the screen is updated as soon as you change something in the middle part:

It is important to note such header parameters as X-RapidAPI-Host and X-RapidAPI-Key. The first is used to identify the API which you want to call in your request. The second serves as an identifier of the project (application) in your account on the RapidAPI platform. The billing is conducted using these variables, so it is important to understand and correctly include them in each request you send.

RapidAPI supports a range of programming languages. You can view code snippets for each language by clicking on the name of the language just above the code snippet:

As you can see, Skyscanner Flight Search API is available for:

• NodeJS
• PHP
• Python
• Ruby
• Objective-C
• Java
• and C#

If you click on the Test Endpoint button, the request will be sent to the API, and you will see the response in the right part of the screen (instead of the code snippet).

Another important thing we want to draw your attention to is the region around the name of the API. Here you can find information about whether the service is free (see the label to the right from the name). Also, the API’s category is displayed here. By clicking on the API Details tab you will be able to learn more about this API and how you can use it. The Discussions tab is the place where people publish their questions about the API. You can also post your message there.

The things described above are the same for any API on the RapidAPI marketplace. Let’s now move further and explore how we can use Skyscanner Flight Search API.

The primary use of this API is, obviously, the search of the flights using the Skyscanner platform. To be able to perform a search, firstly, you should create a search session using the Create session endpoint with the HTTP POST method. You have to pass all needed parameters for search in the request, such as country, currency, origin and destination places, dates, etc. This request will return the sessionKey in the response header. This key should be used in Poll session results endpoint to retrieve the results of the search. SessionKey is the only required parameter in this endpoint. Nevertheless, there are several optional parameters, for example, parameters responsible for the results sorting.

Other endpoints are auxiliary. The List markets and Currencies endpoints are the localization endpoints, providing information about available markets and currencies in the API respectively. The List places endpoint can be used for retrieving information about available airports. It is slightly different from the previous two endpoints because it requires query string for the airport search (for example, London for searching the airports available in London), while the previous endpoints simply return all available markers and currencies.

The group of the Browse Flight Prices endpoints of endpoints which return information about the cheapest quotes, routes, or dates from the Skyscanner cache.

Here are several examples of the API requests using different languages.

Skyscanner Flight Search API NodeJS:

unirest.post("https://skyscanner-skyscanner-flight-search-v1.p.rapidapi.com/apiservices/pricing/v1.0")
.header("X-RapidAPI-Host", "skyscanner-skyscanner-flight-search-v1.p.rapidapi.com")
.header("X-RapidAPI-Key", "40aeaxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx")
.header("Content-Type", "application/x-www-form-urlencoded")
.send("inboundDate=2019-01-10")
.send("cabinClass=business")
.send("children=0")
.send("infants=0")
.send("country=US")
.send("currency=USD")
.send("locale=en-US")
.send("originPlace=SFO-sky")
.send("destinationPlace=LHR-sky")
.send("outboundDate=2019-01-01")
.send("adults=1")
.end(function (result) {
  console.log(result.status, result.headers, result.body);
});

Skyscanner Flight Search API PHP:

$response = UnirestRequest::post("https://skyscanner-skyscanner-flight-search-v1.p.rapidapi.com/apiservices/pricing/v1.0",
  array(
    "X-RapidAPI-Host" => "skyscanner-skyscanner-flight-search-v1.p.rapidapi.com",
    "X-RapidAPI-Key" => "40aeaxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx",
    "Content-Type" => "application/x-www-form-urlencoded"
  ),
  array(
    "inboundDate" => "2019-01-10",
    "cabinClass" => "business",
    "children" => 0,
    "infants" => 0,
    "country" => "US",
    "currency" => "USD",
    "locale" => "en-US",
    "originPlace" => "SFO-sky",
    "destinationPlace" => "LHR-sky",
    "outboundDate" => "2019-01-01",
    "adults" => 1
  )
);

Skyscanner Flight Search API C#:

Task<HttpResponse<MyClass>> response = Unirest.post("https://skyscanner-skyscanner-flight-search-v1.p.rapidapi.com/apiservices/pricing/v1.0")
.header("X-RapidAPI-Host", "skyscanner-skyscanner-flight-search-v1.p.rapidapi.com")
.header("X-RapidAPI-Key", "40aeaxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx")
.header("Content-Type", "application/x-www-form-urlencoded")
.field("inboundDate", "2019-01-10")
.field("cabinClass", "business")
.field("children", 0)
.field("infants", 0)
.field("country", "US")
.field("currency", "USD")
.field("locale", "en-US")
.field("originPlace", "SFO-sky")
.field("destinationPlace", "LHR-sky")
.field("outboundDate", "2019-01-01")
.field("adults", 1)
.asJson();

In our model application, we will use Python to communicate with the Skyscanner Flight Search API.

Dark Sky API

Connect to APIDark Sky API can be used to retrieve weather data in the defined point on the Earth (by longitude and latitude) on the specific date in the past. Also, it can be used to get current weather condition and a forecast for the next week.

All general information for this API is the same as for the Skyscanner API, except that this API is Freemium. This means that there is a free level of usage, limited by some number of requests over the period of time. To use this API you have to subscribe to it on the RapidAPI website:

After you subscribe to an API, you can start using it. This API is pretty simple as it has only two endpoints – Forecast and Time Machine.

The first endpoint is for getting the weather forecast for the future, as well as the current weather conditions in the particular point on the Earth. If available, it provides a minute-by-minute forecast for the next hour, hour-by-hour forecast for the next 48 hours, and day-by-day forecast for the next week.

There are 2 required parameters for this endpoint – longitude, and latitude. The weather conditions will be returned for this location. Also, there are 4 optional parameters for specifying language, units system, exclusion and extension options. Exclude option allows reducing latency by excluding some blocks of information from the response. Extend option allows receiving hour-by-hour data for the next 168 hours instead of the next 48.

The second endpoint is for historical weather data retrieval. There is one more required parameter except for longitude and latitude: time. It is obvious, that you have to specify the time for which you want to get the weather information. On the other hand, there is one less parameter among optional parameters: extend. This is because there is no need to use this parameter with the historical data, it only makes sense for the forecasts.

The Dark Sky API via RapidAPI is available for such languages as NodeJS, Python, PHP, Ruby, Objective-C, Java, and C#. Let’s examine several examples in different languages.

Dark Sky API Ruby:

response = Unirest.get "https://dark-sky.p.rapidapi.com/{latitude},{longitude}?lang=en&units=auto",
headers:{
"X-RapidAPI-Host" => "dark-sky.p.rapidapi.com",

"X-RapidAPI-Key" => "40aeaxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"

}

Dark Sky API Objective-C:

NSDictionary *headers = @{@"X-RapidAPI-Host": @"dark-sky.p.rapidapi.com", @"X-RapidAPI-Key": @"40aeaxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"};

UNIUrlConnection *asyncConnection = [[UNIRest get:^(UNISimpleRequest *request) {

[request setUrl:@"https://dark-sky.p.rapidapi.com/{latitude},{longitude}?lang=en&units=auto"];

[request setHeaders:headers];

}] asJsonAsync:^(UNIHTTPJsonResponse *response, NSError *error) {

NSInteger code = response.code;

NSDictionary *responseHeaders = response.headers;

UNIJsonNode *body = response.body;

NSData *rawBody = response.rawBody;

}];

Dark Sky API Java:

HttpResponse<JsonNode> response = Unirest.get("https://dark-sky.p.rapidapi.com/{latitude},{longitude}?lang=en&units=auto")

.header("X-RapidAPI-Host", "dark-sky.p.rapidapi.com")

.header("X-RapidAPI-Key", "40aeaxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx")

.asJson();

Related: How to make a Weather App in Python

City Geo-Location Lookup API

Connect to APICity Geo-Location Lookup API is a free API available via RapidAPI. It allows getting geographical information about the specific location, mainly about the cities.

This API is extremely simple because it has only one endpoint (GET Results) with only one required parameter. You enter a location, and the API returns the list of possible answers. Usually, the first element in the list is what you actually wanted to find. Look at the example request sent through the browser on the RapidAPI platform:

You can see that we want to find the data about the Ukrainian capital – Kiev. The API returns us the list with 14 items, where the first item is what we were looking for. The second item represents Kieve, which is the city in Germany. Notice, that the response contains not only latitude and longitude, but also the timezone, type of location, and country.

Similarly to all other APIs, this API supports interface for the range of programming languages: Python, Ruby, NodeJS, PHP, Java, Objective-C, and C#. Here are several examples using some of the aforementioned languages.

City Geo-Location Lookup API Python:

response = unirest.get("https://devru-latitude-longitude-find-v1.p.rapidapi.com/latlon.php?location=<required>",
headers={
"X-RapidAPI-Host": "devru-latitude-longitude-find-v1.p.rapidapi.com",
"X-RapidAPI-Key": "40aeaxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
}
)

City Geo-Location Lookup API PHP:

$response = UnirestRequest::get("https://devru-latitude-longitude-find-v1.p.rapidapi.com/latlon.php?location=<required>",
array(
"X-RapidAPI-Host" => "devru-latitude-longitude-find-v1.p.rapidapi.com",
"X-RapidAPI-Key" => "40aeaxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
)
);

City Geo-Location Lookup API NodeJS:

unirest.get("https://devru-latitude-longitude-find-v1.p.rapidapi.com/latlon.php?location=<required>")
.header("X-RapidAPI-Host", "devru-latitude-longitude-find-v1.p.rapidapi.com")
.header("X-RapidAPI-Key", "40aeaxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx")
.end(function (result) {
console.log(result.status, result.headers, result.body);
});

Example Application: Combining all 3 APIs

Now, we want to build an example application to demonstrate how you can use these APIs in practice.

The idea is as follows: users enter the application, and we propose them to search for the flights. They type in the origin and destination locations and the date. We use the Skyscanner API to find the flights. Also, we use City Geo-Location API to get information about the geographical coordinates of the location. Then, we use these coordinates to get the weather data in the departure and arrival points on the specified date in the previous 3 years. We show the information about the weather conditions for each of the previous 3 years to the user, as well as the averaged data. Hopefully, this will help users to plan their trip.

Let’s start from the part where we need to use Skyscanner API. Users expect to enter the origin and destination points as the cities names. However, the Skyscanner’s API session requires the id of the places, not the names. Fortunately, to find the proper id, we can use the same API (List Places endpoint). We enter the query, and it returns the list with the most relevant matches. We hope that the top record is what we need in the most cases, but in the real app probably we would need to use more complex logic to be sure that everything works as expected. For example, we can propose the user to pick the desired place from the dropdown menu. Anyway, here is the code of the function for place’s id retrieval:

def get_placeID(location):
rapidapi_host = "skyscanner-skyscanner-flight-search-v1.p.rapidapi.com"
rapidapi_key = "40aeaxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
apicall = "https://skyscanner-skyscanner-flight-search-v1.p.rapidapi.com/apiservices/autosuggest/v1.0/UK/USD/en-GB/?query=" + str(location)
headers = {
"X-RapidAPI-Host": rapidapi_host,
"X-RapidAPI-Key": rapidapi_key
}
r = requests.get(apicall, headers=headers)
body = json.loads(r.text)
places = body['Places']
top_place_id = places[0]['PlaceId']
return top_place_id

Also, we need a function to convert the name of the user’s country (market) to the country code (the API requires this parameter):

def get_country_code(country):
headers={
"X-RapidAPI-Host": "skyscanner-skyscanner-flight-search-v1.p.rapidapi.com",
"X-RapidAPI-Key": "40aeaxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
}
response = requests.get("https://skyscanner-skyscanner-flight-search-v1.p.rapidapi.com/apiservices/reference/v1.0/countries/en-US",
headers=headers)
response = json.loads(response.text)
country_code = [item['Code'] for item in response['Countries'] if item['Name'] == country][0]
return country_code

Let’s go further and prepare a function for session creation (see the code below). The function create_session expects 4 input parameters: origin, destination, user_country_code, and outbound_date. As this app is just for demonstration purposes, we support only one-way search, economy pricing mode, and for 1 adult only. All prices are displayed in USD. In a real application, you may want to add more flexibility to this search which is not very hard to do. The create_session function returns the session key, which we will use to retrieve the results of the search later.

def create_session(origin, destination, user_country_code, outbound_date):
rapidapi_host = "skyscanner-skyscanner-flight-search-v1.p.rapidapi.com"
rapidapi_key = "40aeaxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
apicall = "https://skyscanner-skyscanner-flight-search-v1.p.rapidapi.com/apiservices/pricing/v1.0"
headers = {
"X-RapidAPI-Host": rapidapi_host,
"X-RapidAPI-Key": rapidapi_key,
"Content-Type": "application/x-www-form-urlencoded"
}
params={
"cabinClass": "economy",
"children": 0,
"infants": 0,
"country": user_country_code,
"currency": "USD",
"locale": "en-US",
"originPlace": origin,
"destinationPlace": destination,
"outboundDate": outbound_date,
"adults": 1
}
r = requests.post(apicall, headers=headers, data=params)
session_key = r.headers['Location'].split("/")[-1]
return session_key

After we have created the session, we can poll results using the corresponding endpoint. All we need to specify is the session key, which we have got from the previous function. The poll_results() function carries out all the work:

def poll_results(session_key):
rapidapi_host = "skyscanner-skyscanner-flight-search-v1.p.rapidapi.com"
rapidapi_key = "40aeaxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
apicall = "https://skyscanner-skyscanner-flight-search-v1.p.rapidapi.com/apiservices/pricing/uk2/v1.0/{}?sortType=price&pageIndex=0&pageSize=10".format(session_key)
headers = {
"X-RapidAPI-Host": rapidapi_host,
"X-RapidAPI-Key": rapidapi_key
}
r = requests.get(apicall, headers=headers)
body = json.loads(r.text)
itineraries = body['Itineraries']
return itineraries

You can see that the function above returns the itineraries variable. This is the list containing information about possible travel routes.

Now, we want to merge all the logic related to the flight search using the Skyscanner API into one single function named search_flights().

def search_flights(origin, destination, user_country, outbound_date):
country_code = get_country_code(user_country)
origin_id = get_placeID(origin)
destination_id = get_placeID(destination)
session_key = create_session(origin_id, destination_id, country_code, outbound_date)
itineraries = poll_results(session_key)
results = []
for i in range(len(itineraries)):
for j in range(len(itineraries[i]['PricingOptions'])):
url = itineraries[i]['PricingOptions'][j]['DeeplinkUrl']
price = itineraries[i]['PricingOptions'][j]['Price']
results.append((price, url))
return results

As you can see, this function expects as inputs the names of the origin and destination locations, the user’s country, and the outbound date. Then it successively calls all mentioned above functions:

• get_country_code() – for converting the user’s country name to the code of the country;
• get_placeID() – to get the Skyscanner’s internal place IDs of the origin and destination points;
• create_session() – to create a session and pass all needed parameters for the search;
• poll_results() – to eventually get the results we are searching for.

Also, this general function performs some results preprocessing. In the end, it returns a list of tuples, where each tuple represents a specific proposal and contains the price and the direct link for purchasing on the Skyscanner’s partners websites.

We will use only one function for working with City Geo-Location Lookup API – get_geolocation(). This function takes the name of the location as input and returns latitude, longitude, and the name of the most likely location from the APIs database. The name usually consists of the city name and the name of the country where this city is located.

Related: Top IP Geolocation APIs

def get_geolocation(location):
rapidapi_host = "devru-latitude-longitude-find-v1.p.rapidapi.com"
rapidapi_key = "40aeaxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
apicall = "https://devru-latitude-longitude-find-v1.p.rapidapi.com/latlon.php?location=" + str(location)
headers = {
"X-RapidAPI-Host": rapidapi_host,
"X-RapidAPI-Key": rapidapi_key
}
r = requests.get(apicall, headers=headers)
body = json.loads(r.text)
items = body['Results']
top_result = items[0]
name = top_result['name']
latitude, longitude = top_result['lat'], top_result['lon']
return latitude, longitude, name

Our app’s interaction with the Dark Sky API will be conducted with the help of two functions. The first function is called get_weather_point(). We are going to use it to retrieve information about the weather in a specific location at a specific moment in the past. You can find the code of this function below.

def get_weather_point(latitude, longitude, date):
date = date + "T12:00:00"
rapidapi_host = "dark-sky.p.rapidapi.com"
rapidapi_key = "40aeaxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
apicall = "https://dark-sky.p.rapidapi.com/{},{},{}?units=ca".format(latitude, longitude, date)
headers = {
"X-RapidAPI-Host": rapidapi_host,
"X-RapidAPI-Key": rapidapi_key
}
r = requests.get(apicall, headers=headers)
body = json.loads(r.text)
weather = body['currently']
conditions_list = ['apparentTemperature', 'temperature', 'cloudCover', 'precipIntensity',
'precipProbability','summary', 'visibility', 'windSpeed']
weather_conditions = {}
for i in range(len(conditions_list)):
if conditions_list[i] in weather:
weather_conditions[conditions_list[i]] = weather[conditions_list[i]]
renamed_conditions_list = ['App temp', 'Temp', 'Cloud cover', 'Precipitations intensity',
'Precipitations probability','Summary', 'Visibility', 'Wind speed']
for i in range(len(conditions_list)):
if conditions_list[i] in weather_conditions:
weather_conditions[renamed_conditions_list[i]] = weather_conditions.pop(conditions_list[i])
return weather_conditions

We need to pass longitude and latitude of the place you are interested in and the date in the past for which you want to get the weather data to this function. The API can return a lot of different weather information, but for our app we want to take only information important for flights and passengers experience before and during a flight (in our opinion). So, we select an apparent temperature, temperature, cloud cover, precipitations intensity and probability, visibility, wind speed, and a summary of the weather for the day. Also, we want to change the names of the fields to receive them in a slightly different format. As we don’t know what fields are available for what location and date, we need to add the check of field existence to avoid possible errors. The first line in the function is used to complete the date string to fetch the data on the 12 o’clock. In the real application, probably you will want to improve this behavior.

The get_weather_point() function pulls data at the specific date. But in our application, we want to use the data for the last 3 years in order to mitigate the outliers’ influence. For this purpose, we prepared the function get_3_years_weather(). This function takes latitude, longitude, and the date of the flight. Then, it generates the needed dates for the last 3 years. These dates are fed into get_weather_point() function to fetch the data for each year. In addition, the average temperature is calculated.

def get_3_years_weather(latitude, longitude, current_date):
month_and_day = current_date.split("-")[1] + "-" + current_date.split("-")[2]
year_1_date = str(int(current_date.split("-")[0])-1) + "-" + month_and_day
year_2_date = str(int(current_date.split("-")[0])-2) + "-" + month_and_day
year_3_date = str(int(current_date.split("-")[0])-3) + "-" + month_and_day
year_1 = get_weather_point(latitude, longitude, year_1_date)
year_2 = get_weather_point(latitude, longitude, year_2_date)
year_3 = get_weather_point(latitude, longitude, year_3_date)
avg_temp = (year_1['Temp'] + year_2['Temp'] + year_3['Temp'])/3
return year_1, year_2, year_3, avg_temp

All the functions mentioned above are the core of the application. You can use them with, for example, Flask or Django web frameworks to develop a complete web application with a convenient frontend and an optimized backend. However, in this article, we only want to show how these functions work in practice.

Let’s say the user wants to find a flight from Kiev, Ukraine, to Larnaca, Cyprus. The desired date is May 15, 2019. Here is how our search_flights() function can be used:

As you can see, it returned the list from one tuple. This tuple contains the price (140.38 USD) and the link for purchasing. If we copy and enter this link in our browser, we will find ourselves on the Skyscanner’s page leading to the website where we can buy the ticket:

So, you can use this link in your app to allow users to buy tickets.

Next, we use get_geolocation() function to get the geographical coordinates of the desired cities. Then, we use these coordinates in the get_3_years_weather() function to eventually get the weather conditions:

And here is what we have now in our variables with weather data:

We can see the weather conditions in both cities. The last variable is the average temperature during the last 3 years on this date. The average temperature in Kiev on May 15 during the 2016-2018 years was around 17,8 degrees Celsius, while in Larnaca it reached almost 28 degrees.

Conclusion

In this article, we explored 3 APIs which are available at RapidAPI Marketplace: Skyscanner Flight Search API, Dark Sky API, and City Geo-Location Lookup API. We described the tasks each of the APIs can be used for. Also, we explained the endpoints the APIs have to perform their jobs.

But the core of the article is the example of how you can use all of the APIs together to build a simple but useful application. We hope that now you have a basic understanding of how you can interact with the RapidAPI platform and how different APIs can be used to build real-world applications.