LH Partner API

GET Baggage Trip and Contact

{{baseUrl}}/baggage/baggagetripandcontact/:searchID

HEADERS

QUERY PARAMS

searchID

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/baggage/baggagetripandcontact/:searchID");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "accept: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/baggage/baggagetripandcontact/:searchID" {:headers {:accept ""}})

require "http/client"

url = "{{baseUrl}}/baggage/baggagetripandcontact/:searchID"
headers = HTTP::Headers{
  "accept" => ""
}

response = HTTP::Client.get url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/baggage/baggagetripandcontact/:searchID"),
    Headers =
    {
        { "accept", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/baggage/baggagetripandcontact/:searchID");
var request = new RestRequest("", Method.Get);
request.AddHeader("accept", "");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/baggage/baggagetripandcontact/:searchID"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("accept", "")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/baggage/baggagetripandcontact/:searchID HTTP/1.1
Accept: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/baggage/baggagetripandcontact/:searchID")
  .setHeader("accept", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/baggage/baggagetripandcontact/:searchID"))
    .header("accept", "")
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/baggage/baggagetripandcontact/:searchID")
  .get()
  .addHeader("accept", "")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/baggage/baggagetripandcontact/:searchID")
  .header("accept", "")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/baggage/baggagetripandcontact/:searchID');
xhr.setRequestHeader('accept', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/baggage/baggagetripandcontact/:searchID',
  headers: {accept: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/baggage/baggagetripandcontact/:searchID';
const options = {method: 'GET', headers: {accept: ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/baggage/baggagetripandcontact/:searchID',
  method: 'GET',
  headers: {
    accept: ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/baggage/baggagetripandcontact/:searchID")
  .get()
  .addHeader("accept", "")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/baggage/baggagetripandcontact/:searchID',
  headers: {
    accept: ''
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/baggage/baggagetripandcontact/:searchID',
  headers: {accept: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/baggage/baggagetripandcontact/:searchID');

req.headers({
  accept: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/baggage/baggagetripandcontact/:searchID',
  headers: {accept: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/baggage/baggagetripandcontact/:searchID';
const options = {method: 'GET', headers: {accept: ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"accept": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/baggage/baggagetripandcontact/:searchID"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/baggage/baggagetripandcontact/:searchID" in
let headers = Header.add (Header.init ()) "accept" "" in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/baggage/baggagetripandcontact/:searchID",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "accept: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/baggage/baggagetripandcontact/:searchID', [
  'headers' => [
    'accept' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/baggage/baggagetripandcontact/:searchID');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'accept' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/baggage/baggagetripandcontact/:searchID');
$request->setRequestMethod('GET');
$request->setHeaders([
  'accept' => ''
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("accept", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/baggage/baggagetripandcontact/:searchID' -Method GET -Headers $headers

$headers=@{}
$headers.Add("accept", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/baggage/baggagetripandcontact/:searchID' -Method GET -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = { 'accept': "" }

conn.request("GET", "/baseUrl/baggage/baggagetripandcontact/:searchID", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/baggage/baggagetripandcontact/:searchID"

headers = {"accept": ""}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/baggage/baggagetripandcontact/:searchID"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/baggage/baggagetripandcontact/:searchID")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["accept"] = ''

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/baggage/baggagetripandcontact/:searchID') do |req|
  req.headers['accept'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/baggage/baggagetripandcontact/:searchID";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("accept", "".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.get(url)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/baggage/baggagetripandcontact/:searchID \
  --header 'accept: '

http GET {{baseUrl}}/baggage/baggagetripandcontact/:searchID \
  accept:''

wget --quiet \
  --method GET \
  --header 'accept: ' \
  --output-document \
  - {{baseUrl}}/baggage/baggagetripandcontact/:searchID

import Foundation

let headers = ["accept": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/baggage/baggagetripandcontact/:searchID")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET All Fares

{{baseUrl}}/offers/fares/allfares

QUERY PARAMS

catalogues

origin

destination

travel-date

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/offers/fares/allfares?catalogues=&origin=&destination=&travel-date=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/offers/fares/allfares" {:query-params {:catalogues ""
                                                                                :origin ""
                                                                                :destination ""
                                                                                :travel-date ""}})

require "http/client"

url = "{{baseUrl}}/offers/fares/allfares?catalogues=&origin=&destination=&travel-date="

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/offers/fares/allfares?catalogues=&origin=&destination=&travel-date="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/offers/fares/allfares?catalogues=&origin=&destination=&travel-date=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/offers/fares/allfares?catalogues=&origin=&destination=&travel-date="

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/offers/fares/allfares?catalogues=&origin=&destination=&travel-date= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/offers/fares/allfares?catalogues=&origin=&destination=&travel-date=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/offers/fares/allfares?catalogues=&origin=&destination=&travel-date="))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/offers/fares/allfares?catalogues=&origin=&destination=&travel-date=")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/offers/fares/allfares?catalogues=&origin=&destination=&travel-date=")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/offers/fares/allfares?catalogues=&origin=&destination=&travel-date=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/offers/fares/allfares',
  params: {catalogues: '', origin: '', destination: '', 'travel-date': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/offers/fares/allfares?catalogues=&origin=&destination=&travel-date=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/offers/fares/allfares?catalogues=&origin=&destination=&travel-date=',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/offers/fares/allfares?catalogues=&origin=&destination=&travel-date=")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/offers/fares/allfares?catalogues=&origin=&destination=&travel-date=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/offers/fares/allfares',
  qs: {catalogues: '', origin: '', destination: '', 'travel-date': ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/offers/fares/allfares');

req.query({
  catalogues: '',
  origin: '',
  destination: '',
  'travel-date': ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/offers/fares/allfares',
  params: {catalogues: '', origin: '', destination: '', 'travel-date': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/offers/fares/allfares?catalogues=&origin=&destination=&travel-date=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/offers/fares/allfares?catalogues=&origin=&destination=&travel-date="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/offers/fares/allfares?catalogues=&origin=&destination=&travel-date=" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/offers/fares/allfares?catalogues=&origin=&destination=&travel-date=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/offers/fares/allfares?catalogues=&origin=&destination=&travel-date=');

echo $response->getBody();

setUrl('{{baseUrl}}/offers/fares/allfares');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'catalogues' => '',
  'origin' => '',
  'destination' => '',
  'travel-date' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/offers/fares/allfares');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'catalogues' => '',
  'origin' => '',
  'destination' => '',
  'travel-date' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/offers/fares/allfares?catalogues=&origin=&destination=&travel-date=' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/offers/fares/allfares?catalogues=&origin=&destination=&travel-date=' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/offers/fares/allfares?catalogues=&origin=&destination=&travel-date=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/offers/fares/allfares"

querystring = {"catalogues":"","origin":"","destination":"","travel-date":""}

response = requests.get(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/offers/fares/allfares"

queryString <- list(
  catalogues = "",
  origin = "",
  destination = "",
  travel-date = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/offers/fares/allfares?catalogues=&origin=&destination=&travel-date=")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/offers/fares/allfares') do |req|
  req.params['catalogues'] = ''
  req.params['origin'] = ''
  req.params['destination'] = ''
  req.params['travel-date'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/offers/fares/allfares";

    let querystring = [
        ("catalogues", ""),
        ("origin", ""),
        ("destination", ""),
        ("travel-date", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/offers/fares/allfares?catalogues=&origin=&destination=&travel-date='

http GET '{{baseUrl}}/offers/fares/allfares?catalogues=&origin=&destination=&travel-date='

wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/offers/fares/allfares?catalogues=&origin=&destination=&travel-date='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/offers/fares/allfares?catalogues=&origin=&destination=&travel-date=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Best Fares

{{baseUrl}}/offers/fares/bestfares

HEADERS

QUERY PARAMS

catalogues

origin

destination

travel-date

trip-duration

range

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/offers/fares/bestfares?catalogues=&origin=&destination=&travel-date=&trip-duration=&range=");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "accept: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/offers/fares/bestfares" {:headers {:accept ""}
                                                                  :query-params {:catalogues ""
                                                                                 :origin ""
                                                                                 :destination ""
                                                                                 :travel-date ""
                                                                                 :trip-duration ""
                                                                                 :range ""}})

require "http/client"

url = "{{baseUrl}}/offers/fares/bestfares?catalogues=&origin=&destination=&travel-date=&trip-duration=&range="
headers = HTTP::Headers{
  "accept" => ""
}

response = HTTP::Client.get url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/offers/fares/bestfares?catalogues=&origin=&destination=&travel-date=&trip-duration=&range="),
    Headers =
    {
        { "accept", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/offers/fares/bestfares?catalogues=&origin=&destination=&travel-date=&trip-duration=&range=");
var request = new RestRequest("", Method.Get);
request.AddHeader("accept", "");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/offers/fares/bestfares?catalogues=&origin=&destination=&travel-date=&trip-duration=&range="

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("accept", "")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/offers/fares/bestfares?catalogues=&origin=&destination=&travel-date=&trip-duration=&range= HTTP/1.1
Accept: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/offers/fares/bestfares?catalogues=&origin=&destination=&travel-date=&trip-duration=&range=")
  .setHeader("accept", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/offers/fares/bestfares?catalogues=&origin=&destination=&travel-date=&trip-duration=&range="))
    .header("accept", "")
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/offers/fares/bestfares?catalogues=&origin=&destination=&travel-date=&trip-duration=&range=")
  .get()
  .addHeader("accept", "")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/offers/fares/bestfares?catalogues=&origin=&destination=&travel-date=&trip-duration=&range=")
  .header("accept", "")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/offers/fares/bestfares?catalogues=&origin=&destination=&travel-date=&trip-duration=&range=');
xhr.setRequestHeader('accept', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/offers/fares/bestfares',
  params: {
    catalogues: '',
    origin: '',
    destination: '',
    'travel-date': '',
    'trip-duration': '',
    range: ''
  },
  headers: {accept: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/offers/fares/bestfares?catalogues=&origin=&destination=&travel-date=&trip-duration=&range=';
const options = {method: 'GET', headers: {accept: ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/offers/fares/bestfares?catalogues=&origin=&destination=&travel-date=&trip-duration=&range=',
  method: 'GET',
  headers: {
    accept: ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/offers/fares/bestfares?catalogues=&origin=&destination=&travel-date=&trip-duration=&range=")
  .get()
  .addHeader("accept", "")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/offers/fares/bestfares?catalogues=&origin=&destination=&travel-date=&trip-duration=&range=',
  headers: {
    accept: ''
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/offers/fares/bestfares',
  qs: {
    catalogues: '',
    origin: '',
    destination: '',
    'travel-date': '',
    'trip-duration': '',
    range: ''
  },
  headers: {accept: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/offers/fares/bestfares');

req.query({
  catalogues: '',
  origin: '',
  destination: '',
  'travel-date': '',
  'trip-duration': '',
  range: ''
});

req.headers({
  accept: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/offers/fares/bestfares',
  params: {
    catalogues: '',
    origin: '',
    destination: '',
    'travel-date': '',
    'trip-duration': '',
    range: ''
  },
  headers: {accept: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/offers/fares/bestfares?catalogues=&origin=&destination=&travel-date=&trip-duration=&range=';
const options = {method: 'GET', headers: {accept: ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"accept": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/offers/fares/bestfares?catalogues=&origin=&destination=&travel-date=&trip-duration=&range="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/offers/fares/bestfares?catalogues=&origin=&destination=&travel-date=&trip-duration=&range=" in
let headers = Header.add (Header.init ()) "accept" "" in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/offers/fares/bestfares?catalogues=&origin=&destination=&travel-date=&trip-duration=&range=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "accept: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/offers/fares/bestfares?catalogues=&origin=&destination=&travel-date=&trip-duration=&range=', [
  'headers' => [
    'accept' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/offers/fares/bestfares');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'catalogues' => '',
  'origin' => '',
  'destination' => '',
  'travel-date' => '',
  'trip-duration' => '',
  'range' => ''
]);

$request->setHeaders([
  'accept' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/offers/fares/bestfares');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'catalogues' => '',
  'origin' => '',
  'destination' => '',
  'travel-date' => '',
  'trip-duration' => '',
  'range' => ''
]));

$request->setHeaders([
  'accept' => ''
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("accept", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/offers/fares/bestfares?catalogues=&origin=&destination=&travel-date=&trip-duration=&range=' -Method GET -Headers $headers

$headers=@{}
$headers.Add("accept", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/offers/fares/bestfares?catalogues=&origin=&destination=&travel-date=&trip-duration=&range=' -Method GET -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = { 'accept': "" }

conn.request("GET", "/baseUrl/offers/fares/bestfares?catalogues=&origin=&destination=&travel-date=&trip-duration=&range=", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/offers/fares/bestfares"

querystring = {"catalogues":"","origin":"","destination":"","travel-date":"","trip-duration":"","range":""}

headers = {"accept": ""}

response = requests.get(url, headers=headers, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/offers/fares/bestfares"

queryString <- list(
  catalogues = "",
  origin = "",
  destination = "",
  travel-date = "",
  trip-duration = "",
  range = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/offers/fares/bestfares?catalogues=&origin=&destination=&travel-date=&trip-duration=&range=")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["accept"] = ''

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/offers/fares/bestfares') do |req|
  req.headers['accept'] = ''
  req.params['catalogues'] = ''
  req.params['origin'] = ''
  req.params['destination'] = ''
  req.params['travel-date'] = ''
  req.params['trip-duration'] = ''
  req.params['range'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/offers/fares/bestfares";

    let querystring = [
        ("catalogues", ""),
        ("origin", ""),
        ("destination", ""),
        ("travel-date", ""),
        ("trip-duration", ""),
        ("range", ""),
    ];

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("accept", "".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/offers/fares/bestfares?catalogues=&origin=&destination=&travel-date=&trip-duration=&range=' \
  --header 'accept: '

http GET '{{baseUrl}}/offers/fares/bestfares?catalogues=&origin=&destination=&travel-date=&trip-duration=&range=' \
  accept:''

wget --quiet \
  --method GET \
  --header 'accept: ' \
  --output-document \
  - '{{baseUrl}}/offers/fares/bestfares?catalogues=&origin=&destination=&travel-date=&trip-duration=&range='

import Foundation

let headers = ["accept": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/offers/fares/bestfares?catalogues=&origin=&destination=&travel-date=&trip-duration=&range=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Deep Links

{{baseUrl}}/offers/fares/deeplink

HEADERS

QUERY PARAMS

catalogues

trackingid

country

lang

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/offers/fares/deeplink?catalogues=&trackingid=&country=&lang=");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "accept: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/offers/fares/deeplink" {:headers {:accept ""}
                                                                 :query-params {:catalogues ""
                                                                                :trackingid ""
                                                                                :country ""
                                                                                :lang ""}})

require "http/client"

url = "{{baseUrl}}/offers/fares/deeplink?catalogues=&trackingid=&country=&lang="
headers = HTTP::Headers{
  "accept" => ""
}

response = HTTP::Client.get url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/offers/fares/deeplink?catalogues=&trackingid=&country=&lang="),
    Headers =
    {
        { "accept", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/offers/fares/deeplink?catalogues=&trackingid=&country=&lang=");
var request = new RestRequest("", Method.Get);
request.AddHeader("accept", "");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/offers/fares/deeplink?catalogues=&trackingid=&country=&lang="

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("accept", "")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/offers/fares/deeplink?catalogues=&trackingid=&country=&lang= HTTP/1.1
Accept: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/offers/fares/deeplink?catalogues=&trackingid=&country=&lang=")
  .setHeader("accept", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/offers/fares/deeplink?catalogues=&trackingid=&country=&lang="))
    .header("accept", "")
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/offers/fares/deeplink?catalogues=&trackingid=&country=&lang=")
  .get()
  .addHeader("accept", "")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/offers/fares/deeplink?catalogues=&trackingid=&country=&lang=")
  .header("accept", "")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/offers/fares/deeplink?catalogues=&trackingid=&country=&lang=');
xhr.setRequestHeader('accept', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/offers/fares/deeplink',
  params: {catalogues: '', trackingid: '', country: '', lang: ''},
  headers: {accept: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/offers/fares/deeplink?catalogues=&trackingid=&country=&lang=';
const options = {method: 'GET', headers: {accept: ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/offers/fares/deeplink?catalogues=&trackingid=&country=&lang=',
  method: 'GET',
  headers: {
    accept: ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/offers/fares/deeplink?catalogues=&trackingid=&country=&lang=")
  .get()
  .addHeader("accept", "")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/offers/fares/deeplink?catalogues=&trackingid=&country=&lang=',
  headers: {
    accept: ''
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/offers/fares/deeplink',
  qs: {catalogues: '', trackingid: '', country: '', lang: ''},
  headers: {accept: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/offers/fares/deeplink');

req.query({
  catalogues: '',
  trackingid: '',
  country: '',
  lang: ''
});

req.headers({
  accept: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/offers/fares/deeplink',
  params: {catalogues: '', trackingid: '', country: '', lang: ''},
  headers: {accept: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/offers/fares/deeplink?catalogues=&trackingid=&country=&lang=';
const options = {method: 'GET', headers: {accept: ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"accept": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/offers/fares/deeplink?catalogues=&trackingid=&country=&lang="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/offers/fares/deeplink?catalogues=&trackingid=&country=&lang=" in
let headers = Header.add (Header.init ()) "accept" "" in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/offers/fares/deeplink?catalogues=&trackingid=&country=&lang=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "accept: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/offers/fares/deeplink?catalogues=&trackingid=&country=&lang=', [
  'headers' => [
    'accept' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/offers/fares/deeplink');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'catalogues' => '',
  'trackingid' => '',
  'country' => '',
  'lang' => ''
]);

$request->setHeaders([
  'accept' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/offers/fares/deeplink');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'catalogues' => '',
  'trackingid' => '',
  'country' => '',
  'lang' => ''
]));

$request->setHeaders([
  'accept' => ''
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("accept", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/offers/fares/deeplink?catalogues=&trackingid=&country=&lang=' -Method GET -Headers $headers

$headers=@{}
$headers.Add("accept", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/offers/fares/deeplink?catalogues=&trackingid=&country=&lang=' -Method GET -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = { 'accept': "" }

conn.request("GET", "/baseUrl/offers/fares/deeplink?catalogues=&trackingid=&country=&lang=", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/offers/fares/deeplink"

querystring = {"catalogues":"","trackingid":"","country":"","lang":""}

headers = {"accept": ""}

response = requests.get(url, headers=headers, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/offers/fares/deeplink"

queryString <- list(
  catalogues = "",
  trackingid = "",
  country = "",
  lang = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/offers/fares/deeplink?catalogues=&trackingid=&country=&lang=")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["accept"] = ''

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/offers/fares/deeplink') do |req|
  req.headers['accept'] = ''
  req.params['catalogues'] = ''
  req.params['trackingid'] = ''
  req.params['country'] = ''
  req.params['lang'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/offers/fares/deeplink";

    let querystring = [
        ("catalogues", ""),
        ("trackingid", ""),
        ("country", ""),
        ("lang", ""),
    ];

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("accept", "".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/offers/fares/deeplink?catalogues=&trackingid=&country=&lang=' \
  --header 'accept: '

http GET '{{baseUrl}}/offers/fares/deeplink?catalogues=&trackingid=&country=&lang=' \
  accept:''

wget --quiet \
  --method GET \
  --header 'accept: ' \
  --output-document \
  - '{{baseUrl}}/offers/fares/deeplink?catalogues=&trackingid=&country=&lang='

import Foundation

let headers = ["accept": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/offers/fares/deeplink?catalogues=&trackingid=&country=&lang=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Fares Subscriptions

{{baseUrl}}/offers/fares/subscriptions

HEADERS

QUERY PARAMS

origin

destination

cabin-class

trip-duration

lang

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/offers/fares/subscriptions?origin=&destination=&cabin-class=&trip-duration=&email=&lang=");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "accept: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/offers/fares/subscriptions" {:headers {:accept ""}
                                                                      :query-params {:origin ""
                                                                                     :destination ""
                                                                                     :cabin-class ""
                                                                                     :trip-duration ""
                                                                                     :email ""
                                                                                     :lang ""}})

require "http/client"

url = "{{baseUrl}}/offers/fares/subscriptions?origin=&destination=&cabin-class=&trip-duration=&email=&lang="
headers = HTTP::Headers{
  "accept" => ""
}

response = HTTP::Client.get url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/offers/fares/subscriptions?origin=&destination=&cabin-class=&trip-duration=&email=&lang="),
    Headers =
    {
        { "accept", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/offers/fares/subscriptions?origin=&destination=&cabin-class=&trip-duration=&email=&lang=");
var request = new RestRequest("", Method.Get);
request.AddHeader("accept", "");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/offers/fares/subscriptions?origin=&destination=&cabin-class=&trip-duration=&email=&lang="

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("accept", "")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/offers/fares/subscriptions?origin=&destination=&cabin-class=&trip-duration=&email=&lang= HTTP/1.1
Accept: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/offers/fares/subscriptions?origin=&destination=&cabin-class=&trip-duration=&email=&lang=")
  .setHeader("accept", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/offers/fares/subscriptions?origin=&destination=&cabin-class=&trip-duration=&email=&lang="))
    .header("accept", "")
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/offers/fares/subscriptions?origin=&destination=&cabin-class=&trip-duration=&email=&lang=")
  .get()
  .addHeader("accept", "")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/offers/fares/subscriptions?origin=&destination=&cabin-class=&trip-duration=&email=&lang=")
  .header("accept", "")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/offers/fares/subscriptions?origin=&destination=&cabin-class=&trip-duration=&email=&lang=');
xhr.setRequestHeader('accept', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/offers/fares/subscriptions',
  params: {
    origin: '',
    destination: '',
    'cabin-class': '',
    'trip-duration': '',
    email: '',
    lang: ''
  },
  headers: {accept: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/offers/fares/subscriptions?origin=&destination=&cabin-class=&trip-duration=&email=&lang=';
const options = {method: 'GET', headers: {accept: ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/offers/fares/subscriptions?origin=&destination=&cabin-class=&trip-duration=&email=&lang=',
  method: 'GET',
  headers: {
    accept: ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/offers/fares/subscriptions?origin=&destination=&cabin-class=&trip-duration=&email=&lang=")
  .get()
  .addHeader("accept", "")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/offers/fares/subscriptions?origin=&destination=&cabin-class=&trip-duration=&email=&lang=',
  headers: {
    accept: ''
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/offers/fares/subscriptions',
  qs: {
    origin: '',
    destination: '',
    'cabin-class': '',
    'trip-duration': '',
    email: '',
    lang: ''
  },
  headers: {accept: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/offers/fares/subscriptions');

req.query({
  origin: '',
  destination: '',
  'cabin-class': '',
  'trip-duration': '',
  email: '',
  lang: ''
});

req.headers({
  accept: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/offers/fares/subscriptions',
  params: {
    origin: '',
    destination: '',
    'cabin-class': '',
    'trip-duration': '',
    email: '',
    lang: ''
  },
  headers: {accept: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/offers/fares/subscriptions?origin=&destination=&cabin-class=&trip-duration=&email=&lang=';
const options = {method: 'GET', headers: {accept: ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"accept": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/offers/fares/subscriptions?origin=&destination=&cabin-class=&trip-duration=&email=&lang="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/offers/fares/subscriptions?origin=&destination=&cabin-class=&trip-duration=&email=&lang=" in
let headers = Header.add (Header.init ()) "accept" "" in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/offers/fares/subscriptions?origin=&destination=&cabin-class=&trip-duration=&email=&lang=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "accept: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/offers/fares/subscriptions?origin=&destination=&cabin-class=&trip-duration=&email=&lang=', [
  'headers' => [
    'accept' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/offers/fares/subscriptions');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'origin' => '',
  'destination' => '',
  'cabin-class' => '',
  'trip-duration' => '',
  'email' => '',
  'lang' => ''
]);

$request->setHeaders([
  'accept' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/offers/fares/subscriptions');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'origin' => '',
  'destination' => '',
  'cabin-class' => '',
  'trip-duration' => '',
  'email' => '',
  'lang' => ''
]));

$request->setHeaders([
  'accept' => ''
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("accept", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/offers/fares/subscriptions?origin=&destination=&cabin-class=&trip-duration=&email=&lang=' -Method GET -Headers $headers

$headers=@{}
$headers.Add("accept", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/offers/fares/subscriptions?origin=&destination=&cabin-class=&trip-duration=&email=&lang=' -Method GET -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = { 'accept': "" }

conn.request("GET", "/baseUrl/offers/fares/subscriptions?origin=&destination=&cabin-class=&trip-duration=&email=&lang=", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/offers/fares/subscriptions"

querystring = {"origin":"","destination":"","cabin-class":"","trip-duration":"","email":"","lang":""}

headers = {"accept": ""}

response = requests.get(url, headers=headers, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/offers/fares/subscriptions"

queryString <- list(
  origin = "",
  destination = "",
  cabin-class = "",
  trip-duration = "",
  email = "",
  lang = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/offers/fares/subscriptions?origin=&destination=&cabin-class=&trip-duration=&email=&lang=")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["accept"] = ''

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/offers/fares/subscriptions') do |req|
  req.headers['accept'] = ''
  req.params['origin'] = ''
  req.params['destination'] = ''
  req.params['cabin-class'] = ''
  req.params['trip-duration'] = ''
  req.params['email'] = ''
  req.params['lang'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/offers/fares/subscriptions";

    let querystring = [
        ("origin", ""),
        ("destination", ""),
        ("cabin-class", ""),
        ("trip-duration", ""),
        ("email", ""),
        ("lang", ""),
    ];

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("accept", "".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/offers/fares/subscriptions?origin=&destination=&cabin-class=&trip-duration=&email=&lang=' \
  --header 'accept: '

http GET '{{baseUrl}}/offers/fares/subscriptions?origin=&destination=&cabin-class=&trip-duration=&email=&lang=' \
  accept:''

wget --quiet \
  --method GET \
  --header 'accept: ' \
  --output-document \
  - '{{baseUrl}}/offers/fares/subscriptions?origin=&destination=&cabin-class=&trip-duration=&email=&lang='

import Foundation

let headers = ["accept": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/offers/fares/subscriptions?origin=&destination=&cabin-class=&trip-duration=&email=&lang=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Fares

{{baseUrl}}/offers/fares/fares

HEADERS

QUERY PARAMS

catalogues

segments

carriers

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/offers/fares/fares?catalogues=&segments=&carriers=");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "accept: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/offers/fares/fares" {:headers {:accept ""}
                                                              :query-params {:catalogues ""
                                                                             :segments ""
                                                                             :carriers ""}})

require "http/client"

url = "{{baseUrl}}/offers/fares/fares?catalogues=&segments=&carriers="
headers = HTTP::Headers{
  "accept" => ""
}

response = HTTP::Client.get url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/offers/fares/fares?catalogues=&segments=&carriers="),
    Headers =
    {
        { "accept", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/offers/fares/fares?catalogues=&segments=&carriers=");
var request = new RestRequest("", Method.Get);
request.AddHeader("accept", "");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/offers/fares/fares?catalogues=&segments=&carriers="

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("accept", "")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/offers/fares/fares?catalogues=&segments=&carriers= HTTP/1.1
Accept: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/offers/fares/fares?catalogues=&segments=&carriers=")
  .setHeader("accept", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/offers/fares/fares?catalogues=&segments=&carriers="))
    .header("accept", "")
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/offers/fares/fares?catalogues=&segments=&carriers=")
  .get()
  .addHeader("accept", "")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/offers/fares/fares?catalogues=&segments=&carriers=")
  .header("accept", "")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/offers/fares/fares?catalogues=&segments=&carriers=');
xhr.setRequestHeader('accept', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/offers/fares/fares',
  params: {catalogues: '', segments: '', carriers: ''},
  headers: {accept: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/offers/fares/fares?catalogues=&segments=&carriers=';
const options = {method: 'GET', headers: {accept: ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/offers/fares/fares?catalogues=&segments=&carriers=',
  method: 'GET',
  headers: {
    accept: ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/offers/fares/fares?catalogues=&segments=&carriers=")
  .get()
  .addHeader("accept", "")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/offers/fares/fares?catalogues=&segments=&carriers=',
  headers: {
    accept: ''
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/offers/fares/fares',
  qs: {catalogues: '', segments: '', carriers: ''},
  headers: {accept: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/offers/fares/fares');

req.query({
  catalogues: '',
  segments: '',
  carriers: ''
});

req.headers({
  accept: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/offers/fares/fares',
  params: {catalogues: '', segments: '', carriers: ''},
  headers: {accept: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/offers/fares/fares?catalogues=&segments=&carriers=';
const options = {method: 'GET', headers: {accept: ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"accept": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/offers/fares/fares?catalogues=&segments=&carriers="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/offers/fares/fares?catalogues=&segments=&carriers=" in
let headers = Header.add (Header.init ()) "accept" "" in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/offers/fares/fares?catalogues=&segments=&carriers=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "accept: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/offers/fares/fares?catalogues=&segments=&carriers=', [
  'headers' => [
    'accept' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/offers/fares/fares');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'catalogues' => '',
  'segments' => '',
  'carriers' => ''
]);

$request->setHeaders([
  'accept' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/offers/fares/fares');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'catalogues' => '',
  'segments' => '',
  'carriers' => ''
]));

$request->setHeaders([
  'accept' => ''
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("accept", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/offers/fares/fares?catalogues=&segments=&carriers=' -Method GET -Headers $headers

$headers=@{}
$headers.Add("accept", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/offers/fares/fares?catalogues=&segments=&carriers=' -Method GET -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = { 'accept': "" }

conn.request("GET", "/baseUrl/offers/fares/fares?catalogues=&segments=&carriers=", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/offers/fares/fares"

querystring = {"catalogues":"","segments":"","carriers":""}

headers = {"accept": ""}

response = requests.get(url, headers=headers, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/offers/fares/fares"

queryString <- list(
  catalogues = "",
  segments = "",
  carriers = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/offers/fares/fares?catalogues=&segments=&carriers=")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["accept"] = ''

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/offers/fares/fares') do |req|
  req.headers['accept'] = ''
  req.params['catalogues'] = ''
  req.params['segments'] = ''
  req.params['carriers'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/offers/fares/fares";

    let querystring = [
        ("catalogues", ""),
        ("segments", ""),
        ("carriers", ""),
    ];

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("accept", "".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/offers/fares/fares?catalogues=&segments=&carriers=' \
  --header 'accept: '

http GET '{{baseUrl}}/offers/fares/fares?catalogues=&segments=&carriers=' \
  accept:''

wget --quiet \
  --method GET \
  --header 'accept: ' \
  --output-document \
  - '{{baseUrl}}/offers/fares/fares?catalogues=&segments=&carriers='

import Foundation

let headers = ["accept": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/offers/fares/fares?catalogues=&segments=&carriers=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET LH Deep Links - FFP

{{baseUrl}}/offers/fares/deeplink/ffp

HEADERS

QUERY PARAMS

catalogues

origin

destination

travel-date

trackingid

country

lang

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/offers/fares/deeplink/ffp?catalogues=&origin=&destination=&travel-date=&trackingid=&country=&lang=");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "accept: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/offers/fares/deeplink/ffp" {:headers {:accept ""}
                                                                     :query-params {:catalogues ""
                                                                                    :origin ""
                                                                                    :destination ""
                                                                                    :travel-date ""
                                                                                    :trackingid ""
                                                                                    :country ""
                                                                                    :lang ""}})

require "http/client"

url = "{{baseUrl}}/offers/fares/deeplink/ffp?catalogues=&origin=&destination=&travel-date=&trackingid=&country=&lang="
headers = HTTP::Headers{
  "accept" => ""
}

response = HTTP::Client.get url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/offers/fares/deeplink/ffp?catalogues=&origin=&destination=&travel-date=&trackingid=&country=&lang="),
    Headers =
    {
        { "accept", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/offers/fares/deeplink/ffp?catalogues=&origin=&destination=&travel-date=&trackingid=&country=&lang=");
var request = new RestRequest("", Method.Get);
request.AddHeader("accept", "");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/offers/fares/deeplink/ffp?catalogues=&origin=&destination=&travel-date=&trackingid=&country=&lang="

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("accept", "")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/offers/fares/deeplink/ffp?catalogues=&origin=&destination=&travel-date=&trackingid=&country=&lang= HTTP/1.1
Accept: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/offers/fares/deeplink/ffp?catalogues=&origin=&destination=&travel-date=&trackingid=&country=&lang=")
  .setHeader("accept", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/offers/fares/deeplink/ffp?catalogues=&origin=&destination=&travel-date=&trackingid=&country=&lang="))
    .header("accept", "")
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/offers/fares/deeplink/ffp?catalogues=&origin=&destination=&travel-date=&trackingid=&country=&lang=")
  .get()
  .addHeader("accept", "")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/offers/fares/deeplink/ffp?catalogues=&origin=&destination=&travel-date=&trackingid=&country=&lang=")
  .header("accept", "")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/offers/fares/deeplink/ffp?catalogues=&origin=&destination=&travel-date=&trackingid=&country=&lang=');
xhr.setRequestHeader('accept', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/offers/fares/deeplink/ffp',
  params: {
    catalogues: '',
    origin: '',
    destination: '',
    'travel-date': '',
    trackingid: '',
    country: '',
    lang: ''
  },
  headers: {accept: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/offers/fares/deeplink/ffp?catalogues=&origin=&destination=&travel-date=&trackingid=&country=&lang=';
const options = {method: 'GET', headers: {accept: ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/offers/fares/deeplink/ffp?catalogues=&origin=&destination=&travel-date=&trackingid=&country=&lang=',
  method: 'GET',
  headers: {
    accept: ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/offers/fares/deeplink/ffp?catalogues=&origin=&destination=&travel-date=&trackingid=&country=&lang=")
  .get()
  .addHeader("accept", "")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/offers/fares/deeplink/ffp?catalogues=&origin=&destination=&travel-date=&trackingid=&country=&lang=',
  headers: {
    accept: ''
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/offers/fares/deeplink/ffp',
  qs: {
    catalogues: '',
    origin: '',
    destination: '',
    'travel-date': '',
    trackingid: '',
    country: '',
    lang: ''
  },
  headers: {accept: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/offers/fares/deeplink/ffp');

req.query({
  catalogues: '',
  origin: '',
  destination: '',
  'travel-date': '',
  trackingid: '',
  country: '',
  lang: ''
});

req.headers({
  accept: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/offers/fares/deeplink/ffp',
  params: {
    catalogues: '',
    origin: '',
    destination: '',
    'travel-date': '',
    trackingid: '',
    country: '',
    lang: ''
  },
  headers: {accept: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/offers/fares/deeplink/ffp?catalogues=&origin=&destination=&travel-date=&trackingid=&country=&lang=';
const options = {method: 'GET', headers: {accept: ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"accept": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/offers/fares/deeplink/ffp?catalogues=&origin=&destination=&travel-date=&trackingid=&country=&lang="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/offers/fares/deeplink/ffp?catalogues=&origin=&destination=&travel-date=&trackingid=&country=&lang=" in
let headers = Header.add (Header.init ()) "accept" "" in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/offers/fares/deeplink/ffp?catalogues=&origin=&destination=&travel-date=&trackingid=&country=&lang=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "accept: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/offers/fares/deeplink/ffp?catalogues=&origin=&destination=&travel-date=&trackingid=&country=&lang=', [
  'headers' => [
    'accept' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/offers/fares/deeplink/ffp');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'catalogues' => '',
  'origin' => '',
  'destination' => '',
  'travel-date' => '',
  'trackingid' => '',
  'country' => '',
  'lang' => ''
]);

$request->setHeaders([
  'accept' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/offers/fares/deeplink/ffp');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'catalogues' => '',
  'origin' => '',
  'destination' => '',
  'travel-date' => '',
  'trackingid' => '',
  'country' => '',
  'lang' => ''
]));

$request->setHeaders([
  'accept' => ''
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("accept", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/offers/fares/deeplink/ffp?catalogues=&origin=&destination=&travel-date=&trackingid=&country=&lang=' -Method GET -Headers $headers

$headers=@{}
$headers.Add("accept", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/offers/fares/deeplink/ffp?catalogues=&origin=&destination=&travel-date=&trackingid=&country=&lang=' -Method GET -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = { 'accept': "" }

conn.request("GET", "/baseUrl/offers/fares/deeplink/ffp?catalogues=&origin=&destination=&travel-date=&trackingid=&country=&lang=", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/offers/fares/deeplink/ffp"

querystring = {"catalogues":"","origin":"","destination":"","travel-date":"","trackingid":"","country":"","lang":""}

headers = {"accept": ""}

response = requests.get(url, headers=headers, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/offers/fares/deeplink/ffp"

queryString <- list(
  catalogues = "",
  origin = "",
  destination = "",
  travel-date = "",
  trackingid = "",
  country = "",
  lang = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/offers/fares/deeplink/ffp?catalogues=&origin=&destination=&travel-date=&trackingid=&country=&lang=")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["accept"] = ''

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/offers/fares/deeplink/ffp') do |req|
  req.headers['accept'] = ''
  req.params['catalogues'] = ''
  req.params['origin'] = ''
  req.params['destination'] = ''
  req.params['travel-date'] = ''
  req.params['trackingid'] = ''
  req.params['country'] = ''
  req.params['lang'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/offers/fares/deeplink/ffp";

    let querystring = [
        ("catalogues", ""),
        ("origin", ""),
        ("destination", ""),
        ("travel-date", ""),
        ("trackingid", ""),
        ("country", ""),
        ("lang", ""),
    ];

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("accept", "".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/offers/fares/deeplink/ffp?catalogues=&origin=&destination=&travel-date=&trackingid=&country=&lang=' \
  --header 'accept: '

http GET '{{baseUrl}}/offers/fares/deeplink/ffp?catalogues=&origin=&destination=&travel-date=&trackingid=&country=&lang=' \
  accept:''

wget --quiet \
  --method GET \
  --header 'accept: ' \
  --output-document \
  - '{{baseUrl}}/offers/fares/deeplink/ffp?catalogues=&origin=&destination=&travel-date=&trackingid=&country=&lang='

import Foundation

let headers = ["accept": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/offers/fares/deeplink/ffp?catalogues=&origin=&destination=&travel-date=&trackingid=&country=&lang=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET LH Deep Links - ITCO

{{baseUrl}}/offers/fares/deeplink/itco

HEADERS

QUERY PARAMS

catalogues

origin

destination

travel-date

outbound-segments

fare

fare-currency

trackingid

country

lang

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/offers/fares/deeplink/itco?catalogues=&origin=&destination=&travel-date=&outbound-segments=&fare=&fare-currency=&trackingid=&country=&lang=");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "accept: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/offers/fares/deeplink/itco" {:headers {:accept ""}
                                                                      :query-params {:catalogues ""
                                                                                     :origin ""
                                                                                     :destination ""
                                                                                     :travel-date ""
                                                                                     :outbound-segments ""
                                                                                     :fare ""
                                                                                     :fare-currency ""
                                                                                     :trackingid ""
                                                                                     :country ""
                                                                                     :lang ""}})

require "http/client"

url = "{{baseUrl}}/offers/fares/deeplink/itco?catalogues=&origin=&destination=&travel-date=&outbound-segments=&fare=&fare-currency=&trackingid=&country=&lang="
headers = HTTP::Headers{
  "accept" => ""
}

response = HTTP::Client.get url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/offers/fares/deeplink/itco?catalogues=&origin=&destination=&travel-date=&outbound-segments=&fare=&fare-currency=&trackingid=&country=&lang="),
    Headers =
    {
        { "accept", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/offers/fares/deeplink/itco?catalogues=&origin=&destination=&travel-date=&outbound-segments=&fare=&fare-currency=&trackingid=&country=&lang=");
var request = new RestRequest("", Method.Get);
request.AddHeader("accept", "");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/offers/fares/deeplink/itco?catalogues=&origin=&destination=&travel-date=&outbound-segments=&fare=&fare-currency=&trackingid=&country=&lang="

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("accept", "")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/offers/fares/deeplink/itco?catalogues=&origin=&destination=&travel-date=&outbound-segments=&fare=&fare-currency=&trackingid=&country=&lang= HTTP/1.1
Accept: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/offers/fares/deeplink/itco?catalogues=&origin=&destination=&travel-date=&outbound-segments=&fare=&fare-currency=&trackingid=&country=&lang=")
  .setHeader("accept", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/offers/fares/deeplink/itco?catalogues=&origin=&destination=&travel-date=&outbound-segments=&fare=&fare-currency=&trackingid=&country=&lang="))
    .header("accept", "")
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/offers/fares/deeplink/itco?catalogues=&origin=&destination=&travel-date=&outbound-segments=&fare=&fare-currency=&trackingid=&country=&lang=")
  .get()
  .addHeader("accept", "")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/offers/fares/deeplink/itco?catalogues=&origin=&destination=&travel-date=&outbound-segments=&fare=&fare-currency=&trackingid=&country=&lang=")
  .header("accept", "")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/offers/fares/deeplink/itco?catalogues=&origin=&destination=&travel-date=&outbound-segments=&fare=&fare-currency=&trackingid=&country=&lang=');
xhr.setRequestHeader('accept', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/offers/fares/deeplink/itco',
  params: {
    catalogues: '',
    origin: '',
    destination: '',
    'travel-date': '',
    'outbound-segments': '',
    fare: '',
    'fare-currency': '',
    trackingid: '',
    country: '',
    lang: ''
  },
  headers: {accept: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/offers/fares/deeplink/itco?catalogues=&origin=&destination=&travel-date=&outbound-segments=&fare=&fare-currency=&trackingid=&country=&lang=';
const options = {method: 'GET', headers: {accept: ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/offers/fares/deeplink/itco?catalogues=&origin=&destination=&travel-date=&outbound-segments=&fare=&fare-currency=&trackingid=&country=&lang=',
  method: 'GET',
  headers: {
    accept: ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/offers/fares/deeplink/itco?catalogues=&origin=&destination=&travel-date=&outbound-segments=&fare=&fare-currency=&trackingid=&country=&lang=")
  .get()
  .addHeader("accept", "")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/offers/fares/deeplink/itco?catalogues=&origin=&destination=&travel-date=&outbound-segments=&fare=&fare-currency=&trackingid=&country=&lang=',
  headers: {
    accept: ''
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/offers/fares/deeplink/itco',
  qs: {
    catalogues: '',
    origin: '',
    destination: '',
    'travel-date': '',
    'outbound-segments': '',
    fare: '',
    'fare-currency': '',
    trackingid: '',
    country: '',
    lang: ''
  },
  headers: {accept: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/offers/fares/deeplink/itco');

req.query({
  catalogues: '',
  origin: '',
  destination: '',
  'travel-date': '',
  'outbound-segments': '',
  fare: '',
  'fare-currency': '',
  trackingid: '',
  country: '',
  lang: ''
});

req.headers({
  accept: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/offers/fares/deeplink/itco',
  params: {
    catalogues: '',
    origin: '',
    destination: '',
    'travel-date': '',
    'outbound-segments': '',
    fare: '',
    'fare-currency': '',
    trackingid: '',
    country: '',
    lang: ''
  },
  headers: {accept: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/offers/fares/deeplink/itco?catalogues=&origin=&destination=&travel-date=&outbound-segments=&fare=&fare-currency=&trackingid=&country=&lang=';
const options = {method: 'GET', headers: {accept: ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"accept": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/offers/fares/deeplink/itco?catalogues=&origin=&destination=&travel-date=&outbound-segments=&fare=&fare-currency=&trackingid=&country=&lang="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/offers/fares/deeplink/itco?catalogues=&origin=&destination=&travel-date=&outbound-segments=&fare=&fare-currency=&trackingid=&country=&lang=" in
let headers = Header.add (Header.init ()) "accept" "" in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/offers/fares/deeplink/itco?catalogues=&origin=&destination=&travel-date=&outbound-segments=&fare=&fare-currency=&trackingid=&country=&lang=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "accept: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/offers/fares/deeplink/itco?catalogues=&origin=&destination=&travel-date=&outbound-segments=&fare=&fare-currency=&trackingid=&country=&lang=', [
  'headers' => [
    'accept' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/offers/fares/deeplink/itco');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'catalogues' => '',
  'origin' => '',
  'destination' => '',
  'travel-date' => '',
  'outbound-segments' => '',
  'fare' => '',
  'fare-currency' => '',
  'trackingid' => '',
  'country' => '',
  'lang' => ''
]);

$request->setHeaders([
  'accept' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/offers/fares/deeplink/itco');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'catalogues' => '',
  'origin' => '',
  'destination' => '',
  'travel-date' => '',
  'outbound-segments' => '',
  'fare' => '',
  'fare-currency' => '',
  'trackingid' => '',
  'country' => '',
  'lang' => ''
]));

$request->setHeaders([
  'accept' => ''
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("accept", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/offers/fares/deeplink/itco?catalogues=&origin=&destination=&travel-date=&outbound-segments=&fare=&fare-currency=&trackingid=&country=&lang=' -Method GET -Headers $headers

$headers=@{}
$headers.Add("accept", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/offers/fares/deeplink/itco?catalogues=&origin=&destination=&travel-date=&outbound-segments=&fare=&fare-currency=&trackingid=&country=&lang=' -Method GET -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = { 'accept': "" }

conn.request("GET", "/baseUrl/offers/fares/deeplink/itco?catalogues=&origin=&destination=&travel-date=&outbound-segments=&fare=&fare-currency=&trackingid=&country=&lang=", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/offers/fares/deeplink/itco"

querystring = {"catalogues":"","origin":"","destination":"","travel-date":"","outbound-segments":"","fare":"","fare-currency":"","trackingid":"","country":"","lang":""}

headers = {"accept": ""}

response = requests.get(url, headers=headers, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/offers/fares/deeplink/itco"

queryString <- list(
  catalogues = "",
  origin = "",
  destination = "",
  travel-date = "",
  outbound-segments = "",
  fare = "",
  fare-currency = "",
  trackingid = "",
  country = "",
  lang = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/offers/fares/deeplink/itco?catalogues=&origin=&destination=&travel-date=&outbound-segments=&fare=&fare-currency=&trackingid=&country=&lang=")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["accept"] = ''

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/offers/fares/deeplink/itco') do |req|
  req.headers['accept'] = ''
  req.params['catalogues'] = ''
  req.params['origin'] = ''
  req.params['destination'] = ''
  req.params['travel-date'] = ''
  req.params['outbound-segments'] = ''
  req.params['fare'] = ''
  req.params['fare-currency'] = ''
  req.params['trackingid'] = ''
  req.params['country'] = ''
  req.params['lang'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/offers/fares/deeplink/itco";

    let querystring = [
        ("catalogues", ""),
        ("origin", ""),
        ("destination", ""),
        ("travel-date", ""),
        ("outbound-segments", ""),
        ("fare", ""),
        ("fare-currency", ""),
        ("trackingid", ""),
        ("country", ""),
        ("lang", ""),
    ];

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("accept", "".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/offers/fares/deeplink/itco?catalogues=&origin=&destination=&travel-date=&outbound-segments=&fare=&fare-currency=&trackingid=&country=&lang=' \
  --header 'accept: '

http GET '{{baseUrl}}/offers/fares/deeplink/itco?catalogues=&origin=&destination=&travel-date=&outbound-segments=&fare=&fare-currency=&trackingid=&country=&lang=' \
  accept:''

wget --quiet \
  --method GET \
  --header 'accept: ' \
  --output-document \
  - '{{baseUrl}}/offers/fares/deeplink/itco?catalogues=&origin=&destination=&travel-date=&outbound-segments=&fare=&fare-currency=&trackingid=&country=&lang='

import Foundation

let headers = ["accept": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/offers/fares/deeplink/itco?catalogues=&origin=&destination=&travel-date=&outbound-segments=&fare=&fare-currency=&trackingid=&country=&lang=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Lowest Fares

{{baseUrl}}/offers/fares/lowestfares

HEADERS

QUERY PARAMS

catalogues

origin

destination

travel-date

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/offers/fares/lowestfares?catalogues=&origin=&destination=&travel-date=");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "accept: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/offers/fares/lowestfares" {:headers {:accept ""}
                                                                    :query-params {:catalogues ""
                                                                                   :origin ""
                                                                                   :destination ""
                                                                                   :travel-date ""}})

require "http/client"

url = "{{baseUrl}}/offers/fares/lowestfares?catalogues=&origin=&destination=&travel-date="
headers = HTTP::Headers{
  "accept" => ""
}

response = HTTP::Client.get url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/offers/fares/lowestfares?catalogues=&origin=&destination=&travel-date="),
    Headers =
    {
        { "accept", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/offers/fares/lowestfares?catalogues=&origin=&destination=&travel-date=");
var request = new RestRequest("", Method.Get);
request.AddHeader("accept", "");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/offers/fares/lowestfares?catalogues=&origin=&destination=&travel-date="

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("accept", "")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/offers/fares/lowestfares?catalogues=&origin=&destination=&travel-date= HTTP/1.1
Accept: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/offers/fares/lowestfares?catalogues=&origin=&destination=&travel-date=")
  .setHeader("accept", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/offers/fares/lowestfares?catalogues=&origin=&destination=&travel-date="))
    .header("accept", "")
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/offers/fares/lowestfares?catalogues=&origin=&destination=&travel-date=")
  .get()
  .addHeader("accept", "")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/offers/fares/lowestfares?catalogues=&origin=&destination=&travel-date=")
  .header("accept", "")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/offers/fares/lowestfares?catalogues=&origin=&destination=&travel-date=');
xhr.setRequestHeader('accept', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/offers/fares/lowestfares',
  params: {catalogues: '', origin: '', destination: '', 'travel-date': ''},
  headers: {accept: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/offers/fares/lowestfares?catalogues=&origin=&destination=&travel-date=';
const options = {method: 'GET', headers: {accept: ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/offers/fares/lowestfares?catalogues=&origin=&destination=&travel-date=',
  method: 'GET',
  headers: {
    accept: ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/offers/fares/lowestfares?catalogues=&origin=&destination=&travel-date=")
  .get()
  .addHeader("accept", "")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/offers/fares/lowestfares?catalogues=&origin=&destination=&travel-date=',
  headers: {
    accept: ''
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/offers/fares/lowestfares',
  qs: {catalogues: '', origin: '', destination: '', 'travel-date': ''},
  headers: {accept: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/offers/fares/lowestfares');

req.query({
  catalogues: '',
  origin: '',
  destination: '',
  'travel-date': ''
});

req.headers({
  accept: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/offers/fares/lowestfares',
  params: {catalogues: '', origin: '', destination: '', 'travel-date': ''},
  headers: {accept: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/offers/fares/lowestfares?catalogues=&origin=&destination=&travel-date=';
const options = {method: 'GET', headers: {accept: ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"accept": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/offers/fares/lowestfares?catalogues=&origin=&destination=&travel-date="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/offers/fares/lowestfares?catalogues=&origin=&destination=&travel-date=" in
let headers = Header.add (Header.init ()) "accept" "" in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/offers/fares/lowestfares?catalogues=&origin=&destination=&travel-date=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "accept: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/offers/fares/lowestfares?catalogues=&origin=&destination=&travel-date=', [
  'headers' => [
    'accept' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/offers/fares/lowestfares');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'catalogues' => '',
  'origin' => '',
  'destination' => '',
  'travel-date' => ''
]);

$request->setHeaders([
  'accept' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/offers/fares/lowestfares');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'catalogues' => '',
  'origin' => '',
  'destination' => '',
  'travel-date' => ''
]));

$request->setHeaders([
  'accept' => ''
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("accept", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/offers/fares/lowestfares?catalogues=&origin=&destination=&travel-date=' -Method GET -Headers $headers

$headers=@{}
$headers.Add("accept", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/offers/fares/lowestfares?catalogues=&origin=&destination=&travel-date=' -Method GET -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = { 'accept': "" }

conn.request("GET", "/baseUrl/offers/fares/lowestfares?catalogues=&origin=&destination=&travel-date=", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/offers/fares/lowestfares"

querystring = {"catalogues":"","origin":"","destination":"","travel-date":""}

headers = {"accept": ""}

response = requests.get(url, headers=headers, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/offers/fares/lowestfares"

queryString <- list(
  catalogues = "",
  origin = "",
  destination = "",
  travel-date = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/offers/fares/lowestfares?catalogues=&origin=&destination=&travel-date=")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["accept"] = ''

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/offers/fares/lowestfares') do |req|
  req.headers['accept'] = ''
  req.params['catalogues'] = ''
  req.params['origin'] = ''
  req.params['destination'] = ''
  req.params['travel-date'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/offers/fares/lowestfares";

    let querystring = [
        ("catalogues", ""),
        ("origin", ""),
        ("destination", ""),
        ("travel-date", ""),
    ];

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("accept", "".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/offers/fares/lowestfares?catalogues=&origin=&destination=&travel-date=' \
  --header 'accept: '

http GET '{{baseUrl}}/offers/fares/lowestfares?catalogues=&origin=&destination=&travel-date=' \
  accept:''

wget --quiet \
  --method GET \
  --header 'accept: ' \
  --output-document \
  - '{{baseUrl}}/offers/fares/lowestfares?catalogues=&origin=&destination=&travel-date='

import Foundation

let headers = ["accept": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/offers/fares/lowestfares?catalogues=&origin=&destination=&travel-date=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET OND Route

{{baseUrl}}/offers/ond/route/:origin/:destination

HEADERS

QUERY PARAMS

origin

destination

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/offers/ond/route/:origin/:destination");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "accept: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/offers/ond/route/:origin/:destination" {:headers {:accept ""}})

require "http/client"

url = "{{baseUrl}}/offers/ond/route/:origin/:destination"
headers = HTTP::Headers{
  "accept" => ""
}

response = HTTP::Client.get url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/offers/ond/route/:origin/:destination"),
    Headers =
    {
        { "accept", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/offers/ond/route/:origin/:destination");
var request = new RestRequest("", Method.Get);
request.AddHeader("accept", "");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/offers/ond/route/:origin/:destination"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("accept", "")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/offers/ond/route/:origin/:destination HTTP/1.1
Accept: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/offers/ond/route/:origin/:destination")
  .setHeader("accept", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/offers/ond/route/:origin/:destination"))
    .header("accept", "")
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/offers/ond/route/:origin/:destination")
  .get()
  .addHeader("accept", "")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/offers/ond/route/:origin/:destination")
  .header("accept", "")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/offers/ond/route/:origin/:destination');
xhr.setRequestHeader('accept', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/offers/ond/route/:origin/:destination',
  headers: {accept: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/offers/ond/route/:origin/:destination';
const options = {method: 'GET', headers: {accept: ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/offers/ond/route/:origin/:destination',
  method: 'GET',
  headers: {
    accept: ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/offers/ond/route/:origin/:destination")
  .get()
  .addHeader("accept", "")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/offers/ond/route/:origin/:destination',
  headers: {
    accept: ''
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/offers/ond/route/:origin/:destination',
  headers: {accept: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/offers/ond/route/:origin/:destination');

req.headers({
  accept: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/offers/ond/route/:origin/:destination',
  headers: {accept: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/offers/ond/route/:origin/:destination';
const options = {method: 'GET', headers: {accept: ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"accept": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/offers/ond/route/:origin/:destination"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/offers/ond/route/:origin/:destination" in
let headers = Header.add (Header.init ()) "accept" "" in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/offers/ond/route/:origin/:destination",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "accept: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/offers/ond/route/:origin/:destination', [
  'headers' => [
    'accept' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/offers/ond/route/:origin/:destination');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'accept' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/offers/ond/route/:origin/:destination');
$request->setRequestMethod('GET');
$request->setHeaders([
  'accept' => ''
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("accept", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/offers/ond/route/:origin/:destination' -Method GET -Headers $headers

$headers=@{}
$headers.Add("accept", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/offers/ond/route/:origin/:destination' -Method GET -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = { 'accept': "" }

conn.request("GET", "/baseUrl/offers/ond/route/:origin/:destination", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/offers/ond/route/:origin/:destination"

headers = {"accept": ""}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/offers/ond/route/:origin/:destination"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/offers/ond/route/:origin/:destination")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["accept"] = ''

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/offers/ond/route/:origin/:destination') do |req|
  req.headers['accept'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/offers/ond/route/:origin/:destination";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("accept", "".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.get(url)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/offers/ond/route/:origin/:destination \
  --header 'accept: '

http GET {{baseUrl}}/offers/ond/route/:origin/:destination \
  accept:''

wget --quiet \
  --method GET \
  --header 'accept: ' \
  --output-document \
  - {{baseUrl}}/offers/ond/route/:origin/:destination

import Foundation

let headers = ["accept": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/offers/ond/route/:origin/:destination")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET OND Status

{{baseUrl}}/offers/ond/status

HEADERS

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/offers/ond/status");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "accept: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/offers/ond/status" {:headers {:accept ""}})

require "http/client"

url = "{{baseUrl}}/offers/ond/status"
headers = HTTP::Headers{
  "accept" => ""
}

response = HTTP::Client.get url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/offers/ond/status"),
    Headers =
    {
        { "accept", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/offers/ond/status");
var request = new RestRequest("", Method.Get);
request.AddHeader("accept", "");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/offers/ond/status"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("accept", "")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/offers/ond/status HTTP/1.1
Accept: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/offers/ond/status")
  .setHeader("accept", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/offers/ond/status"))
    .header("accept", "")
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/offers/ond/status")
  .get()
  .addHeader("accept", "")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/offers/ond/status")
  .header("accept", "")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/offers/ond/status');
xhr.setRequestHeader('accept', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/offers/ond/status',
  headers: {accept: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/offers/ond/status';
const options = {method: 'GET', headers: {accept: ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/offers/ond/status',
  method: 'GET',
  headers: {
    accept: ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/offers/ond/status")
  .get()
  .addHeader("accept", "")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/offers/ond/status',
  headers: {
    accept: ''
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/offers/ond/status',
  headers: {accept: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/offers/ond/status');

req.headers({
  accept: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/offers/ond/status',
  headers: {accept: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/offers/ond/status';
const options = {method: 'GET', headers: {accept: ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"accept": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/offers/ond/status"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/offers/ond/status" in
let headers = Header.add (Header.init ()) "accept" "" in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/offers/ond/status",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "accept: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/offers/ond/status', [
  'headers' => [
    'accept' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/offers/ond/status');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'accept' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/offers/ond/status');
$request->setRequestMethod('GET');
$request->setHeaders([
  'accept' => ''
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("accept", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/offers/ond/status' -Method GET -Headers $headers

$headers=@{}
$headers.Add("accept", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/offers/ond/status' -Method GET -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = { 'accept': "" }

conn.request("GET", "/baseUrl/offers/ond/status", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/offers/ond/status"

headers = {"accept": ""}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/offers/ond/status"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/offers/ond/status")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["accept"] = ''

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/offers/ond/status') do |req|
  req.headers['accept'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/offers/ond/status";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("accept", "".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.get(url)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/offers/ond/status \
  --header 'accept: '

http GET {{baseUrl}}/offers/ond/status \
  accept:''

wget --quiet \
  --method GET \
  --header 'accept: ' \
  --output-document \
  - {{baseUrl}}/offers/ond/status

import Foundation

let headers = ["accept": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/offers/ond/status")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Top OND

{{baseUrl}}/offers/ond/top

HEADERS

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/offers/ond/top");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "accept: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/offers/ond/top" {:headers {:accept ""}})

require "http/client"

url = "{{baseUrl}}/offers/ond/top"
headers = HTTP::Headers{
  "accept" => ""
}

response = HTTP::Client.get url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/offers/ond/top"),
    Headers =
    {
        { "accept", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/offers/ond/top");
var request = new RestRequest("", Method.Get);
request.AddHeader("accept", "");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/offers/ond/top"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("accept", "")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/offers/ond/top HTTP/1.1
Accept: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/offers/ond/top")
  .setHeader("accept", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/offers/ond/top"))
    .header("accept", "")
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/offers/ond/top")
  .get()
  .addHeader("accept", "")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/offers/ond/top")
  .header("accept", "")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/offers/ond/top');
xhr.setRequestHeader('accept', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/offers/ond/top',
  headers: {accept: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/offers/ond/top';
const options = {method: 'GET', headers: {accept: ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/offers/ond/top',
  method: 'GET',
  headers: {
    accept: ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/offers/ond/top")
  .get()
  .addHeader("accept", "")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/offers/ond/top',
  headers: {
    accept: ''
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/offers/ond/top',
  headers: {accept: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/offers/ond/top');

req.headers({
  accept: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/offers/ond/top',
  headers: {accept: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/offers/ond/top';
const options = {method: 'GET', headers: {accept: ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"accept": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/offers/ond/top"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/offers/ond/top" in
let headers = Header.add (Header.init ()) "accept" "" in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/offers/ond/top",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "accept: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/offers/ond/top', [
  'headers' => [
    'accept' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/offers/ond/top');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'accept' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/offers/ond/top');
$request->setRequestMethod('GET');
$request->setHeaders([
  'accept' => ''
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("accept", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/offers/ond/top' -Method GET -Headers $headers

$headers=@{}
$headers.Add("accept", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/offers/ond/top' -Method GET -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = { 'accept': "" }

conn.request("GET", "/baseUrl/offers/ond/top", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/offers/ond/top"

headers = {"accept": ""}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/offers/ond/top"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/offers/ond/top")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["accept"] = ''

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/offers/ond/top') do |req|
  req.headers['accept'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/offers/ond/top";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("accept", "".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.get(url)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/offers/ond/top \
  --header 'accept: '

http GET {{baseUrl}}/offers/ond/top \
  accept:''

wget --quiet \
  --method GET \
  --header 'accept: ' \
  --output-document \
  - {{baseUrl}}/offers/ond/top

import Foundation

let headers = ["accept": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/offers/ond/top")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Orders

{{baseUrl}}/orders/orders/:orderID/:name

HEADERS

QUERY PARAMS

orderID

name

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/orders/orders/:orderID/:name");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "accept: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/orders/orders/:orderID/:name" {:headers {:accept ""}})

require "http/client"

url = "{{baseUrl}}/orders/orders/:orderID/:name"
headers = HTTP::Headers{
  "accept" => ""
}

response = HTTP::Client.get url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/orders/orders/:orderID/:name"),
    Headers =
    {
        { "accept", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/orders/orders/:orderID/:name");
var request = new RestRequest("", Method.Get);
request.AddHeader("accept", "");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/orders/orders/:orderID/:name"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("accept", "")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/orders/orders/:orderID/:name HTTP/1.1
Accept: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/orders/orders/:orderID/:name")
  .setHeader("accept", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/orders/orders/:orderID/:name"))
    .header("accept", "")
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/orders/orders/:orderID/:name")
  .get()
  .addHeader("accept", "")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/orders/orders/:orderID/:name")
  .header("accept", "")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/orders/orders/:orderID/:name');
xhr.setRequestHeader('accept', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/orders/orders/:orderID/:name',
  headers: {accept: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/orders/orders/:orderID/:name';
const options = {method: 'GET', headers: {accept: ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/orders/orders/:orderID/:name',
  method: 'GET',
  headers: {
    accept: ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/orders/orders/:orderID/:name")
  .get()
  .addHeader("accept", "")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/orders/orders/:orderID/:name',
  headers: {
    accept: ''
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/orders/orders/:orderID/:name',
  headers: {accept: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/orders/orders/:orderID/:name');

req.headers({
  accept: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/orders/orders/:orderID/:name',
  headers: {accept: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/orders/orders/:orderID/:name';
const options = {method: 'GET', headers: {accept: ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"accept": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/orders/orders/:orderID/:name"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/orders/orders/:orderID/:name" in
let headers = Header.add (Header.init ()) "accept" "" in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/orders/orders/:orderID/:name",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "accept: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/orders/orders/:orderID/:name', [
  'headers' => [
    'accept' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/orders/orders/:orderID/:name');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'accept' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/orders/orders/:orderID/:name');
$request->setRequestMethod('GET');
$request->setHeaders([
  'accept' => ''
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("accept", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/orders/orders/:orderID/:name' -Method GET -Headers $headers

$headers=@{}
$headers.Add("accept", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/orders/orders/:orderID/:name' -Method GET -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = { 'accept': "" }

conn.request("GET", "/baseUrl/orders/orders/:orderID/:name", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/orders/orders/:orderID/:name"

headers = {"accept": ""}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/orders/orders/:orderID/:name"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/orders/orders/:orderID/:name")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["accept"] = ''

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/orders/orders/:orderID/:name') do |req|
  req.headers['accept'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/orders/orders/:orderID/:name";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("accept", "".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.get(url)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/orders/orders/:orderID/:name \
  --header 'accept: '

http GET {{baseUrl}}/orders/orders/:orderID/:name \
  accept:''

wget --quiet \
  --method GET \
  --header 'accept: ' \
  --output-document \
  - {{baseUrl}}/orders/orders/:orderID/:name

import Foundation

let headers = ["accept": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/orders/orders/:orderID/:name")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

PUT Auto Check-In

{{baseUrl}}/preflight/autocheckin/:ticketnumber

HEADERS

QUERY PARAMS

emailAddress

ticketnumber

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/preflight/autocheckin/:ticketnumber?emailAddress=");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "accept: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/preflight/autocheckin/:ticketnumber" {:headers {:accept ""}
                                                                               :query-params {:emailAddress ""}})

require "http/client"

url = "{{baseUrl}}/preflight/autocheckin/:ticketnumber?emailAddress="
headers = HTTP::Headers{
  "accept" => ""
}

response = HTTP::Client.put url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/preflight/autocheckin/:ticketnumber?emailAddress="),
    Headers =
    {
        { "accept", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/preflight/autocheckin/:ticketnumber?emailAddress=");
var request = new RestRequest("", Method.Put);
request.AddHeader("accept", "");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/preflight/autocheckin/:ticketnumber?emailAddress="

	req, _ := http.NewRequest("PUT", url, nil)

	req.Header.Add("accept", "")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

PUT /baseUrl/preflight/autocheckin/:ticketnumber?emailAddress= HTTP/1.1
Accept: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/preflight/autocheckin/:ticketnumber?emailAddress=")
  .setHeader("accept", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/preflight/autocheckin/:ticketnumber?emailAddress="))
    .header("accept", "")
    .method("PUT", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/preflight/autocheckin/:ticketnumber?emailAddress=")
  .put(null)
  .addHeader("accept", "")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/preflight/autocheckin/:ticketnumber?emailAddress=")
  .header("accept", "")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/preflight/autocheckin/:ticketnumber?emailAddress=');
xhr.setRequestHeader('accept', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/preflight/autocheckin/:ticketnumber',
  params: {emailAddress: ''},
  headers: {accept: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/preflight/autocheckin/:ticketnumber?emailAddress=';
const options = {method: 'PUT', headers: {accept: ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/preflight/autocheckin/:ticketnumber?emailAddress=',
  method: 'PUT',
  headers: {
    accept: ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/preflight/autocheckin/:ticketnumber?emailAddress=")
  .put(null)
  .addHeader("accept", "")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/preflight/autocheckin/:ticketnumber?emailAddress=',
  headers: {
    accept: ''
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/preflight/autocheckin/:ticketnumber',
  qs: {emailAddress: ''},
  headers: {accept: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/preflight/autocheckin/:ticketnumber');

req.query({
  emailAddress: ''
});

req.headers({
  accept: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/preflight/autocheckin/:ticketnumber',
  params: {emailAddress: ''},
  headers: {accept: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/preflight/autocheckin/:ticketnumber?emailAddress=';
const options = {method: 'PUT', headers: {accept: ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"accept": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/preflight/autocheckin/:ticketnumber?emailAddress="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/preflight/autocheckin/:ticketnumber?emailAddress=" in
let headers = Header.add (Header.init ()) "accept" "" in

Client.call ~headers `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/preflight/autocheckin/:ticketnumber?emailAddress=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_HTTPHEADER => [
    "accept: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('PUT', '{{baseUrl}}/preflight/autocheckin/:ticketnumber?emailAddress=', [
  'headers' => [
    'accept' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/preflight/autocheckin/:ticketnumber');
$request->setMethod(HTTP_METH_PUT);

$request->setQueryData([
  'emailAddress' => ''
]);

$request->setHeaders([
  'accept' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/preflight/autocheckin/:ticketnumber');
$request->setRequestMethod('PUT');
$request->setQuery(new http\QueryString([
  'emailAddress' => ''
]));

$request->setHeaders([
  'accept' => ''
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("accept", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/preflight/autocheckin/:ticketnumber?emailAddress=' -Method PUT -Headers $headers

$headers=@{}
$headers.Add("accept", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/preflight/autocheckin/:ticketnumber?emailAddress=' -Method PUT -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = { 'accept': "" }

conn.request("PUT", "/baseUrl/preflight/autocheckin/:ticketnumber?emailAddress=", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/preflight/autocheckin/:ticketnumber"

querystring = {"emailAddress":""}

headers = {"accept": ""}

response = requests.put(url, headers=headers, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/preflight/autocheckin/:ticketnumber"

queryString <- list(emailAddress = "")

response <- VERB("PUT", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/preflight/autocheckin/:ticketnumber?emailAddress=")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Put.new(url)
request["accept"] = ''

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.put('/baseUrl/preflight/autocheckin/:ticketnumber') do |req|
  req.headers['accept'] = ''
  req.params['emailAddress'] = ''
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/preflight/autocheckin/:ticketnumber";

    let querystring = [
        ("emailAddress", ""),
    ];

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("accept", "".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .query(&querystring)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request PUT \
  --url '{{baseUrl}}/preflight/autocheckin/:ticketnumber?emailAddress=' \
  --header 'accept: '

http PUT '{{baseUrl}}/preflight/autocheckin/:ticketnumber?emailAddress=' \
  accept:''

wget --quiet \
  --method PUT \
  --header 'accept: ' \
  --output-document \
  - '{{baseUrl}}/preflight/autocheckin/:ticketnumber?emailAddress='

import Foundation

let headers = ["accept": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/preflight/autocheckin/:ticketnumber?emailAddress=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Price Offers

{{baseUrl}}/promotions/priceoffers/flights/ond/:origin/:destination

QUERY PARAMS

departureDate

returnDate

origin

destination

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/promotions/priceoffers/flights/ond/:origin/:destination?departureDate=&returnDate=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/promotions/priceoffers/flights/ond/:origin/:destination" {:query-params {:departureDate ""
                                                                                                                  :returnDate ""}})

require "http/client"

url = "{{baseUrl}}/promotions/priceoffers/flights/ond/:origin/:destination?departureDate=&returnDate="

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/promotions/priceoffers/flights/ond/:origin/:destination?departureDate=&returnDate="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/promotions/priceoffers/flights/ond/:origin/:destination?departureDate=&returnDate=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/promotions/priceoffers/flights/ond/:origin/:destination?departureDate=&returnDate="

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/promotions/priceoffers/flights/ond/:origin/:destination?departureDate=&returnDate= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/promotions/priceoffers/flights/ond/:origin/:destination?departureDate=&returnDate=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/promotions/priceoffers/flights/ond/:origin/:destination?departureDate=&returnDate="))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/promotions/priceoffers/flights/ond/:origin/:destination?departureDate=&returnDate=")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/promotions/priceoffers/flights/ond/:origin/:destination?departureDate=&returnDate=")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/promotions/priceoffers/flights/ond/:origin/:destination?departureDate=&returnDate=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/promotions/priceoffers/flights/ond/:origin/:destination',
  params: {departureDate: '', returnDate: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/promotions/priceoffers/flights/ond/:origin/:destination?departureDate=&returnDate=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/promotions/priceoffers/flights/ond/:origin/:destination?departureDate=&returnDate=',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/promotions/priceoffers/flights/ond/:origin/:destination?departureDate=&returnDate=")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/promotions/priceoffers/flights/ond/:origin/:destination?departureDate=&returnDate=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/promotions/priceoffers/flights/ond/:origin/:destination',
  qs: {departureDate: '', returnDate: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/promotions/priceoffers/flights/ond/:origin/:destination');

req.query({
  departureDate: '',
  returnDate: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/promotions/priceoffers/flights/ond/:origin/:destination',
  params: {departureDate: '', returnDate: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/promotions/priceoffers/flights/ond/:origin/:destination?departureDate=&returnDate=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/promotions/priceoffers/flights/ond/:origin/:destination?departureDate=&returnDate="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/promotions/priceoffers/flights/ond/:origin/:destination?departureDate=&returnDate=" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/promotions/priceoffers/flights/ond/:origin/:destination?departureDate=&returnDate=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/promotions/priceoffers/flights/ond/:origin/:destination?departureDate=&returnDate=');

echo $response->getBody();

setUrl('{{baseUrl}}/promotions/priceoffers/flights/ond/:origin/:destination');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'departureDate' => '',
  'returnDate' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/promotions/priceoffers/flights/ond/:origin/:destination');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'departureDate' => '',
  'returnDate' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/promotions/priceoffers/flights/ond/:origin/:destination?departureDate=&returnDate=' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/promotions/priceoffers/flights/ond/:origin/:destination?departureDate=&returnDate=' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/promotions/priceoffers/flights/ond/:origin/:destination?departureDate=&returnDate=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/promotions/priceoffers/flights/ond/:origin/:destination"

querystring = {"departureDate":"","returnDate":""}

response = requests.get(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/promotions/priceoffers/flights/ond/:origin/:destination"

queryString <- list(
  departureDate = "",
  returnDate = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/promotions/priceoffers/flights/ond/:origin/:destination?departureDate=&returnDate=")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/promotions/priceoffers/flights/ond/:origin/:destination') do |req|
  req.params['departureDate'] = ''
  req.params['returnDate'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/promotions/priceoffers/flights/ond/:origin/:destination";

    let querystring = [
        ("departureDate", ""),
        ("returnDate", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/promotions/priceoffers/flights/ond/:origin/:destination?departureDate=&returnDate='

http GET '{{baseUrl}}/promotions/priceoffers/flights/ond/:origin/:destination?departureDate=&returnDate='

wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/promotions/priceoffers/flights/ond/:origin/:destination?departureDate=&returnDate='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/promotions/priceoffers/flights/ond/:origin/:destination?departureDate=&returnDate=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Seat Details

{{baseUrl}}/references/seatdetails/:aircraftCode/:cabinCode

HEADERS

QUERY PARAMS

aircraftCode

cabinCode

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/references/seatdetails/:aircraftCode/:cabinCode");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "accept: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/references/seatdetails/:aircraftCode/:cabinCode" {:headers {:accept ""}})

require "http/client"

url = "{{baseUrl}}/references/seatdetails/:aircraftCode/:cabinCode"
headers = HTTP::Headers{
  "accept" => ""
}

response = HTTP::Client.get url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/references/seatdetails/:aircraftCode/:cabinCode"),
    Headers =
    {
        { "accept", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/references/seatdetails/:aircraftCode/:cabinCode");
var request = new RestRequest("", Method.Get);
request.AddHeader("accept", "");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/references/seatdetails/:aircraftCode/:cabinCode"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("accept", "")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/references/seatdetails/:aircraftCode/:cabinCode HTTP/1.1
Accept: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/references/seatdetails/:aircraftCode/:cabinCode")
  .setHeader("accept", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/references/seatdetails/:aircraftCode/:cabinCode"))
    .header("accept", "")
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/references/seatdetails/:aircraftCode/:cabinCode")
  .get()
  .addHeader("accept", "")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/references/seatdetails/:aircraftCode/:cabinCode")
  .header("accept", "")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/references/seatdetails/:aircraftCode/:cabinCode');
xhr.setRequestHeader('accept', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/references/seatdetails/:aircraftCode/:cabinCode',
  headers: {accept: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/references/seatdetails/:aircraftCode/:cabinCode';
const options = {method: 'GET', headers: {accept: ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/references/seatdetails/:aircraftCode/:cabinCode',
  method: 'GET',
  headers: {
    accept: ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/references/seatdetails/:aircraftCode/:cabinCode")
  .get()
  .addHeader("accept", "")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/references/seatdetails/:aircraftCode/:cabinCode',
  headers: {
    accept: ''
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/references/seatdetails/:aircraftCode/:cabinCode',
  headers: {accept: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/references/seatdetails/:aircraftCode/:cabinCode');

req.headers({
  accept: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/references/seatdetails/:aircraftCode/:cabinCode',
  headers: {accept: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/references/seatdetails/:aircraftCode/:cabinCode';
const options = {method: 'GET', headers: {accept: ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"accept": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/references/seatdetails/:aircraftCode/:cabinCode"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/references/seatdetails/:aircraftCode/:cabinCode" in
let headers = Header.add (Header.init ()) "accept" "" in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/references/seatdetails/:aircraftCode/:cabinCode",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "accept: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/references/seatdetails/:aircraftCode/:cabinCode', [
  'headers' => [
    'accept' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/references/seatdetails/:aircraftCode/:cabinCode');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'accept' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/references/seatdetails/:aircraftCode/:cabinCode');
$request->setRequestMethod('GET');
$request->setHeaders([
  'accept' => ''
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("accept", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/references/seatdetails/:aircraftCode/:cabinCode' -Method GET -Headers $headers

$headers=@{}
$headers.Add("accept", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/references/seatdetails/:aircraftCode/:cabinCode' -Method GET -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = { 'accept': "" }

conn.request("GET", "/baseUrl/references/seatdetails/:aircraftCode/:cabinCode", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/references/seatdetails/:aircraftCode/:cabinCode"

headers = {"accept": ""}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/references/seatdetails/:aircraftCode/:cabinCode"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/references/seatdetails/:aircraftCode/:cabinCode")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["accept"] = ''

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/references/seatdetails/:aircraftCode/:cabinCode') do |req|
  req.headers['accept'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/references/seatdetails/:aircraftCode/:cabinCode";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("accept", "".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.get(url)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/references/seatdetails/:aircraftCode/:cabinCode \
  --header 'accept: '

http GET {{baseUrl}}/references/seatdetails/:aircraftCode/:cabinCode \
  accept:''

wget --quiet \
  --method GET \
  --header 'accept: ' \
  --output-document \
  - {{baseUrl}}/references/seatdetails/:aircraftCode/:cabinCode

import Foundation

let headers = ["accept": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/references/seatdetails/:aircraftCode/:cabinCode")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()