# Skyscanner Scraper API - Flights, Prices, Carriers & Stops (`makework36/skyscanner-flight-scraper-api`) Actor

Scrape Skyscanner flights — origin, destination, dates. Returns price, carrier, stops, duration, booking URL. HTTP-only mobile endpoint, no browser, no residential proxy.

- **URL**: https://apify.com/makework36/skyscanner-flight-scraper-api.md
- **Developed by:** [deusex machine](https://apify.com/makework36) (community)
- **Categories:** Travel, E-commerce, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.50 / 1,000 itineraries

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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 Scraper API — Flights, Prices, Carriers & Itineraries

Production-ready Skyscanner flight scraper for any origin–destination–date combo. Returns structured itineraries with price, marketing carrier, stop count, total duration, and departure/arrival times. No browser automation on your side — the actor calls the same mobile endpoints that the Skyscanner Android app uses and receives clean JSON.

**Covers**: one-way and round-trip flights across [Skyscanner.net](https://www.skyscanner.net), [Skyscanner.com.mx](https://www.skyscanner.com.mx), [Skyscanner.co.uk](https://www.skyscanner.co.uk), [Skyscanner.es](https://www.skyscanner.es), [Skyscanner.com.br](https://www.skyscanner.com.br) and any other Skyscanner market — just change the `market`, `locale` and `currency` inputs. Itinerary buckets returned: **Best**, **Cheapest**, **Fastest**, and **Direct**.

**Jump to:** [Why use this](#what-this-skyscanner-scraper-does) · [Fields](#data-fields-the-skyscanner-scraper-extracts) · [Use cases](#use-cases-for-this-skyscanner-flight-data-api) · [How to use](#how-to-use-this-skyscanner-scraper) · [Code examples](#how-to-call-this-skyscanner-scraper-from-your-code) · [Pricing](#pricing) · [FAQ](#faq)

### What this Skyscanner scraper does

Skyscanner is not a meta-search API you can hit publicly — the mobile app is protected by PerimeterX Mobile SDK and the website requires a browser. Most scrapers on this Store handle it with Playwright + residential proxies, which is slow (10–30 s per search), expensive (residential bandwidth ~€8/GB), and fragile (breaks whenever PerimeterX ships an update).

This actor takes a different path. We run a mobile-token pipeline on a dedicated VPS that keeps a fresh anti-fraud token warm in cache. When your actor run starts, we fetch that token over an authenticated HTTP endpoint and call Skyscanner's official mobile endpoint `https://www.skyscanner.net/g/radar/api/v2/unified-search` directly from the actor container. The request completes in **2–15 seconds** and returns the same JSON the Skyscanner Android app uses to render results — meaning you get the same prices end-users see, not a proxy estimate.

Because we use the mobile endpoint there is **no browser fingerprinting to solve**, no captcha to bypass, and no residential proxy to pay for. That is why this actor is cheaper than almost any competing Skyscanner scraper on the Store.

### Data fields the Skyscanner scraper extracts

Each dataset item is a flat JSON record with **20 fields** — enough to build dashboards, price trackers, and BI analyses without touching a second endpoint:

**Itinerary identifiers**

- `itineraryId` — Skyscanner's unique id for the full itinerary (stable across polls)
- `origin` — entityId you passed in the input (e.g. `39151418` for Mexico City)
- `destination` — entityId of the destination (or `everywhere` for open-ended searches)
- `originCode` — IATA code of the first departure airport (e.g. `MEX`)
- `destinationCode` — IATA code of the final arrival airport (e.g. `MAD`)

**Dates and times**

- `departDate` — outbound date (ISO, YYYY-MM-DD) as requested
- `returnDate` — return date for round-trips; `null` for one-way
- `departDateTime` — full ISO timestamp with timezone of the first departure
- `arrivalDateTime` — full ISO timestamp of the last arrival

**Pricing**

- `price` — numeric price in the currency requested (e.g. `899.6`)
- `priceFormatted` — string formatted by Skyscanner in market locale (e.g. `"$900"`)
- `currency` — ISO currency code, defaults to the `currency` input

**Flight composition**

- `marketingCarrier` — name of the marketing carrier of the first leg (e.g. `"Aeromexico"`)
- `legCount` — number of legs (1 for one-way, 2 for round-trip)
- `totalDurationMin` — total flight time across all legs in minutes
- `stops` — total number of stops across all legs (0 = direct)
- `cabinClass` — cabin class as passed in input
- `bookingUrl` — deeplink to book on the preferred provider (when present)

**Meta**

- `scrapedAt` — ISO 8601 UTC timestamp when the row was produced

Every field is populated in ≥99% of rows in our test runs (10 k+ itineraries across 50 routes). The few exceptions are exotic routes where Skyscanner itself returns `null` for carrier or deeplink.

### Use cases for this Skyscanner flight data API

**Revenue management for OTAs and airlines**. Track how your prices compare to competing carriers on the same route every hour. Feed `price`, `marketingCarrier` and `stops` into a Looker Studio board and you have a competitive-pricing dashboard in an afternoon.

**Deal-finder and newsletter automation**. Schedule the actor daily on ~200 popular routes and push rows where `price < X` to a Google Sheet or Slack channel. Classic travel-deals newsletter mechanic, runs at ~$0.01 per deal monitored.

**Travel BI and ML pricing models**. Pull 30–60 days of price history per route, join with your own load factor or event calendar, and train a simple regression on `price ~ departDate + carrier + stops`. The structured output makes feature engineering trivial.

**Corporate travel benchmarking**. Finance teams can compare internal travel-agency quotes against real-time Skyscanner prices for the same dates. Plug into SAP Concur, Navan, or a bespoke dashboard.

**Affiliate content and SEO**. Deal-of-the-day landing pages ("cheapest MEX→MAD flights for July") update automatically. Each `bookingUrl` can be rewritten with your affiliate parameters downstream.

**Refund & fare-alert services**. Your product lets users set a target price; this actor polls every few hours and pings them when a row drops below the threshold.

### How to use this Skyscanner scraper

The actor takes a simple JSON input describing a single search. Each run returns up to `maxItineraries` rows covering the Best/Cheapest/Fastest/Direct buckets for that query.

#### Mode 1 — one-way flight

```json
{
  "origin": "39151418",
  "destination": "95565077",
  "departDate": "2026-07-15",
  "adults": 1,
  "cabinClass": "economy",
  "market": "US",
  "locale": "en-US",
  "currency": "USD",
  "maxItineraries": 50
}
````

#### Mode 2 — round-trip flight

Add `returnDate`. The actor builds two legs automatically and Skyscanner returns round-trip itineraries.

```json
{
  "origin": "27544008",
  "destination": "95565065",
  "departDate": "2026-09-04",
  "returnDate": "2026-09-11",
  "adults": 2,
  "cabinClass": "business",
  "market": "GB",
  "locale": "en-GB",
  "currency": "GBP"
}
```

#### Mode 3 — "everywhere" search

Pass `destination: "everywhere"` to get the cheapest flight from your origin to any destination. Great for deal discovery, competitor spotting, and editorial "cheap flights from X" content.

```json
{
  "origin": "95673679",
  "destination": "everywhere",
  "departDate": "2026-08-20",
  "maxItineraries": 100
}
```

#### How to find Skyscanner `entityId`s

The actor uses Skyscanner's internal `entityId` numeric identifiers, not IATA codes. Common ones:

| City / Airport | entityId |
|---|:---:|
| Mexico City | `39151418` |
| Madrid | `95565077` |
| London | `27544008` |
| Paris / Rome (CDG-cluster) | `95565065` |
| Boston (BOS) | `95673679` |
| Orlando (MCO) | `95674009` |
| New York (JFK-cluster) | `27537542` |
| Los Angeles | `27536067` |

You can discover any other entityId by hitting Skyscanner's public typeahead, visible in the browser URL when you search a city on the site. A future version of this actor will expose an `entityId lookup` input to save you that step.

### Input parameters

| Field | Type | Default | Notes |
|-------|------|---------|-------|
| `origin` | string | `39151418` | Origin entityId. Required. |
| `destination` | string | `95565077` | Destination entityId or `"everywhere"`. Required. |
| `departDate` | string | `2026-07-15` | ISO date YYYY-MM-DD. Required. |
| `returnDate` | string | `""` | ISO date for round-trip. Empty = one-way. |
| `adults` | int | `1` | 1-9 travelers. |
| `cabinClass` | select | `economy` | `economy`, `premium_economy`, `business`, `first` |
| `market` | string | `US` | ISO country for results localization. |
| `locale` | string | `en-US` | Locale for carrier names & UI strings. |
| `currency` | string | `USD` | ISO currency code. |
| `maxItineraries` | int | `100` | Hard cap on rows pushed to dataset. 1-500. |

### Output example

A real itinerary returned by a `MEX → MAD, 2026-07-15` search:

```json
{
  "itineraryId": "13993-2607152125--32733-0-13870-2607161630",
  "origin": "39151418",
  "destination": "95565077",
  "originCode": "MEX",
  "destinationCode": "MAD",
  "departDate": "2026-07-15",
  "returnDate": null,
  "departDateTime": "2026-07-15T21:25:00",
  "arrivalDateTime": "2026-07-16T16:30:00",
  "price": 899.6,
  "priceFormatted": "$900",
  "currency": "USD",
  "marketingCarrier": "Aeromexico",
  "legCount": 1,
  "totalDurationMin": 665,
  "stops": 0,
  "cabinClass": "economy",
  "bookingUrl": "",
  "scrapedAt": "2026-04-23T00:21:46.552624+00:00"
}
```

### How to call this Skyscanner scraper from your code

#### From the Apify API (curl)

```bash
curl -X POST "https://api.apify.com/v2/acts/makework36~skyscanner-flight-scraper-api/run-sync-get-dataset-items?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "origin": "39151418",
    "destination": "95565077",
    "departDate": "2026-07-15",
    "adults": 1,
    "cabinClass": "economy",
    "market": "US",
    "currency": "USD",
    "maxItineraries": 50
  }'
```

#### From Python (apify-client)

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")

run = client.actor("makework36/skyscanner-flight-scraper-api").call(run_input={
    "origin": "39151418",
    "destination": "95565077",
    "departDate": "2026-07-15",
    "maxItineraries": 100,
})

for it in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(it["marketingCarrier"], it["price"], it["currency"], it["originCode"], "→", it["destinationCode"])
```

#### From Node.js (apify-client)

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

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

const run = await client.actor('makework36/skyscanner-flight-scraper-api').call({
    origin: '27544008',
    destination: '95565077',
    departDate: '2026-08-10',
    returnDate: '2026-08-17',
    currency: 'GBP',
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.table(items.map(i => ({ carrier: i.marketingCarrier, price: i.price, stops: i.stops })));
```

#### Export to CSV

```bash
curl "https://api.apify.com/v2/datasets/YOUR_DATASET_ID/items?format=csv" > flights.csv
```

#### From Zapier / Make / n8n

Use the official Apify connector and feed `origin`, `destination`, and `departDate` from the previous step. The actor finishes in under 20 s, so it fits comfortably in webhook workflows.

### Performance & cost

A typical run (1 route, 1 date, 50 itineraries):

- **Fetch fresh token**: 5–50 ms (cached on the dedicated VPS)
- **Skyscanner unified-search**: 2–4 s cold, plus up to 4 polls × 2 s while Skyscanner fills the remaining providers
- **Parse + push**: <100 ms
- **Total**: 8–15 s per search, 256 MB RAM, 1 CPU

At `$0.004` per itinerary (Silver tier), the typical 50-row search costs about `$0.20`. Running 100 routes every 6 h (400 k itineraries/month) costs **~$1,600/month** on Silver — significantly less than a single enterprise fare-monitoring SaaS and infinitely more flexible. Small workloads (500 searches × 50 rows/month) land at **~$125/month** on the FREE tier.

### Skyscanner scraper comparison — how this compares to other actors on the Store

All comparisons anonymized (we don't name competitors publicly). These reflect the typical state of the Skyscanner category on the Apify Store as of the last update of this README.

| Approach | Tech | Residential proxy | Avg run time | Price / 1K |
|----------|:----:|:-----------------:|:------------:|:----------:|
| **This actor** (mobile-token pipeline) | HTTP only | **No** | 8–15 s | **$5** |
| Playwright scraper with residential | Browser | Required | 25–45 s | $5 + proxy ($30/mo) |
| Scraper using leaked internal GraphQL | HTTP | No | 3–8 s | $4–8 (unstable) |
| Browser-based with captcha solver | Browser | Required | 30–60 s | $8 + captcha fees |
| Affiliate-API wrapper (Partners) | API | No | 2–3 s | Partner only (B2B contract) |

For low-to-medium volume (under 30 000 searches/month) this actor is the cheapest total-cost option because you do not need to buy residential proxy bandwidth or captcha credits on top of the per-result fee.

### Step-by-step tutorial — your first Skyscanner run in 3 minutes

1. Open the actor page on Apify and click **Try for free**.
2. In the **Input** tab, leave the defaults (Mexico City → Madrid, 2026-07-15) and set `maxItineraries = 10`.
3. Click **Start**. The run finishes in about 15 seconds.
4. Open the **Dataset** tab — you'll see 10 rows with all 20 fields populated, formatted as a sortable table (sort by `price` to see the cheapest first).
5. Click **Export → CSV** to download; or **API** for a ready-to-use URL you can paste into Google Sheets' `IMPORTDATA()`.

That's it — you just scraped 10 real Skyscanner flight offers without a browser, a proxy, or a captcha solver.

### Advanced usage patterns

#### Pattern 1 — daily price monitor on one route

Schedule the actor to run every 6 hours with a fixed `origin`, `destination` and `departDate`. Pipe the dataset into BigQuery via Apify's integration. Plot `price` vs `scrapedAt` in Looker Studio and you have a real-time fare-tracking dashboard.

#### Pattern 2 — 100 routes in one run (task chaining)

Use an Apify **Task** per route and call them from a master Apify workflow. Each task runs in parallel and finishes in ~15 s, so 100 routes complete in under a minute of wall clock time (and ~15 actor-minutes of compute).

#### Pattern 3 — cheapest-flight-anywhere newsletter

`destination: "everywhere"` returns the cheapest destinations from your origin ranked by price. Schedule daily for 5–10 origin cities, filter rows where `price < median`, push top 10 to a Beehiiv/Substack draft via webhook, schedule the newsletter. Classic editorial automation.

#### Pattern 4 — feed an AI pricing model

Dump 30 days of runs into Parquet, join with your calendar of events (holidays, conferences, school breaks), and fit a gradient-boosted model on `price`. Use the residuals to flag "unusually cheap" flights.

#### Pattern 5 — competitor benchmark for an airline

Run the actor on your airline's own routes every hour and compute how far your own fares are from the `min(price)` per route. Feed the delta into your revenue-management system to trigger re-pricing.

### Troubleshooting

**`status=incomplete` in logs, but results returned** — that's normal. Skyscanner emits partial results as each provider responds. The actor automatically polls up to 4 times (8 seconds) to collect additional itineraries. Some low-traffic routes never reach `status=complete` because not every provider has inventory; you still get the available rows.

**Empty dataset with status=incomplete** — the route or date combination has zero availability right now. Typical for exotic pairs (e.g. Kamchatka → Lagos next Tuesday). Try a different date or a nearby airport.

**HTTP 403 from upstream** — the token cache on our VPS is being rebuilt. The actor surfaces this as a 503 and exits cleanly; re-running 30–60 seconds later almost always succeeds. We auto-refresh the token and have a stale-but-valid fallback, so this is rare.

**`Too little data for declared Content-Length`** — old builds had a header passthrough bug; upgrade to latest build (auto-build pulls fix this).

**Prices differ from the Skyscanner website** — they don't, really. The website shows the market currency of your IP; this actor respects the `market`/`currency` inputs. Set them to match and numbers align.

**Timeout on big `maxItineraries`** — keep it ≤100 per run. Chaining multiple runs is faster than one huge request because Skyscanner caps its unified-search response.

### Pricing

Pay-per-event model, consistent with the rest of makework36's scrapers.

| Tier | Per itinerary | Per start |
|------|:-------------:|:---------:|
| FREE | $0.005 | $0.05 |
| BRONZE | $0.0045 | $0.05 |
| SILVER | $0.004 | $0.05 |
| GOLD | $0.0035 | $0.05 |
| PLATINUM | $0.003 | $0.05 |
| DIAMOND | $0.003 | $0.05 |

Examples (FREE tier):

- **1 route × 50 itineraries** = $0.30 per search
- **100 routes × 50 / day** (150 k/month) = **~$750/month**
- **Daily monitor of 50 popular routes** (75 k/month) = **~$375/month**
- **Weekly snapshot of 500 routes × 100 itineraries** (200 k/month) = **~$1,000/month**

Volume discounts cut the per-result price **up to 40%** automatically as your Apify account grade increases (from FREE $0.005 down to DIAMOND $0.003).

### FAQ

**Is it legal to scrape Skyscanner?** Scraping publicly available flight data is a legal grey area. This actor only calls the same mobile endpoints the Skyscanner Android app calls — no login, no paywall, no TOS-specific restrictions beyond [Skyscanner's general terms](https://www.skyscanner.net/terms.html). You are responsible for how you use the extracted data; respect trademarks and downstream data-protection regulations.

**How fresh are the prices?** They reflect what Skyscanner shows the mobile app at the moment of your request — typically 5–15 minutes fresh. For sub-minute freshness you'd need an airline-API direct feed, which costs $20k+/year.

**Do I need a proxy?** No. The actor runs against Skyscanner's mobile endpoints using a token served by our VPS; the request to Skyscanner is made directly from the Apify container with its default IP.

**Can I search round-trip / multi-city?** Round-trip: yes, pass `returnDate`. Multi-city: not yet — roadmap item.

**Which markets/currencies are supported?** Every market Skyscanner supports. Common ones tested: US, GB, MX, ES, BR, DE, FR, IT, JP, IN, AU. Pass the market code you want in `market` + the matching `locale` and `currency`.

**What's the max volume?** Hundreds of thousands of itineraries per day are fine. At that scale, open an issue and we'll discuss an Enterprise tier with dedicated infrastructure.

**Does it support the Skyscanner Hotels / Car Hire endpoints?** Not in this actor. A separate Skyscanner Hotels actor is on our roadmap — it uses a different JWT flow that's much simpler than flights.

**Can I filter by carrier / stops / cabin?** Not server-side yet — filter downstream on the fields we emit (`marketingCarrier`, `stops`, `cabinClass`). A future version will accept `filters` in the input schema.

**Does PerimeterX ever block you?** The mobile token pipeline has a soft-fail fallback that kicks in when our auto-refresh encounters an overlay change in the Skyscanner app. In practice that degraded path covers us for hours, and we re-bootstrap the device fingerprint within minutes of any PX policy change.

**Can I use this from Zapier or Make?** Yes — Apify has first-class connectors for both. Build a workflow that fires this actor then pushes results to Google Sheets, Slack, Airtable, or a webhook.

**Is there an MCP server version?** Not yet. Let us know if you want one — happy to publish one if there's demand from Claude / Cursor / ChatGPT users.

### Changelog

**0.1.7 — 2026-04-23** — Initial public release. 20 output fields, 1-way + round-trip + everywhere modes. Poll support for incomplete Skyscanner responses. Header sanitization for httpx.

### Related scrapers from the same author

- [Flight Price Scraper API](https://apify.com/makework36/flight-price-scraper) — multi-source flight aggregator (Google Flights, Kiwi, Ryanair, EasyJet, Wizz Air, Norwegian, Travelpayouts). Use alongside this Skyscanner scraper for cross-provider price comparisons.
- [Airbnb Scraper](https://apify.com/makework36/fast-airbnb-price-scraper) — listings, prices, photos and hosts API.
- [Booking.com Scraper API](https://apify.com/makework36/fast-booking-scraper) — hotels, prices, ratings and rooms.
- [VRBO Scraper](https://apify.com/makework36/vrbo-scraper) — vacation rentals + Expedia hotels API.
- [Shopee Scraper API](https://apify.com/makework36/shopee-scraper-api) — Shopee products, prices, discounts across 11 countries.
- [Reddit Scraper](https://apify.com/makework36/reddit-scraper) — posts, comments, subreddits and users.
- [Trustpilot Scraper API](https://apify.com/makework36/trustpilot-reviews-scraper) — reviews, ratings, business search.

### Legal & ethics note

This actor queries public mobile endpoints of Skyscanner that are used by the official Android application. It does not bypass authentication, captchas intended for end users, or any paid-API restriction. You remain responsible for how you use the extracted data — respect copyright, trademarks, [Skyscanner's terms](https://www.skyscanner.net/terms.html), and applicable data-protection regulation (LGPD in Brazil, GDPR in Europe, CCPA in California) when storing, transforming, or redistributing the output.

Prices and availability change minute-by-minute. This actor reflects what the Skyscanner mobile app would show a real user at the time of the request; we don't cache or rewrite numbers. If Skyscanner itself returns incorrect data, that's propagated to the output.

The actor does not store personal information. Inputs (`origin`, `destination`, `departDate`, etc.) are not retained beyond the run metadata Apify keeps for billing. Outputs live in your Apify dataset and are yours to export and delete at will.

# Actor input Schema

## `origin` (type: `string`):

Skyscanner entityId of origin city or airport. Examples: 39151418 (Mexico City), 95565077 (Madrid), 27544008 (London), 95673679 (Boston BOS), 95674009 (Orlando MCO).

## `destination` (type: `string`):

Skyscanner entityId of destination. Use 'everywhere' for open-ended search (cheapest flights anywhere).

## `departDate` (type: `string`):

Outbound flight date in ISO format.

## `returnDate` (type: `string`):

Return flight date for round-trip. Leave empty for one-way.

## `adults` (type: `integer`):

Number of adult travelers.

## `cabinClass` (type: `string`):

Travel class for the search.

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

Market country code (e.g. US, GB, MX, ES, JP).

## `locale` (type: `string`):

Locale code (e.g. en-US, es-MX, pt-BR).

## `currency` (type: `string`):

ISO currency code.

## `maxItineraries` (type: `integer`):

Cap on itineraries returned per run.

## Actor input object example

```json
{
  "origin": "39151418",
  "destination": "95565077",
  "departDate": "2026-07-15",
  "adults": 1,
  "cabinClass": "economy",
  "market": "US",
  "locale": "en-US",
  "currency": "USD",
  "maxItineraries": 100
}
```

# Actor output Schema

## `itineraries` (type: `string`):

Default dataset with one row per itinerary (Best, Cheapest, Fastest, Direct buckets merged & deduplicated).

## `itinerariesCsv` (type: `string`):

Same dataset formatted as CSV for spreadsheet tools (Google Sheets IMPORTDATA, Excel).

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("makework36/skyscanner-flight-scraper-api").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 = {}

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

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

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

```

## CLI example

```bash
echo '{}' |
apify call makework36/skyscanner-flight-scraper-api --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=makework36/skyscanner-flight-scraper-api",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Skyscanner Scraper API - Flights, Prices, Carriers & Stops",
        "description": "Scrape Skyscanner flights — origin, destination, dates. Returns price, carrier, stops, duration, booking URL. HTTP-only mobile endpoint, no browser, no residential proxy.",
        "version": "0.1",
        "x-build-id": "QNlV38wQe8UjvFI4Q"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/makework36~skyscanner-flight-scraper-api/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-makework36-skyscanner-flight-scraper-api",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/makework36~skyscanner-flight-scraper-api/runs": {
            "post": {
                "operationId": "runs-sync-makework36-skyscanner-flight-scraper-api",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/makework36~skyscanner-flight-scraper-api/run-sync": {
            "post": {
                "operationId": "run-sync-makework36-skyscanner-flight-scraper-api",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "origin",
                    "destination",
                    "departDate"
                ],
                "properties": {
                    "origin": {
                        "title": "Origin",
                        "type": "string",
                        "description": "Skyscanner entityId of origin city or airport. Examples: 39151418 (Mexico City), 95565077 (Madrid), 27544008 (London), 95673679 (Boston BOS), 95674009 (Orlando MCO).",
                        "default": "39151418"
                    },
                    "destination": {
                        "title": "Destination",
                        "type": "string",
                        "description": "Skyscanner entityId of destination. Use 'everywhere' for open-ended search (cheapest flights anywhere).",
                        "default": "95565077"
                    },
                    "departDate": {
                        "title": "Depart date (YYYY-MM-DD)",
                        "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
                        "type": "string",
                        "description": "Outbound flight date in ISO format.",
                        "default": "2026-07-15"
                    },
                    "returnDate": {
                        "title": "Return date (YYYY-MM-DD, optional)",
                        "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
                        "type": "string",
                        "description": "Return flight date for round-trip. Leave empty for one-way."
                    },
                    "adults": {
                        "title": "Adults",
                        "minimum": 1,
                        "maximum": 9,
                        "type": "integer",
                        "description": "Number of adult travelers.",
                        "default": 1
                    },
                    "cabinClass": {
                        "title": "Cabin class",
                        "enum": [
                            "economy",
                            "premium_economy",
                            "business",
                            "first"
                        ],
                        "type": "string",
                        "description": "Travel class for the search.",
                        "default": "economy"
                    },
                    "market": {
                        "title": "Market (country)",
                        "type": "string",
                        "description": "Market country code (e.g. US, GB, MX, ES, JP).",
                        "default": "US"
                    },
                    "locale": {
                        "title": "Locale",
                        "type": "string",
                        "description": "Locale code (e.g. en-US, es-MX, pt-BR).",
                        "default": "en-US"
                    },
                    "currency": {
                        "title": "Currency",
                        "type": "string",
                        "description": "ISO currency code.",
                        "default": "USD"
                    },
                    "maxItineraries": {
                        "title": "Max itineraries",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Cap on itineraries returned per run.",
                        "default": 100
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```