# Skyscanner Route Intelligence Scraper (`apt_marble/skyscanner-route-intelligence-scraper`) Actor

Profile any flight route from Skyscanner: the airlines flying it non-stop, flights per week, typical flight time, cheapest month, a twelve-month price curve, and what the same trip costs from nearby airports. One row per route per market, with several countries compared in one run.

- **URL**: https://apify.com/apt\_marble/skyscanner-route-intelligence-scraper.md
- **Developed by:** [Hamza](https://apify.com/apt_marble) (community)
- **Categories:** Travel
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $15.00 / 1,000 route profile collecteds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## Skyscanner Route Intelligence Scraper

Turn any city pair into a route-economics profile. For every route you name — or every
route Skyscanner publishes, if you'd rather sweep — you get the airlines that fly it
non-stop, how many flights a week it carries, how long it takes, what it costs, which
month is cheapest, how the price moves across the year, and what the same trip costs
from the other airports serving the same city. One clean row per route per market,
ready for a spreadsheet or a model. No account and no login are needed — just run it.

***

### What you can do with it

- **Size a route before you fly it.** Weekly frequency, the non-stop airline roster and
  the typical fare tell you how contested a city pair already is, and at what price.
- **Find the gap in an airport's catchment.** The nearby-airport comparison shows what
  the same city costs from LGA, EWR and JFK — and how far each one really is from the
  centre — so you can see where a catchment is leaking.
- **Build a seasonality model.** Twelve months of cheapest prices per route, per market,
  is a ready-made seasonal curve for pricing, capacity or campaign planning.
- **Compare markets you sell into.** The same route is a different product in different
  countries: different currency, different fares, and often a different cheapest month.
  Collect several countries in one run and put them side by side — every result also says
  whether its prices are for one direction or for the return trip, because that differs by
  country too and it is the one thing that makes two prices incomparable.
- **Sweep a whole network.** Point it at a departure airport and let it work through
  every route published from there, then filter to the ones with real traffic.
- **Publish route content at scale.** Flight times and airline lists as structured fields
  for every route, plus booking-lead-time advice and the destination's airport count on the
  English-language storefronts (see Limits).

***

### What you get

One result per route per market. Abridged real example — the London → New York profile
as the Indian market sees it:

```json
{
  "route": "LOND > NYCA",
  "originCode": "LOND",
  "destinationCode": "NYCA",
  "originName": "London",
  "destinationName": "New York",
  "market": "IN",
  "currency": "INR",
  "cheapestPrice": 27470,
  "priceTripType": "one_way",
  "cheapestPriceTripType": "one_way",
  "monthlyPriceTripType": "one_way",
  "nearbyAirportPriceTripType": "one_way",
  "cheapestMonth": "November",
  "cheapestMonthByPrice": "2026-11",
  "cheapestMonthPrice": 27470,
  "dearestMonthByPrice": "2026-08",
  "dearestMonthPrice": 39434,
  "flightsPerWeek": 1285,
  "averageFlightTime": "7 hrs, 60 mins",
  "averageFlightTimeMinutes": 480,
  "mostPopularAirline": "Iberia",
  "mostPopularAirlineCode": "IB",
  "directAirlineCount": 26,
  "directAirlines": [
    { "name": "Aer Lingus",  "code": "EI", "isPopularOnThisRoute": true  },
    { "name": "Air Canada",  "code": "AC", "isPopularOnThisRoute": false },
    { "name": "Air France",  "code": "AF", "isPopularOnThisRoute": false }
  ],
  "nearbyAirportCount": 6,
  "cheapestNearbyAirport": "JFK",
  "cheapestNearbyAirportPrice": 27470,
  "nearbyAirports": [
    { "airportCode": "LGA", "airportName": "New York LaGuardia",
      "distance": 13, "distanceUnit": "km", "isClosest": true,
      "cheapestCarrier": "Ryanair",  "cheapestPrice": 36178, "tripType": "one_way" },
    { "airportCode": "EWR", "airportName": "New York Newark",
      "distance": 14, "distanceUnit": "km", "isClosest": false,
      "cheapestCarrier": "Wizz Air", "cheapestPrice": 31697, "tripType": "one_way" }
  ],
  "monthlyPriceCurve": [
    { "month": "2026-08", "monthName": "August",    "price": 39434,
      "tripType": "one_way", "currency": "INR" },
    { "month": "2026-09", "monthName": "September", "price": 31921,
      "tripType": "one_way", "currency": "INR" }
  ],
  "exampleFares": [
    { "departureDate": "2026-11-29", "tripType": "one_way", "price": 27470,
      "airlines": ["Ryanair"], "airlineCodes": ["FR"],
      "fromAirport": "STN", "toAirport": "JFK", "isDirect": false }
  ],
  "bookAheadDays": 40,
  "airportsServingDestination": 6,
  "writtenAnswerFiguresAvailable": true,
  "collectedAt": "2026-08-16T12:00:00.000Z"
}
```

The full result carries more: every one of the 26 direct airlines, all six nearby
airports, all twelve months, up to 60 priced examples, the published questions and
answers for the route, and the provenance fields listed further down.

**Read `priceTripType` before you compare two prices.** The same London → New York route,
collected at the same moment, is priced one way on the Indian storefront (₹ 27,470) and as
a return trip on the German one (348 €). The numbers look directly comparable and are not:
one of them buys twice the travel. Every price on the result is labelled — the headline,
each of the twelve months, each alternative airport and each priced example — so the two
kinds never get averaged together by accident.

***

### Input reference

| Field | Type | Default | What it does |
| --- | --- | --- | --- |
| `routes` | list of text | `["LON-NYC"]` | The city pairs to profile, one per line. Two place codes — a city code like `LON`, `NYC`, `PAR`, or an airport code like `LHR`, `JFK`, `CDG`. `LON-NYC`, `LHR > JFK` and `CDG to BCN` all work. A Skyscanner route address is accepted too: the two places are taken from it and the route is then collected for the `market` you chose, which may be a different country from the address you pasted — the run says so at the start when that happens. |
| `market` | choice | `GB` | The country you are selling into. Skyscanner runs a separate storefront per country and they are genuinely different — different currency, different fares, often a different cheapest month, and some price a one-way trip where others price the return (see `priceTripType`). Two fields, `bookAheadDays` and `airportsServingDestination`, come back only on the English-language storefronts — see Limits. |
| `compareMarkets` | multi-choice | empty | Collect the same routes for extra countries too, one result per route per market. Up to 6 extras. |
| `findRoutesForMe` | true/false | `false` | Work through the routes Skyscanner publishes for the chosen market instead of listing them all yourself. |
| `seedOrigins` | list of text | empty | With discovery on: keep only routes departing from these places, e.g. `LHR`, `LGW`, `STN`. |
| `seedDestinations` | list of text | empty | With discovery on: keep only routes arriving at these places, e.g. `JFK`, `EWR`. |
| `maxRoutes` | number (1–2000) | `25` | The most routes in one run, counting both the ones you listed and the ones found for you. |
| `includeNearbyAirports` | true/false | `true` | Add the alternative-airport comparison. Charged separately — see pricing. |
| `includeMonthlyPrices` | true/false | `true` | Add the twelve-month cheapest-price curve. |
| `includeDeals` | true/false | `true` | Add the priced example trips, each with a direct link and its own `tripType` — one-way on some storefronts, return on others. |
| `includeFaqs` | true/false | `true` | Add the questions and answers Skyscanner publishes for the route. |
| `minFlightsPerWeek` | number (0–200000) | `0` | Keep only routes carrying at least this many flights a week. |
| `minDirectAirlines` | number (0–200) | `0` | Keep only routes flown non-stop by at least this many airlines. Set to 1 to exclude connection-only pairs. |
| `onlyRoutesWithAPrice` | true/false | `false` | Drop routes with no published headline price. |
| `onlyRequestedMarket` | true/false | `false` | Drop results that came back labelled with a market other than the one you chose. |

***

### Output fields

| Field | What it is |
| --- | --- |
| `routeKey`, `route` | Stable identity for the route and market, and a readable label. |
| `originCode`, `destinationCode` | The two places, as Skyscanner identifies them. |
| `originName`, `destinationName`, `originCountry`, `destinationCountry` | Their published names. |
| `marketRequested`, `marketRequestedName` | The market you asked for. |
| `market`, `marketMatchesRequested` | The market that actually answered, and whether it is the one you asked for. |
| `currency`, `currencyConfirmed`, `language` | The currency the figures are in, whether it was stated outright, and the language the text is in. |
| `cheapestPrice`, `cheapestPriceFormatted`, `cheapestPriceUrl` | The headline lowest price, as a number, as displayed, and a link to it. |
| `priceTripType` | What the prices on this result buy: `one_way` or `return`. Read this before comparing two results — it differs by country. `null` when the source did not say, or when its own labels disagree; nothing is assumed. |
| `cheapestPriceTripType`, `monthlyPriceTripType`, `nearbyAirportPriceTripType` | The same answer for each group of prices separately: the headline figure, the twelve-month curve, and the alternative-airport comparison. |
| `cheapestMonth` | The headline cheapest month. |
| `cheapestMonthStatement` | Skyscanner's own written answer to the same question — sometimes a different month (see Limits). |
| `cheapestMonthByPrice`, `cheapestMonthByPriceName`, `cheapestMonthPrice` | The cheapest month worked out from the published monthly prices themselves. |
| `dearestMonthByPrice`, `dearestMonthPrice` | The most expensive month, likewise. |
| `monthsWithAPublishedPrice` | How many of the twelve months actually carry a price. |
| `averageFlightTime`, `averageFlightTimeMinutes` | Typical flight time, as published and in minutes. |
| `averageFlightTimeIsRounded` | True when the published figure is a rounded one (see Limits). |
| `flightsPerWeek` | Weekly frequency on the route. |
| `bookAheadDays` | How far ahead Skyscanner says to book this route. English-language storefronts only — see Limits. |
| `airportsServingDestination` | How many airports serve the destination city. English-language storefronts only — see Limits. |
| `writtenAnswerFiguresAvailable` | Whether the two figures above could be taken from this route's written answers at all. `false` on a storefront that publishes those answers in another language — where both fields are empty for every route, rather than unpublished for this one. `null` when the written answers were not collected (you switched them off, or the result is partial). |
| `mostPopularAirline`, `mostPopularAirlineCode` | The most-flown carrier on the route. |
| `directAirlineCount`, `directAirlines[]` | Every airline flying it non-stop: `name`, `code`, `isPopularOnThisRoute`, `airlineUrl`. |
| `nearbyAirportsIncluded`, `nearbyAirportCount`, `nearbyAirportsWithAPrice` | Whether the comparison was collected, how many airports it covers, and how many of them are priced. |
| `nearbyAirportDistanceUnit` | `km` or `mi` — read from the source, because it changes by market. |
| `cheapestNearbyAirport`, `cheapestNearbyAirportPrice` | The cheapest airport into the destination city, and its price. |
| `nearbyAirports[]` | Per airport: `airportCode`, `airportName`, `distance`, `distanceUnit`, `isClosest`, `isCheapest`, `cheapestCarrier`, `cheapestPrice`, `cheapestPriceFormatted`, `tripType`, `currency`. |
| `monthlyPriceCurve[]` | Per month: `month`, `monthName`, `price`, `priceFormatted`, `tripType`, `currency`, `monthUrl`. |
| `exampleFareCount`, `exampleFares[]` | Priced examples: `departureDate`, `returnDate`, `tripType`, `price`, `airlines`, `airlineCodes`, `fromAirport`, `toAirport`, `isDirect`, `quotedAt`, `flightUrl`. |
| `faqCount`, `faqs[]` | The published questions and answers for the route: `question`, `answer`, `topic`. |
| `sourceUrl`, `requestedUrl` | Where the profile came from, and what was asked for. |
| `priceDisclaimer`, `pricesAreEstimates` | Skyscanner's own wording about how its prices should be read. |
| `isPartialProfile` | True when only part of the profile came through. Everything missing is then `null`, never estimated and never zero — including the counts (`directAirlineCount`, `exampleFareCount`, `nearbyAirportCount`, `monthsWithAPublishedPrice`, `faqCount`), because a count of `0` would be a measurement nobody took. A count is `0` only on a complete result where the source published nothing there. |
| `publishedFigureConflicts[]` | Cases where Skyscanner published two different values for the same numeric figure — weekly flights, flight time, destination count, headline price. Both are kept. (The cheapest-month disagreement is not in here; both answers are their own columns, `cheapestMonth` and `cheapestMonthStatement`.) |
| `notes[]` | Anything unusual about this particular result. |
| `collectedAt` | When it was collected. |

***

### Pricing

You pay per result, not per minute.

| What you pay for | Price |
| --- | --- |
| **Route profile collected** — one route, one market, saved as a result | **$15.00 per 1,000** |
| **Nearby airport comparison added** — only when you switch it on, and only when it actually carries prices | **$5.00 per 1,000** |

One result is a whole route dossier — the complete non-stop airline roster, weekly
frequency, flight time, a twelve-month price curve, priced examples and the catchment
comparison — around fifty fields for one route in one market.

**Worked example.** 500 routes in one market, with the nearby-airport comparison on:
500 profiles × $0.015 = **$7.50**, plus 500 comparisons × $0.005 = **$2.50**.
**Total: $10.00.**

Take those same 500 routes across three markets and you get 1,500 results for
1,500 × $0.02 = **$30.00**. A first look at 25 routes costs **$0.50**.

Switch the comparison off and the run is $15.00 per 1,000 results, flat.

You are never charged for a route that had nothing published, a route the source does
not publish at all, a route removed by your own filters, or a route that could not be
read. Those are reported in the run summary instead.

***

### Limits & what this actor cannot do

- **Prices are a snapshot, and Skyscanner labels them as estimates.** Its own wording
  travels with every result in `priceDisclaimer`. Airline pricing moves continuously,
  and a price seen now may be gone shortly after.
- **It cannot book, hold or reserve anything**, and it cannot guarantee a price is still
  available. It reports what Skyscanner publishes to the public, nothing more.
- **Some countries price one direction and others price the return trip, and you have to
  look.** Measured on the same route at the same moment: the Indian storefront published
  ₹ 27,470 for a one-way London → New York, and the German one published 348 € for the
  return. Nothing in the two figures themselves distinguishes them, so every result carries
  `priceTripType`, every month in the curve, every alternative airport and every priced
  example carries its own `tripType`, and none of them is ever assumed — when the source
  does not say, or contradicts itself, the field is `null`. Do not compare, average or
  model two results without checking it first.
- **Two figures are English-only.** `bookAheadDays` and `airportsServingDestination` are
  not published as figures anywhere: they exist only inside the route's written answers,
  and a number is only ever taken out of those answers in English rather than guessed from
  another language. On any storefront whose answers are not in English — Germany, France,
  Spain, Italy, the Netherlands and Poland always, and any of the others on a run where
  they answer for a different country — both fields are therefore empty on **every** route,
  and
  `writtenAnswerFiguresAvailable` on each result — plus a line in the run summary — tells
  you that is what happened, rather than leaving it looking like a route nobody answered
  for. Everything else on the result is available in every market.
- **Skyscanner sometimes disagrees with itself, and you are shown both answers.** The
  headline cheapest month and its own written answer to "which month is cheapest" come
  from different places and can name different months — measured on a live route:
  headline November, written answer September. Both are on the result, in `cheapestMonth`
  and `cheapestMonthStatement`, and `cheapestMonthByPrice` gives you the month the
  published numbers actually support. Nothing is silently picked for you. Note that
  `publishedFigureConflicts[]` covers the figures published as numbers — weekly flights,
  flight time, destination count and the headline price — and not this one, because the
  written answer is a sentence in the local language and no month is ever read out of it.
- **The published flight time is rounded, occasionally oddly.** One live route is
  published as "7 hrs, 60 mins" where the same page's written answer says 7 h 59 m.
  The text is passed through exactly as published and flagged with
  `averageFlightTimeIsRounded` rather than quietly corrected.
- **Results differ by market, and a few markets answer for wherever the run reads
  from.** Germany, India, Australia, Canada, Spain, Italy, the Netherlands and Poland
  reliably answer for themselves. The United States, United Kingdom and France
  storefronts sometimes answer with another country's market instead. Every result is
  always labelled with the market and currency that actually answered, and
  `marketMatchesRequested` tells you which happened — a result is never labelled with a
  market that was merely asked for. Turn on `onlyRequestedMarket` to discard mismatches.
- **A route with nothing on it is reported as having nothing, not as an error.** Thin
  and seasonal routes exist: measured live, one real Scottish island route publishes its
  alternative airports and no price at all anywhere. That is reported as empty, and it
  is not saved as a result or charged for.
- **A route Skyscanner does not publish at all is its own outcome.** It is counted
  separately from a route that is published but bare.
- **If the source declines to serve a route, that route is reported as "could not be
  read" — never as a route with no data.** This is the distinction the whole actor is
  built around, because the two look identical otherwise. The run summary counts them
  separately, and if the source stops answering part-way through, the run says so and
  stops rather than spending your allowance on silence.
- **Baggage fees, seat maps, airline ratings and cabin classes are not available here.**
  Skyscanner does not publish them alongside route economics.
- **There is no "cheapest destinations from anywhere" list.** Skyscanner publishes only
  a small sample of destinations on pages of this kind, so a full destination sweep is
  not something this actor can honestly offer.
- **Very broad sweeps return what Skyscanner publishes**, in the order it publishes it,
  up to your route limit — not an unlimited list.
- **Speed depends on the size of the job and on how quickly the source answers.** No
  fixed throughput is promised, and a large run is deliberately paced.
- **Skyscanner's terms govern automated access.** You are responsible for using the data
  lawfully and in line with those terms, and for handling any personal data in line with
  applicable privacy law.

***

### FAQ

**Do I need an account on Skyscanner?**
No. Nothing is signed in to and nothing is signed up for.

**Does it need my login or password?**
No. It never asks for one, and there is nowhere to enter one.

**Can I schedule it?**
Yes. Schedule it daily or weekly and the results accumulate, so you can watch a route's
frequency, airline roster and seasonal curve change over time.

**Are these prices bookable?**
Treat them as indicative. Skyscanner publishes them as estimated lowest prices and says
so itself, in wording carried on every result. They are a snapshot of what was published
at collection time, not a held or guaranteed price.

**Why does the same route cost different amounts in different markets?**
Because they genuinely are different products. Each country storefront has its own
inventory and its own currency, and the cheapest month can differ too. Nothing is ever
converted between currencies — every figure is exactly what that market published. Check
`priceTripType` before reading anything into a gap: some countries publish these prices
for one direction and others for the return trip, so part of a difference can simply be
that one of the two figures buys twice the travel.

**One market shows a much lower price than another. Is it really cheaper?**
Only if both results say the same thing in `priceTripType`. When one says `one_way` and
the other says `return`, they are not comparable at all, and neither one is wrong — they
are answers to different questions.

**What is the difference between "cheapest month" and "cheapest month by price"?**
The first is Skyscanner's headline answer. The second is the month with the lowest
figure in the twelve-month curve on the same result. They usually agree; when they don't,
you can see it rather than having a choice made for you.

**How do I get every route out of one airport?**
Turn on `findRoutesForMe`, put the airport in `seedOrigins`, and raise `maxRoutes`. Add
`minFlightsPerWeek` to cut the long tail down to routes with real traffic.

# Actor input Schema

## `routes` (type: `array`):

The city pairs to profile, one per line. Write them as two place codes — a city code such as LON, NYC or PAR, or an airport code such as LHR, JFK or CDG. "LON-NYC", "LHR > JFK" and "CDG to BCN" are all accepted. You can also paste a Skyscanner route page address: the two places are taken from it and the route is then collected for the market you choose below, which may be a different country from the address you pasted. Pick that country as the market, or add it to the comparison markets, to collect the one you pasted.

## `market` (type: `string`):

The country you are selling into. Skyscanner runs a separate storefront per country, and they are genuinely different: the same route can be cheapest in November for one country and in September for another, priced in that country's own currency, and some storefronts price a one-way trip where others price the return — every result says which in "priceTripType", so compare that before comparing prices. Every result is also labelled with the market and currency it was actually served in. Two figures — "bookAheadDays" and "airportsServingDestination" — exist only inside the route's written answers and are read in English only, so they are empty on every route on a storefront that answers in another language: Germany, France, Spain, Italy, the Netherlands and Poland always, and any other storefront on a run where it answers for a different country. Each result says which happened in "writtenAnswerFiguresAvailable".

## `compareMarkets` (type: `array`):

Collect the same routes for extra countries as well, so you can compare what a route costs and when it is cheapest in each one. You get one result per route per market. Leave empty to collect only the market above. Up to 6 extra markets.

## `findRoutesForMe` (type: `boolean`):

Instead of listing every route yourself, let the actor work through the routes Skyscanner publishes for the chosen market, in the order it publishes them, until the route limit is reached. Combine this with the two filters below to sweep everything out of, or everything into, the airports you care about.

## `seedOrigins` (type: `array`):

Used only when "Find routes for me" is on. Keep only discovered routes that leave from these places, for example LHR, LGW, STN. Leave empty for any departure point.

## `seedDestinations` (type: `array`):

Used only when "Find routes for me" is on. Keep only discovered routes that arrive at these places, for example JFK, EWR. Leave empty for any destination.

## `maxRoutes` (type: `integer`):

The most routes to profile in one run, counting both the routes you listed and any the actor found for you. Each route produces one result per market.

## `includeNearbyAirports` (type: `boolean`):

Add the alternative-airport comparison to every result: the other airports serving the destination, how far each one is from the city, the cheapest airline into it and what that costs. This is the part that tells you whether the traffic on a route is really going somewhere else. Charged separately — see pricing.

## `includeMonthlyPrices` (type: `boolean`):

Add the month-by-month cheapest price for the year ahead, so you can see the seasonal shape of the route rather than a single headline number.

## `includeDeals` (type: `boolean`):

Add the sample dated fares the route page publishes — date, airline, airports and price — each with a direct link to the trip. Some country storefronts price these one way and others price the return trip; every example says which in its own "tripType", and the result says which its headline figures are in "priceTripType".

## `includeFaqs` (type: `boolean`):

Add the questions and answers Skyscanner publishes for the route, such as how many airports serve the destination and how far ahead to book. Useful as ready-made copy for travel content.

## `minFlightsPerWeek` (type: `integer`):

Keep only routes with at least this many flights a week, so a large sweep returns real trunk routes rather than thin ones. A route where this figure is not published is left out when this filter is set. Leave at 0 to keep every route.

## `minDirectAirlines` (type: `integer`):

Keep only routes flown non-stop by at least this many airlines. Useful for finding competitive routes, or — set to 1 — for excluding connection-only city pairs. Leave at 0 to keep every route.

## `onlyRoutesWithAPrice` (type: `boolean`):

Leave out routes where no headline price is published. Turn this on when you are building a pricing model and a route without a price is noise.

## `onlyRequestedMarket` (type: `boolean`):

A few country storefronts answer with the market of wherever the run happens to read from rather than their own. Turn this on to discard those results instead of keeping them labelled with the market that was actually served.

## Actor input object example

```json
{
  "routes": [
    "LON-NYC",
    "LHR-JFK",
    "CDG-BCN"
  ],
  "market": "GB",
  "compareMarkets": [],
  "findRoutesForMe": false,
  "seedOrigins": [],
  "seedDestinations": [],
  "maxRoutes": 25,
  "includeNearbyAirports": true,
  "includeMonthlyPrices": true,
  "includeDeals": true,
  "includeFaqs": true,
  "minFlightsPerWeek": 0,
  "minDirectAirlines": 0,
  "onlyRoutesWithAPrice": false,
  "onlyRequestedMarket": false
}
```

# Actor output Schema

## `routeProfiles` (type: `string`):

One result per route and market, with the direct-airline roster, weekly frequency, average flight time, cheapest month and nearby-airport comparison.

## `routeProfilesCsv` (type: `string`):

The same results as a spreadsheet-ready file.

## `runSummary` (type: `string`):

How many route profiles were collected, how many routes were published with nothing on them, how many are not published at all, and how many could not be read.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "routes": [
        "LON-NYC",
        "LHR-JFK",
        "CDG-BCN"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("apt_marble/skyscanner-route-intelligence-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = { "routes": [
        "LON-NYC",
        "LHR-JFK",
        "CDG-BCN",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("apt_marble/skyscanner-route-intelligence-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "routes": [
    "LON-NYC",
    "LHR-JFK",
    "CDG-BCN"
  ]
}' |
apify call apt_marble/skyscanner-route-intelligence-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,apt_marble/skyscanner-route-intelligence-scraper"
        }
    }
}

```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/hnoL1n4Te3eOramm8/builds/LRsUpnJhCsiwHnSPw/openapi.json