@mattywhite/skyscanner-api 1.0.0

package/src/skyscanner.js

@@ -0,0 +1,634 @@
+const axios = require('axios');
+const config = require('./config');
+const PXSolver = require('./px');
+const {
+    Location,
+    Airport,
+    CabinClass,
+    SpecialTypes,
+    SkyscannerResponse,
+    Coordinates,
+} = require('./types');
+const {
+    AttemptsExhaustedIncompleteResponse,
+    BannedWithCaptcha,
+    GenericError
+} = require('./errors');
+const crypto = require('crypto');
+
+class SkyScanner {
+    /**
+     * A client for interacting with the Skyscanner flight and car rental APIs.
+     * 
+     * @param {Object} options - Configuration options
+     * @param {string} options.locale - Locale code for results (default: "en-US")
+     * @param {string} options.currency - Currency code for pricing (default: "USD")
+     * @param {string} options.market - Market region code (default: "US")
+     * @param {number} options.retryDelay - Seconds to wait between polling retries (default: 2)
+     * @param {number} options.maxRetries - Maximum number of polling retries (default: 15)
+     * @param {string} options.proxy - Proxy URL for HTTP requests
+     * @param {string} options.pxAuthorization - Optional pre-generated PX authorization token
+     * @param {boolean} options.verify - If set to false, SSL certificates won't be verified (default: true)
+     */
+    constructor(options = {}) {
+        this.locale = options.locale || "en-US";
+        this.currency = options.currency || "USD";
+        this.market = options.market || "US";
+        this.retryDelay = options.retryDelay || 2;
+        this.maxRetries = options.maxRetries || 15;
+        this.proxy = options.proxy || "";
+        this.verify = options.verify !== undefined ? options.verify : true;
+
+        this.pxAuthorization = null;
+        this.UUID = null;
+
+        this.initialized = false;
+    }
+
+    /**
+     * Initialize the client (async initialization)
+     * @private
+     */
+    async _initialize() {
+        if (this.initialized) return;
+
+        if (!this.pxAuthorization) {
+            const solver = new PXSolver(this.proxy, this.verify);
+            [this.pxAuthorization, this.UUID] = await solver.genPxAuthorization();
+        }
+
+        this.headers = {
+            "X-Skyscanner-ChannelId": "goandroid",
+            "X-Skyscanner-Currency": this.currency,
+            "X-Skyscanner-Locale": this.locale,
+            "X-Skyscanner-Market": this.market,
+            "X-Skyscanner-Device": "Android-phone",
+            "X-Skyscanner-Device-Class": "phone",
+            "X-Skyscanner-Client-Type": "net.skyscanner.android.main",
+            "X-Skyscanner-Client-Network-Type": "WIFI",
+            "Content-Type": "application/json; charset=UTF-8",
+            "X-Px-Authorization": this.pxAuthorization,
+            "X-PX-Os": "Android",
+            "X-Px-Uuid": this.UUID,
+            "X-Px-Mobile-Sdk-Version": "3.4.4",
+        };
+
+        this.axiosConfig = {
+            headers: this.headers,
+            proxy: this.proxy ? {
+                host: new URL(this.proxy).hostname,
+                port: new URL(this.proxy).port
+            } : false
+        };
+
+        this.initialized = true;
+    }
+
+    /**
+     * Search for flight prices between two points.
+     * 
+     * @param {Object} params - Search parameters
+     * @param {Airport} params.origin - Origin airport object
+     * @param {Airport|SpecialTypes} params.destination - Destination airport or special search type
+     * @param {Date|string|null} params.departDate - Departure date or special enum (default: now)
+     * @param {Date|string|null} params.returnDate - Return date or special enum (optional)
+     * @param {string} params.cabinClass - Cabin class for travel (default: ECONOMY)
+     * @param {number} params.adults - Number of adult passengers (max 8)
+     * @param {number[]} params.childAges - List of child ages (each 0-17, max 8 children)
+     * @returns {Promise<SkyscannerResponse>} Parsed response containing pricing and itinerary data
+     */
+    async getFlightPrices({
+        origin,
+        destination,
+        departDate = null,
+        returnDate = null,
+        cabinClass = CabinClass.ECONOMY,
+        adults = 1,
+        childAges = []
+    }) {
+        await this._initialize();
+
+        if (!departDate) {
+            departDate = new Date();
+        }
+
+        // Validate child ages
+        if (!childAges.every(age => age >= 0 && age < 18)) {
+            throw new Error("Child ages must be >= 0 and < 18");
+        }
+
+        // Validate dates
+        if (departDate instanceof Date && returnDate instanceof Date) {
+            if (returnDate < departDate) {
+                throw new Error("Return date cannot be past departure");
+            }
+        }
+
+        // Validate passenger counts
+        if (!(adults <= 8 && childAges.length <= 8)) {
+            throw new Error("Max 8 adults and 8 children");
+        }
+
+        // Validate cabin class for special searches
+        const specialValues = [SpecialTypes.ANYTIME, SpecialTypes.EVERYWHERE];
+        if ((specialValues.includes(departDate) || specialValues.includes(returnDate) || 
+             specialValues.includes(destination)) && cabinClass !== CabinClass.ECONOMY) {
+            throw new Error("To search for cabin class that's not economy enter departDate / returnDate and destination");
+        }
+
+        // Validate dates are not in the past
+        const now = new Date();
+        if ((departDate instanceof Date && departDate < now) || 
+            (returnDate instanceof Date && returnDate < now)) {
+            throw new Error("Depart date or return date cannot be in the past");
+        }
+
+        const jsonData = {
+            adults: adults,
+            childAges: childAges,
+            cabinClass: cabinClass,
+            legs: [
+                this._genLeg({ departDate, origin, destination }),
+            ],
+            options: null,
+        };
+
+        if (returnDate) {
+            const returnLeg = this._genLeg({
+                departDate: returnDate,
+                origin: destination,
+                destination: origin
+            });
+            jsonData.legs.push(returnLeg);
+        }
+
+        const customHeaders = {
+            ...this.headers,
+            "X-Skyscanner-Viewid": crypto.randomUUID(),
+            "Content-Type": "application/json; charset=UTF-8",
+            "Accept-Encoding": "gzip, deflate, br",
+        };
+
+        let req;
+        try {
+            req = await axios.post(config.UNIFIED_SEARCH_ENDPOINT, jsonData, {
+                ...this.axiosConfig,
+                headers: customHeaders
+            });
+        } catch (error) {
+            if (error.response && error.response.status === 403) {
+                throw new BannedWithCaptcha(
+                    "https://www.skyscanner.net" + error.response.data.redirect_to
+                );
+            }
+            throw error;
+        }
+
+        let data = req.data;
+
+        if (data.context.status === "complete") {
+            return new SkyscannerResponse(
+                data,
+                this._getSessionId(data),
+                jsonData,
+                origin,
+                destination
+            );
+        }
+
+        let retries = 0;
+        let sessionId = data.context.sessionId;
+
+        while (retries < this.maxRetries) {
+            await this._sleep(this.retryDelay * 1000);
+            const url = config.UNIFIED_SEARCH_ENDPOINT + sessionId;
+            
+            try {
+                req = await axios.get(url, {
+                    ...this.axiosConfig,
+                    headers: customHeaders
+                });
+            } catch (error) {
+                throw new Error(`Error while scraping flight, status_code: ${error.response?.status} response: ${error.response?.data}`);
+            }
+
+            data = req.data;
+
+            if (req.status !== 200) {
+                throw new Error(`Error while scraping flight, status_code: ${req.status} response: ${req.data}`);
+            }
+
+            if (data.context.status === "complete") {
+                return new SkyscannerResponse(
+                    data,
+                    this._getSessionId(data),
+                    jsonData,
+                    origin,
+                    destination
+                );
+            }
+            sessionId = data.context.sessionId;
+            retries += 1;
+        }
+
+        throw new AttemptsExhaustedIncompleteResponse();
+    }
+
+    /**
+     * Auto-suggest airports based on a query string.
+     * 
+     * @param {string} query - Text to search for airport names or codes
+     * @param {Date|null} departDate - Optional outbound date for context
+     * @param {Date|null} returnDate - Optional inbound date for context
+     * @returns {Promise<Airport[]>} List of suggested Airport objects
+     */
+    async searchAirports(query, departDate = null, returnDate = null) {
+        await this._initialize();
+
+        const params = {
+            query: query,
+            inboundDate: departDate ? this._formatDate(departDate) : "",
+            outboundDate: returnDate ? this._formatDate(returnDate) : "",
+        };
+
+        let req;
+        try {
+            req = await axios.get(config.SEARCH_ORIGIN_ENDPOINT, {
+                ...this.axiosConfig,
+                params
+            });
+        } catch (error) {
+            if (error.response && error.response.status === 403) {
+                throw new BannedWithCaptcha(
+                    "https://www.skyscanner.net" + error.response.data.redirect_to
+                );
+            }
+            throw error;
+        }
+
+        if (req.status !== 200) {
+            throw new GenericError(
+                `Error when scraping airports, code: ${req.status} text: ${req.data}`
+            );
+        }
+
+        const data = req.data;
+        return data.inputSuggest.map(e => new Airport(
+            e.presentation.title,
+            e.navigation.entityId,
+            e.navigation.relevantFlightParams.skyId
+        ));
+    }
+
+    /**
+     * Auto-suggest locations based on a query.
+     * 
+     * @param {string} query - Text to search for locations
+     * @returns {Promise<Location[]>} List of suggested Location objects
+     */
+    async searchLocations(query) {
+        await this._initialize();
+
+        const url = config.LOCATION_SEARCH_ENDPOINT
+            .replace('{locale}', this.locale)
+            .replace('{market}', this.market) + query;
+
+        const params = { autosuggestExp: "neighborhood_b" };
+
+        let req;
+        try {
+            req = await axios.get(url, {
+                ...this.axiosConfig,
+                params
+            });
+        } catch (error) {
+            if (error.response && error.response.status === 403) {
+                throw new BannedWithCaptcha(
+                    "https://www.skyscanner.net" + error.response.data.redirect_to
+                );
+            }
+            throw error;
+        }
+
+        if (req.status !== 200) {
+            throw new GenericError(
+                `Error when scraping locations, code: ${req.status} text: ${req.data}`
+            );
+        }
+
+        return req.data.map(location => new Location(
+            location.entity_name,
+            location.entity_id,
+            location.location
+        ));
+    }
+
+    /**
+     * Retrieve a single Airport by its IATA code.
+     * 
+     * @param {string} airportCode - Three-letter IATA code to look up
+     * @returns {Promise<Airport>} Matching Airport object
+     */
+    async getAirportByCode(airportCode) {
+        const airports = await this.searchAirports(airportCode);
+        for (const airport of airports) {
+            if (airport.skyId === airportCode) {
+                return airport;
+            }
+        }
+        throw new GenericError(`IATA code not found: ${airportCode}`);
+    }
+
+    /**
+     * Retrieve detailed information for a specific flight itinerary.
+     * 
+     * @param {string} itineraryId - Unique identifier for the itinerary
+     * @param {SkyscannerResponse} response - The response object from a flight search
+     * @returns {Promise<Object>} Parsed JSON response with itinerary details
+     */
+    async getItineraryDetails(itineraryId, response) {
+        await this._initialize();
+
+        const jsonData = {
+            itineraryId: itineraryId,
+            searchSessionId: response.sessionId,
+            featuresEnabled: ["FEATURES_ENABLED_ITINERARY_LEGACY_INFO"],
+            userPreferences: {
+                market: this.market,
+                currencyCode: this.currency,
+                locale: this.locale,
+            },
+            searchRequestDetails: {
+                adults: response.searchPayload.adults,
+                cabinClass: response.searchPayload.cabinClass,
+                legs: [],
+            },
+            options: {
+                totalCostOptions: {
+                    fareAttributeFilters: [
+                        "ATTRIBUTE_CABIN_BAGGAGE",
+                        "ATTRIBUTE_CHECKED_BAGGAGE",
+                    ]
+                }
+            },
+        };
+
+        if (response.searchPayload.childAges) {
+            jsonData.searchRequestDetails.childAges = response.searchPayload.childAges;
+        }
+
+        for (const leg of response.searchPayload.legs) {
+            const originId = leg.legOrigin?.entityId || leg.legOrigin;
+            const destinationId = leg.legDestination?.entityId || leg.legDestination;
+            const originIata = response.origin.entityId === originId 
+                ? response.origin.skyId 
+                : response.destination.skyId;
+            const destinationIata = response.destination.entityId === destinationId
+                ? response.destination.skyId
+                : response.origin.skyId;
+            const date = leg.dates;
+            
+            const res = {
+                originIata: originIata,
+                destinationIata: destinationIata,
+                date: {
+                    year: date.year,
+                    month: date.month,
+                    day: date.day,
+                },
+                addAlternativeOrigins: false,
+                addAlternativeDestinations: false,
+                originSkyscannerCode: originIata,
+                destinationSkyscannerCode: destinationIata,
+                originEntityId: "",
+                destinationEntityId: "",
+            };
+            jsonData.searchRequestDetails.legs.push(res);
+        }
+
+        const headers = {
+            "grpc-metadata-x-skyscanner-devicedetection-istablet": "false",
+            "grpc-metadata-x-skyscanner-devicedetection-ismobile": "true",
+            "grpc-metadata-x-skyscanner-channelid": "goandroid",
+            "grpc-metadata-x-skyscanner-viewid": crypto.randomUUID(),
+            "grpc-metadata-x-skyscanner-clientid": "skyscanner_app",
+            "grpc-metadata-x-skyscanner-client-type": "net.skyscanner.android.main",
+            "grpc-metadata-skyscanner-flights-config-session-id": crypto.randomUUID(),
+            "grpc-metadata-x-skyscanner-consent-information": "true",
+            "grpc-metadata-x-skyscanner-consent-adverts": "true",
+            "content-type": "application/json; charset=utf-8",
+            "accept-encoding": "gzip",
+        };
+
+        let req;
+        try {
+            req = await axios.post(config.ITINERARY_DETAILS_ENDPOINT, jsonData, {
+                ...this.axiosConfig,
+                headers: { ...this.headers, ...headers }
+            });
+        } catch (error) {
+            if (error.response && error.response.status === 403) {
+                throw new BannedWithCaptcha(
+                    "https://www.skyscanner.net" + error.response.data.redirect_to
+                );
+            }
+            throw error;
+        }
+
+        if (req.status !== 200) {
+            throw new GenericError(
+                `Error fetching itinerary details, code: ${req.status}, text: ${req.data}`
+            );
+        }
+
+        return req.data;
+    }
+
+    /**
+     * Parse a Skyscanner car rental URL and fetch rental options.
+     * 
+     * @param {string} url - Skyscanner car hire URL
+     * @returns {Promise<Object>} Car rental search results
+     */
+    async getCarRentalFromUrl(url) {
+        url = url.split("?")[0];
+        const args = url.split("/");
+
+        if (args.length < 14) {
+            throw new Error("URL not valid");
+        }
+
+        const isDriverOver25 = parseInt(args[8]) >= 25;
+        const origin = new Location("", args[9], "");
+        const destination = new Location("", args[10], "");
+        const departTime = new Date(args[11]);
+        const returnTime = new Date(args[12]);
+
+        return this.getCarRental({
+            origin,
+            departTime,
+            returnTime,
+            isDriverOver25,
+            destination
+        });
+    }
+
+    /**
+     * Search for car rental options between two locations and times.
+     * 
+     * @param {Object} params - Search parameters
+     * @param {Location|Coordinates|Airport} params.origin - Pickup location
+     * @param {Date} params.departTime - Pickup datetime
+     * @param {Date} params.returnTime - Drop-off datetime
+     * @param {Location|Coordinates|Airport|null} params.destination - Drop-off location (defaults to origin)
+     * @param {boolean} params.isDriverOver25 - Flag for driver age pricing threshold
+     * @returns {Promise<Object>} JSON response containing car rental group listings and metadata
+     */
+    async getCarRental({
+        origin,
+        departTime,
+        returnTime,
+        destination = null,
+        isDriverOver25 = true
+    }) {
+        await this._initialize();
+
+        if (!destination) {
+            destination = origin;
+        }
+
+        if (returnTime < departTime) {
+            throw new Error("Return time cannot be past depart time");
+        }
+
+        const now = new Date();
+        if (returnTime < now || departTime < now) {
+            throw new Error("Return or depart time cannot be in the past");
+        }
+
+        const firstLocation = origin instanceof Coordinates
+            ? `${origin.latitude},${origin.longitude}`
+            : origin.entityId;
+        const secondLocation = destination instanceof Coordinates
+            ? `${destination.latitude},${destination.longitude}`
+            : destination.entityId;
+
+        const ageValue = isDriverOver25 ? "30" : "21";
+        const firstDate = this._formatDateTime(departTime);
+        const secondDate = this._formatDateTime(returnTime);
+
+        const url = config.CAR_RENTAL_ENDPOINT
+            .replace('{first_location}', firstLocation)
+            .replace('{second_location}', secondLocation)
+            .replace('{driver_age}', ageValue)
+            .replace('{first_date}', firstDate)
+            .replace('{second_date}', secondDate)
+            .replace('{market}', this.market)
+            .replace('{currency}', this.currency)
+            .replace('{locale}', this.locale);
+
+        const params = {
+            group: "true",
+            sipp_map: "true",
+            channel: "android",
+            vndr_img_rounded: "true",
+            ranking_enable: "false",
+            reqn: "0",
+            version: "6.9",
+            include_location: "true",
+            city_search_enable: "true",
+        };
+
+        let lastCount = null;
+
+        for (let i = 0; i < this.maxRetries; i++) {
+            const req = await axios.get(url, {
+                ...this.axiosConfig,
+                params
+            });
+            const reqData = req.data;
+            params.reqn = String(parseInt(params.reqn) + 1);
+
+            const count = reqData.groups_count;
+            if (!lastCount) {
+                lastCount = count;
+                await this._sleep(this.retryDelay * 1000);
+                continue;
+            }
+
+            if (count === lastCount) {
+                return reqData;
+            }
+
+            lastCount = count;
+            await this._sleep(this.retryDelay * 1000);
+        }
+
+        throw new AttemptsExhaustedIncompleteResponse();
+    }
+
+    // Private helper methods
+
+    _getSessionId(data) {
+        if (!data.itineraries) {
+            return null;
+        }
+        return data.itineraries.context.sessionId;
+    }
+
+    _genLeg({ departDate = null, returnDate = null, origin = null, destination = null }) {
+        const res = {};
+        const date = departDate || returnDate;
+        
+        if (date instanceof Date) {
+            res.dates = {
+                "@type": "date",
+                year: date.getFullYear(),
+                month: date.getMonth() + 1,
+                day: date.getDate()
+            };
+        } else {
+            res.dates = { "@type": date };
+        }
+
+        if (origin instanceof Airport) {
+            res.legOrigin = { "@type": "entity", entityId: origin.entityId };
+        } else {
+            res.legOrigin = { "@type": origin };
+        }
+
+        if (destination instanceof Airport) {
+            res.legDestination = { "@type": "entity", entityId: destination.entityId };
+        } else {
+            res.legDestination = { "@type": destination };
+        }
+
+        res.placeOfStay = destination instanceof Airport
+            ? destination.entityId
+            : origin.entityId;
+
+        return res;
+    }
+
+    _formatDate(date) {
+        const year = date.getFullYear();
+        const month = String(date.getMonth() + 1).padStart(2, '0');
+        const day = String(date.getDate()).padStart(2, '0');
+        return `${year}-${month}-${day}`;
+    }
+
+    _formatDateTime(date) {
+        const year = date.getFullYear();
+        const month = String(date.getMonth() + 1).padStart(2, '0');
+        const day = String(date.getDate()).padStart(2, '0');
+        const hours = String(date.getHours()).padStart(2, '0');
+        const minutes = String(date.getMinutes()).padStart(2, '0');
+        return `${year}-${month}-${day}T${hours}:${minutes}`;
+    }
+
+    _sleep(ms) {
+        return new Promise(resolve => setTimeout(resolve, ms));
+    }
+}
+
+module.exports = SkyScanner;

package/src/types.js

@@ -0,0 +1,78 @@
+class Location {
+    /**
+     * Represents an auto-suggested location from the Skyscanner API.
+     * @param {string} entityName - Human-readable name of the location
+     * @param {string} entityId - Internal Skyscanner identifier for the location
+     * @param {string} rawLocation - Latitude and longitude as comma-separated string
+     */
+    constructor(entityName, entityId, rawLocation) {
+        this.entityName = entityName;
+        this.entityId = entityId;
+        this.location = rawLocation.split(',');
+    }
+}
+
+class Airport {
+    /**
+     * Represents an airport in the Skyscanner system.
+     * @param {string} title - The display name of the airport (e.g. "London Heathrow")
+     * @param {string} entityId - The internal Skyscanner entity ID for the airport
+     * @param {string} skyId - The IATA-style Skyscanner identifier (used in search requests)
+     */
+    constructor(title, entityId, skyId) {
+        this.title = title;
+        this.entityId = entityId;
+        this.skyId = skyId;
+    }
+}
+
+class SkyscannerResponse {
+    /**
+     * Represents the response from a Skyscanner flight search.
+     * @param {Object} json - The raw JSON response returned by Skyscanner
+     * @param {string} sessionId - The unique session identifier associated with the search
+     * @param {Object} searchPayload - The original payload used to perform the search request
+     * @param {Airport} origin - The airport from which the search was initiated
+     * @param {Airport} destination - The destination airport, if specified
+     */
+    constructor(json, sessionId, searchPayload, origin, destination = null) {
+        this.json = json;
+        this.sessionId = sessionId;
+        this.searchPayload = searchPayload;
+        this.origin = origin;
+        this.destination = destination;
+    }
+}
+
+class Coordinates {
+    /**
+     * Represents geographic coordinates.
+     * @param {number} latitude - Latitude coordinate
+     * @param {number} longitude - Longitude coordinate
+     */
+    constructor(latitude, longitude) {
+        this.latitude = latitude;
+        this.longitude = longitude;
+    }
+}
+
+const CabinClass = {
+    ECONOMY: "economy",
+    PREMIUM_ECONOMY: "premium_economy",
+    BUSINESS: "business",
+    FIRST: "first"
+};
+
+const SpecialTypes = {
+    ANYTIME: "anytime",
+    EVERYWHERE: "everywhere"
+};
+
+module.exports = {
+    Location,
+    Airport,
+    SkyscannerResponse,
+    Coordinates,
+    CabinClass,
+    SpecialTypes
+};