Flight Price Scraper — Compare Cheap Flights from Multiple Sources in One API Call

⭐ Useful? Leave a review — it takes 10 seconds and is the single biggest thing that helps other travel developers and price-comparison teams find this flight scraper.

A production-grade flight price scraper that compares fares across seven flight databases in one API call and returns a single, deduplicated, merged feed of the cheapest flights for any route and date. Pulls Google Flights, Kiwi.com, a cached price database (Travelpayouts), Ryanair, EasyJet, Wizz Air and Norwegian in parallel, matches the same physical flight across every source, and exposes bestPrice, cheapestSource, baggage policy, segment-level details and direct booking links per result. No airline OAuth, no GDS contract, no browser rendering — pure HTTP, JSON or CSV export, ready for Python, Node.js, Zapier, Make.com or any data warehouse. Built for travel aggregators, fare-alert products, OTA startups, corporate-travel teams and data analysts that need accurate multi-source flight price comparison at scale.

What this flight scraper does

Given an origin IATA code, a destination IATA code and a date, this flight scraper queries seven independent flight search systems concurrently and returns structured flight data with a price breakdown per source. Every run hits the sources live — airfare prices are the most volatile retail price on the internet, moving every few minutes during the day, so the scraper never caches. You can search one-way or round-trip, filter by cabin class, pick any ISO currency (USD, EUR, MXN, GBP, BRL, JPY…) and cap the result count with maxFlights. The merger logic inside the actor flattens and deduplicates results by flight number + departure time, then sorts ascending by the cheapest price discovered across any source.

Because the whole pipeline runs over raw HTTP (no Puppeteer, no Playwright, no Chromium, no Selenium), the actor is an order of magnitude cheaper and faster than browser-based flight scrapers. A typical one-way search across all seven sources finishes in about 2 to 4 seconds. Output is available as JSON, CSV, Excel or XML directly from the Apify console or via the Apify API.

Data fields the flight scraper extracts

The output is a flat JSON document per unique flight. Fields are grouped below for clarity.

Price comparison fields

Field	Description
prices	Object mapping each source that found this flight to its price in the selected currency
bestPrice	Lowest numeric price across every source that returned this flight
cheapestSource	Identifier of the source that had the lowest price (e.g. kiwi, google, ryanair)
sourcesFound	Array of source identifiers that found and returned this flight
currency	ISO currency code used for every price on the row

Schedule and route fields

Field	Description
airline	Primary carrier or multi-airline label (e.g. American Airlines, Ryanair + Wizz Air)
departTime	Departure date and time in ISO 8601
arriveTime	Arrival date and time in ISO 8601
duration	Total trip duration (e.g. 9h 50m)
stops	Number of stops — 0 means nonstop
from	Object: airport (IATA), name, city, country
to	Object: airport (IATA), name, city, country
departDate	Departure date in YYYY-MM-DD

Segment, layover and baggage fields

Field	Description
segments	Array of per-leg details: flightCode, airline, from, to, departure, arrival, duration, cabinClass
layovers	Per-layover details: airport, city, duration, baggage recheck required, terminal change
baggage	Object: includedHandBags, includedCheckedBags, includedPersonalItem
isSelfTransfer	Boolean — true when separate tickets are combined and the passenger must recheck bags
travelHack	Hidden-city, virtual-interlining or throwaway-ticket indicator when the source surfaces it
highlights	Whether the flight is tagged as cheapest, fastest or best by any source

Booking and metadata fields

Field	Description
links	Direct booking URLs keyed by source (e.g. googleFlights, kiwi, ryanair)
scrapedAt	ISO timestamp of when the record was produced by this actor

Use cases for this flight data API

• Build a fare-alert product — Run the scraper on a schedule against the routes your subscribers care about and push a notification whenever bestPrice drops below their threshold. Everything you need (price per source, cheapest source, booking link) is already in the payload.
• Power a price-comparison site or Chrome extension — Skip the cost of ten independent scrapers and 10 sets of blocks. Hit this actor once, surface prices as a side-by-side table and link users straight to each source's booking page.
• Corporate-travel pre-booking audits — Give finance a daily CSV of the cheapest economy and business fares on the ten routes your road warriors fly most, so they can audit whether the agency is really booking the cheapest option.
• Market research for airlines and OTAs — Track how a carrier's price moves versus low-cost competitors on specific city pairs over weeks. The scraper gives you aligned timestamps across every source in one run.
• Feed a dynamic-pricing model — Use the scraper as a daily data ingestion step for an ML pipeline that predicts fare movement on routes your product sells.
• Travel deal newsletter / social media bot — Find flights where bestPrice is more than 30% below the median for the route, include the booking link, and auto-post to your audience.

How to use this flight scraper

The actor supports three common input shapes. All the examples below are copy-pasteable into the Apify input form.

One-way flight search

{
    "origin": "LAX",
    "destination": "JFK",
    "departDate": "2026-04-25",
    "currency": "USD",
    "maxFlights": 20
}

Round-trip flight search with cabin class

{
    "origin": "MEX",
    "destination": "EZE",
    "departDate": "2026-04-25",
    "returnDate": "2026-05-05",
    "adults": 1,
    "cabinClass": "ECONOMY",
    "currency": "MXN",
    "maxFlights": 50
}

Business-class multi-passenger flight search

{
    "origin": "LHR",
    "destination": "SIN",
    "departDate": "2026-07-10",
    "returnDate": "2026-07-20",
    "adults": 2,
    "cabinClass": "BUSINESS",
    "currency": "GBP",
    "maxFlights": 30
}

Supported cabin classes: ECONOMY, PREMIUM_ECONOMY, BUSINESS, FIRST.

Input parameters

Parameter	Type	Default	Description
origin	string	"LAX"	Origin airport IATA code (e.g. LAX, JFK, LHR, MTY)
destination	string	"JFK"	Destination airport IATA code (e.g. JFK, EZE, CDG)
departDate	string	"2026-04-25"	Departure date in YYYY-MM-DD format
returnDate	string	—	Return date YYYY-MM-DD. Omit for one-way.
adults	integer	1	Number of adult passengers (1–9)
cabinClass	string	"ECONOMY"	ECONOMY, PREMIUM_ECONOMY, BUSINESS, or FIRST
currency	string	"USD"	ISO currency code used to price every source (USD, EUR, MXN, GBP, BRL, JPY…)
maxFlights	integer	50	Maximum number of merged flights returned after deduplication

Output example (JSON)

{
    "prices": {
        "google": 409,
        "kiwi": 380,
        "travelpayouts": 130
    },
    "bestPrice": 130,
    "cheapestSource": "travelpayouts",
    "sourcesFound": ["google", "kiwi", "travelpayouts"],
    "currency": "USD",
    "airline": "American Airlines",
    "departTime": "2026-04-25T06:00:00",
    "arriveTime": "2026-04-25T14:32:00",
    "duration": "5h 32m",
    "stops": 0,
    "from": {
        "airport": "LAX",
        "city": "Los Angeles",
        "country": "United States"
    },
    "to": {
        "airport": "JFK",
        "city": "New York",
        "country": "United States"
    },
    "segments": [
        {
            "flightCode": "AA 123",
            "airline": "American Airlines",
            "from": "LAX",
            "to": "JFK",
            "departure": "2026-04-25T06:00:00",
            "arrival": "2026-04-25T14:32:00",
            "duration": "5h 32m",
            "cabinClass": "ECONOMY"
        }
    ],
    "baggage": {
        "includedHandBags": 1,
        "includedCheckedBags": 0,
        "includedPersonalItem": 1
    },
    "links": {
        "googleFlights": "https://www.google.com/travel/flights?q=LAX+JFK+2026-04-25",
        "kiwi": "https://www.kiwi.com/en/search/results/..."
    },
    "scrapedAt": "2026-04-25T16:45:42.209Z"
}

Export the full dataset as CSV, Excel, JSON or XML from the Apify console run page, or pull it programmatically via the Apify API.

How to call this flight scraper from your code

From the Apify API (curl)

curl -X POST 'https://api.apify.com/v2/acts/makework36~flight-price-scraper/run-sync-get-dataset-items?token=YOUR_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{
    "origin": "MEX",
    "destination": "MAD",
    "departDate": "2026-06-10",
    "returnDate": "2026-06-25",
    "adults": 1,
    "currency": "EUR",
    "maxFlights": 30
  }'

From Python (apify-client)

from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("makework36/flight-price-scraper").call(run_input={
    "origin": "JFK",
    "destination": "CDG",
    "departDate": "2026-07-01",
    "returnDate": "2026-07-10",
    "adults": 1,
    "cabinClass": "ECONOMY",
    "currency": "USD",
    "maxFlights": 40,
})

for flight in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(
        flight["airline"],
        flight["bestPrice"],
        flight["cheapestSource"],
        flight["duration"],
        flight["stops"],
    )

From Node.js (apify-client)

import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: 'YOUR_APIFY_TOKEN' });

const run = await client.actor('makework36/flight-price-scraper').call({
  origin: 'MEX',
  destination: 'EZE',
  departDate: '2026-08-12',
  returnDate: '2026-08-22',
  adults: 1,
  cabinClass: 'ECONOMY',
  currency: 'MXN',
  maxFlights: 50,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.table(items.map((f) => ({
  airline: f.airline,
  best: f.bestPrice,
  source: f.cheapestSource,
  duration: f.duration,
  stops: f.stops,
})));

Export to CSV

From the console run page → Export → CSV. Or via the dataset API:

https://api.apify.com/v2/datasets/DATASET_ID/items?format=csv&token=YOUR_TOKEN

Performance and cost

• 2 to 4 seconds per search — all seven sources run in parallel, not sequentially.
• ~$0.0003 per search — pay-per-event pricing; no browser overhead inflating compute.
• 128 MB memory tier is enough for the default maxFlights=50. Bump to 256 MB only if you raise maxFlights above 100.
• Apify Proxy rotates IPs automatically — no proxy setup, no block management on your side.
• Deduplicated and sorted — you receive a clean, merged feed, not seven raw result sets to stitch together yourself.

Flight scraper comparison — how this compares to other flight scrapers on Apify Store

There are several flight scrapers on Apify Store. Here is how this multi-source flight scraper stacks up on the dimensions that actually matter to production workflows: coverage, completeness, per-result cost and developer ergonomics. All competitors are anonymized because pricing models and field sets change week to week.

Feature	This scraper	Single-source flight scraper (Google Flights only)	Airline-specific scraper (one low-cost carrier)	Browser-based flight scraper with residential proxy
Sources queried per run	7 (Google Flights, Kiwi, cached prices DB, Ryanair, EasyJet, Wizz Air, Norwegian)	1	1	1–2
Price comparison in output	Yes (prices map + cheapestSource)	No	No	No
Scraping engine	Raw HTTP	Raw HTTP	Raw HTTP	Headless browser + residential proxy
Latency per search	2–4 s	2–3 s	2–3 s	10–30 s
Price per search	~$0.0003	Similar	Similar	10–50× higher
Segment details	Yes (per-leg)	Partial	Yes	Yes
Layover and baggage recheck	Yes	Partial	N/A	Partial
Baggage allowance (hand / checked / personal)	Yes	Partial	Yes	Partial
Direct booking links per source	Yes	Single link	Single link	Single link
Self-transfer / virtual interlining flag	Yes	No	No	No
Multi-currency output	Yes (any ISO)	Limited	Limited	Yes
Cabin class filter	Yes	Yes	Limited	Yes
Round-trip + one-way	Yes	Yes	Round-trip sometimes missing	Yes
Export formats	JSON / CSV / Excel / XML	JSON / CSV	JSON	JSON / CSV
Code examples in README	Python / Node.js / curl / PHP / Go / Ruby	Typically none	Typically none	Typically none
MCP-compatible alternative	Hotel MCP server, Airbnb MCP server, Reddit MCP server on same account	Rare	Rare	Rare

The honest take: if you only ever need Google Flights and you do not care which carrier has the cheapest fare, a single-source flight scraper will do. If you need an accurate multi-source price comparison, a fallback when one source blocks, and a single merged output to ship to downstream consumers, this scraper is the one to pick. The cost difference per search is negligible; the ops cost of running and reconciling seven scrapers yourself is not.

Step-by-step tutorial — your first flight price comparison run in 3 minutes

1. Sign up for Apify — go to apify.com and create a free account. You get a $5 trial credit, enough for thousands of searches on this actor.
2. Open this actor — click Flight Price Scraper → Try for free.
3. Fill the input form — origin and destination IATA codes, departDate in YYYY-MM-DD format, optionally a returnDate, pick a currency, leave maxFlights at 50 for the first run.
4. Click Start — the run will finish in 2 to 4 seconds. Open the Dataset tab.
5. Compare the output — each row has a prices object showing every source that found the flight, plus bestPrice and cheapestSource. Click Export to download JSON, CSV, Excel or XML.
6. Schedule it — click Schedules → Create new schedule to re-run the same route every hour, day or week. Each run writes to a fresh dataset you can pull via the API.
7. Wire it up — copy a code example above into a small Python or Node.js script and point the dataset at your warehouse, Airtable, Slack webhook or PostgreSQL table.

That is the entire setup. No airline keys, no GDS contract, no proxy pool to manage.

Advanced usage patterns

Pattern 1 — fare alerts for a list of routes

Define a table of (origin, destination, departDate, threshold). On a schedule, run the actor once per row and compare bestPrice against threshold. When the scraped price dips below the user's threshold, send an email or push notification with the links object so the customer can click straight through to the cheapest source. Because the scraper already returns the cheapest source and its direct booking link, this pattern is a few dozen lines of code — most of the hard work (multi-source querying, deduplication, sorting) lives inside the actor.

Pattern 2 — daily corporate-travel price audit

Corporate-travel agencies often book through a single GDS and quietly charge a markup. Set up a daily scheduled run over the ten routes your company flies most, dump the full prices map into Snowflake or BigQuery, and build a Looker dashboard that visualizes "agency price vs. scraped cheapest price, route over time". This is one of the quickest ROI wins for finance teams; one mid-size company recovered the cost of the scraper hundreds of times over in its first month.

Pattern 3 — virtual interlining research

Virtual interlining — combining tickets from different airlines into one itinerary — often produces the absolute cheapest routes on long-haul pairs. Pull the scraper's output for a route and filter where isSelfTransfer = true. You will typically see the cheapest fares here, but with a baggage recheck caveat that's explicitly flagged for you in the output. Perfect for "cheap flight hackers" content channels or deal sites that specialize in unconventional routings.

Pattern 4 — low-cost carrier market share

Filter the scraper's output by airline and count how often a low-cost carrier (Ryanair, EasyJet, Wizz Air, Norwegian, Frontier, Spirit, Volaris, VivaAerobus…) appears as cheapestSource on each route. Roll this up by origin region over weeks and you have a proxy for where low-cost market share is growing fastest — a useful signal for travel-industry analysts and equity research teams.

Pattern 5 — calendar-view price heatmap

Loop through every departure date in the next 30, 60 or 90 days, one scraper run per date. Store each bestPrice. Plot as a heatmap per route and you have a cheap-days calendar you can publish on your own site or sell as an OTA-style feature. Because one run is about $0.0003, a 90-day sweep across 10 routes is still under a dollar.

More code examples

PHP

<?php
$token = 'YOUR_APIFY_TOKEN';
$payload = json_encode([
    'origin' => 'MEX',
    'destination' => 'LHR',
    'departDate' => '2026-09-10',
    'returnDate' => '2026-09-25',
    'adults' => 1,
    'currency' => 'EUR',
    'maxFlights' => 25,
]);

$ch = curl_init("https://api.apify.com/v2/acts/makework36~flight-price-scraper/run-sync-get-dataset-items?token=$token");
curl_setopt($ch, CURLOPT_POST, 1);
curl_setopt($ch, CURLOPT_POSTFIELDS, $payload);
curl_setopt($ch, CURLOPT_HTTPHEADER, ['Content-Type: application/json']);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
$response = curl_exec($ch);
$flights = json_decode($response, true);
foreach ($flights as $f) {
    echo $f['airline'] . " — €" . $f['bestPrice'] . " via " . $f['cheapestSource'] . "\n";
}

Ruby

require 'net/http'
require 'json'

token = 'YOUR_APIFY_TOKEN'
uri = URI("https://api.apify.com/v2/acts/makework36~flight-price-scraper/run-sync-get-dataset-items?token=#{token}")
payload = {
  origin: 'SFO',
  destination: 'NRT',
  departDate: '2026-10-01',
  returnDate: '2026-10-14',
  adults: 1,
  currency: 'USD',
  maxFlights: 30
}.to_json

req = Net::HTTP::Post.new(uri, 'Content-Type' => 'application/json')
req.body = payload
flights = JSON.parse(Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |h| h.request(req) }.body)
flights.each { |f| puts "#{f['airline']} — $#{f['bestPrice']} (#{f['cheapestSource']})" }

Go

package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "io"
    "net/http"
)

func main() {
    token := "YOUR_APIFY_TOKEN"
    url := "https://api.apify.com/v2/acts/makework36~flight-price-scraper/run-sync-get-dataset-items?token=" + token
    payload := map[string]any{
        "origin":      "GRU",
        "destination": "MIA",
        "departDate":  "2026-11-01",
        "returnDate":  "2026-11-10",
        "adults":      1,
        "currency":    "BRL",
        "maxFlights":  40,
    }
    body, _ := json.Marshal(payload)
    resp, _ := http.Post(url, "application/json", bytes.NewBuffer(body))
    defer resp.Body.Close()
    out, _ := io.ReadAll(resp.Body)
    var flights []map[string]any
    json.Unmarshal(out, &flights)
    for _, f := range flights {
        fmt.Printf("%s — R$%v (%s)\n", f["airline"], f["bestPrice"], f["cheapestSource"])
    }
}

Zapier and Make.com (no-code)

Both Zapier and Make.com have an official Apify integration. Typical setup:

1. Trigger — Schedule, webhook, new row in a Google Sheet of routes, or a new user in your fare-alert product.
2. Action — Apify → Run an Actor synchronously → select makework36/flight-price-scraper → pass JSON input.
3. Downstream — Write each flight to Airtable, Google Sheets, Notion, a Slack channel, a Discord webhook, a Postmark or Resend email, or your own API endpoint.

The output is already clean JSON, so no formatter step is required — just map bestPrice, airline, duration, stops and links.googleFlights into the downstream action.

Troubleshooting

Empty dataset — no flights returned

• Verify departDate (and returnDate) are in the future and in YYYY-MM-DD format.
• Check both IATA codes. LHR is valid, London Heathrow is not. Use iata.org code search when in doubt.
• On very obscure regional pairs, one or two sources may have zero coverage — that is expected. Check the logs for per-source counts.

All prices come from only one source Some routes (e.g. intra-African or niche regional hops) are only served by one or two of the seven sources. The scraper still works and returns the real cheapest price; sourcesFound will simply be shorter.

bestPrice looks too low vs. the airline's own site That usually means a hidden-city, self-transfer or virtual-interlining fare. Check isSelfTransfer and travelHack. These are legitimate fares, but read the airline's rules carefully before booking: skipping a leg can void the remaining segments.

Rate-limited or blocked IPs The Apify Proxy rotates automatically. For very large sweeps (hundreds of routes in a single schedule slot), split into batches of 50 and stagger them 1–2 minutes apart.

Prices in the wrong currency Always set currency explicitly. If you omit it, the default is USD. Some sources also return a localized currency for certain geographies; the merger converts everything into the currency field you set.

Timezones in departTime / arriveTime Times are local to the airport, in ISO 8601 without an offset (this matches the displayed time on booking sites). If you need UTC, combine with an IATA-to-timezone lookup table.

Pricing

Pay-per-event model:

• ~$0.0003 per flight price search (as of 2026-04-22), measured per merged result set across all seven sources.
• Apify gives every new user a $5 free trial, enough to run thousands of searches while evaluating.
• No subscription, no minimum, no egress fees, no rate cap.

Plan guidance

Apify plan	Recommended for	Notes
FREE (trial credit)	First-time evaluation, hobby projects	~$5 credit → thousands of searches
STARTER	Personal fare-alert bots, small side projects, MVP OTAs	Monthly credit + proxy included
SCALE	Production fare-alert products, corporate-travel dashboards, small OTAs	Higher concurrency, more proxy bandwidth
BUSINESS	B2B fare feeds, multi-tenant SaaS, travel agencies	SLAs and priority support
ENTERPRISE / DIAMOND	Large OTAs, airlines benchmarking competitors, enterprise data teams	Dedicated resources, custom terms

FAQ

Do I need an airline API key, a GDS contract or a Kiwi.com Affiliate account? No. This flight scraper reads publicly available search result pages and public fare APIs — no login, no OAuth, no airline contract required. You only need an Apify account and an API token.

How many sources does it actually query? Seven source groups: Google Flights, Kiwi.com, a cached price database (via Travelpayouts), Ryanair, EasyJet, Wizz Air and Norwegian. All seven run in parallel inside the actor.

What airport codes are supported? Any valid 3-letter IATA code: JFK, LAX, LHR, CDG, NRT, MTY, EZE, MEX, TRC, PVG, SIN, DXB, and so on. Small regional airports are supported too, subject to each underlying source's coverage.

Can I search in other currencies? Yes. Set currency to any ISO code: USD, EUR, MXN, GBP, BRL, JPY, INR, AUD, CAD, CHF, ZAR, AED, HKD, and so on. The merger normalizes every source into the currency you request.

Why do different sources show different prices for the same flight? Each source has different airline agreements, distribution fees, markups and, for OTAs, affiliate margin. That is the entire point of a multi-source flight price comparison — you see who is genuinely cheapest on this exact flight right now.

What is self-transfer and when should I care? isSelfTransfer = true means separate tickets are combined into one itinerary. You must collect your bags and check in again at the connection airport. Cheaper fare, but a missed connection is the passenger's problem, not the airline's. Flag this clearly to users in any consumer product.

How often should I run this for fare monitoring? Once or twice per day is plenty for most routes. Serious deal-hunters run hourly on hot routes. Running more often than every 15 minutes is overkill and rarely surfaces new prices.

Do you have a scraper for hotels and vacation rentals? Yes. See Related scrapers below — the same Apify account publishes Airbnb, Booking.com, Vrbo and hotel-price scrapers with consistent output shapes and pricing models.

Can I get seat availability or seat maps? Not in the current version — the actor focuses on price and schedule. Seat maps and per-fare availability are on the roadmap; leave a request on the actor issues tab to prioritize.

Can I filter by number of stops or max duration? Not as input parameters yet. Post-process the dataset with .filter(f => f.stops === 0 && parseDuration(f.duration) < 720) — the fields are already in the output. Native filters are on the roadmap.

Changelog

• v0.3 (2026-04-22) — SEO-friendly rewrite of the README, explicit source list, code examples in Python, Node.js, curl, PHP, Ruby and Go, expanded troubleshooting and FAQ. No breaking API changes.
• v0.2 (2026-04-10) — Added Wizz Air, Norwegian and EasyJet sources. Merger now tracks cheapestSource and exposes a per-source prices map.
• v0.1 (2026-03-25) — Initial release with Google Flights, Kiwi and Travelpayouts.

Related scrapers

• Airbnb Price Scraper — Fast HTTP, Coordinates Included — Search Airbnb listings with price, rating, Superhost badge and GPS.
• Booking.com Hotel Scraper — Hotel rates and availability by city and date.
• VRBO Scraper — Cracked Mobile GraphQL — Vacation-rental prices from VRBO with baggage-free HTTP calls.
• Hotel Price Scraper — Multi-source — Hotel prices compared across multiple sources in one call.
• Reddit MCP Server — Claude, ChatGPT, Cursor — Reddit data as MCP tools for AI agents.
• Trustpilot Reviews Scraper — Reviews, ratings and business search on Trustpilot.

Legal and ethics note

This flight scraper reads data that is publicly visible to any user with a browser — flight schedules, fares and booking pages that airlines and OTAs publish to the open web. We do not bypass paywalls, logins, CAPTCHAs behind accounts, or scrape private customer data. Per-source terms of service vary; consult legal counsel for your specific use case and jurisdiction, especially if you plan to resell the data or build a commercial product on top of it.

For context and definitions around travel metasearch, public-data APIs and flight pricing, see IATA.org, the US DOT Bureau of Transportation Statistics and OAG's aviation-data glossary.

---

🙏 Ran this flight scraper successfully? Leaving a review helps the Apify algorithm surface this actor to other travel developers and price-comparison teams. Much appreciated.