# Ryanair Scraper (`automation-lab/ryanair-flight-fares-cheapest-routes`) Actor

Search Ryanair fare calendars by airport and future date range, then export current fares, schedules, availability, and cheapest route/date options.

- **URL**: https://apify.com/automation-lab/ryanair-flight-fares-cheapest-routes.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Travel
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.44 / 1,000 item extracteds

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/actors/running/actors-in-store.md#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

## Ryanair Scraper

Search public **Ryanair fares** by departure airport and future date range.
Export current prices, route and airport details, departure and arrival times, availability, retrieval timestamps, and the cheapest dates found for each route.

Use one destination for a focused fare calendar, or leave the destination empty to compare multiple direct Ryanair routes from an airport.
The Actor writes normalized records to the default Apify dataset for spreadsheets, scheduled monitoring, APIs, and data pipelines.

### What does Ryanair Scraper do?

The Actor queries Ryanair's public airport and fare-calendar data.
It can:

- search a specific origin and destination;
- discover direct destinations exposed for an origin;
- scan a future date range of up to 180 days;
- return current one-way fares and currency;
- include public departure and arrival timestamps;
- mark the lowest returned fare for each route;
- include sold-out and unavailable dates on request;
- generate a Ryanair booking URL for every date;
- timestamp each snapshot for scheduled comparisons.

No Ryanair account is required.
The Actor uses direct public structured endpoints and does not automatically spend money on proxy traffic.

### Who is this Ryanair fare scraper for?

#### Travelers and travel-deal researchers

Compare destinations from a departure airport and identify lower-priced dates before opening the Ryanair booking flow.

#### Travel agencies and content teams

Build route/date fare tables for internal research, destination content, or deal discovery.
Always verify a fare on Ryanair before presenting it as bookable.

#### Revenue and market analysts

Collect repeatable snapshots of public route prices and availability.
Join successive datasets by `route` and `travelDate` to calculate historical changes.

#### Developers and data teams

Send typed fare rows to Google Sheets, webhooks, databases, BI tools, or custom applications through Apify integrations and API clients.

### Why use this Actor?

- **Ryanair-specific records:** direct route, airport, schedule, fare, and availability fields.
- **Two useful workflows:** focused route lookup and cheapest-destination exploration.
- **Rolling dates:** `today+7` style inputs remain useful in scheduled Tasks.
- **Bounded execution:** limits for records, destinations, and date range prevent accidental large runs.
- **Typed output:** one fare-date option per dataset row.
- **Visible failures:** invalid input or an unexpected upstream response fails rather than returning fabricated data.
- **No browser overhead:** the current implementation uses lightweight HTTP requests.

### What Ryanair data can I extract?

| Field | Meaning |
| --- | --- |
| `route` | Origin and destination IATA codes, such as `DUB-STN` |
| `departureAirport` | Origin IATA code |
| `departureAirportName` | Public airport name |
| `departureCity` | Ryanair city code |
| `departureCountry` | Two-letter country code |
| `arrivalAirport` | Destination IATA code |
| `arrivalAirportName` | Public destination airport name |
| `arrivalCity` | Destination city code |
| `arrivalCountry` | Destination country code |
| `flightNumber` | Flight number when exposed; currently often `null` in fare-calendar data |
| `departureDate` | Public local departure timestamp |
| `arrivalDate` | Public local arrival timestamp |
| `travelDate` | Fare calendar date |
| `currentFare` | Current displayed one-way fare |
| `previousFare` | Previous fare when Ryanair includes it in the response |
| `currency` | ISO fare currency |
| `currencySymbol` | Display symbol supplied by Ryanair |
| `fareChange` | Current minus previous fare when both exist |
| `soldOut` | Ryanair sold-out flag |
| `unavailable` | Ryanair unavailable flag |
| `newRoute` | Ryanair new-route flag |
| `isCheapestForRoute` | Whether this row has the lowest fare found for its route |
| `routeLowestFare` | Lowest fare found for the route in this run |
| `sourceUrl` | Ryanair booking page for the route and date |
| `priceUpdatedAt` | Timestamp when the Actor fetched the fare snapshot |

Fields can be `null` when the public response does not provide them.
A null value is not replaced with an estimate.

### How to scrape Ryanair fares

1. Open the Actor in Apify Console.
2. Enter a three-letter departure airport, for example `DUB`.
3. Optionally enter an arrival airport, for example `STN`.
4. Choose a future start and end date, or use rolling values such as `today+7` and `today+30`.
5. Set the record and route limits.
6. Click **Start**.
7. Open the **Dataset** tab to preview or export the fare records.

A useful focused-route input is:

```json
{
  "departureIata": "DUB",
  "arrivalIata": "STN",
  "dateFrom": "today+7",
  "dateTo": "today+21",
  "maxItems": 30,
  "market": "en-ie",
  "currency": "EUR"
}
```

For cheapest-destination exploration, omit `arrivalIata` and set `maxRoutes`.

### Input parameters

| Input | Type | Default | Description |
| --- | --- | --- | --- |
| `departureIata` | string | required | Three-letter departure airport code |
| `arrivalIata` | string | empty | Optional destination airport code |
| `dateFrom` | string | required | Future `YYYY-MM-DD`, `today`, or `today+N` |
| `dateTo` | string | required | Inclusive range end, maximum 180 days after start |
| `maxItems` | integer | `20` | Maximum saved fare-date records, up to 5,000 |
| `maxRoutes` | integer | `10` | Destinations checked when arrival is empty, up to 100 |
| `currency` | string | origin currency | Requested three-letter fare currency |
| `market` | string | `en-ie` | Ryanair locale, for example `en-ie` or `en-gb` |
| `language` | string | `en` | Two-letter language for airport names |
| `includeUnavailable` | boolean | `false` | Include unavailable or sold-out dates with nullable fares |

Airport codes are normalized to uppercase.
Past start dates and malformed airport, locale, currency, or date values fail validation.

### Output example

A real run produces records with this shape:

```json
{
  "route": "DUB-STN",
  "departureAirport": "DUB",
  "departureAirportName": "Dublin",
  "departureCountry": "IE",
  "arrivalAirport": "STN",
  "arrivalAirportName": "London Stansted",
  "arrivalCountry": "GB",
  "flightNumber": null,
  "departureDate": "2026-09-08T06:10:00",
  "arrivalDate": "2026-09-08T07:30:00",
  "travelDate": "2026-09-08",
  "currentFare": 14.99,
  "previousFare": null,
  "currency": "EUR",
  "fareChange": null,
  "soldOut": false,
  "unavailable": false,
  "isCheapestForRoute": true,
  "routeLowestFare": 14.99,
  "sourceUrl": "https://www.ryanair.com/en-ie/trip/flights/select?...",
  "priceUpdatedAt": "2026-08-27T07:30:00.000Z"
}
```

Fare values change over time.
The example describes the schema rather than promising that exact price or schedule.

### How much does it cost to scrape Ryanair fares?

This is a pay-per-event Actor.
A one-time `start` event covers starting a run, and the primary `item` event covers each fare record written to the dataset.
Plan tiers apply progressively lower event prices from FREE through DIAMOND.

The start event is **$0.005**. Item prices decrease by Apify plan:

| Plan | Price per fare record |
| --- | ---: |
| FREE | $0.000851 |
| BRONZE | $0.000740 |
| SILVER | $0.0005772 |
| GOLD | $0.000444 |
| PLATINUM | $0.000296 |
| DIAMOND | $0.0002072 |

Total price is:

```text
$0.005 start + (saved fare records × applicable item price)
```

At BRONZE pricing, 15 records cost **$0.0161**, 50 records cost **$0.0420**, and 100 records cost **$0.0790**.
A run that finds no accepted fare records has no item events.
Runtime and platform usage are not separate Actor events charged by this Actor.

### Find the cheapest Ryanair route and date

Leave `arrivalIata` empty to activate route discovery.
The Actor reads direct destination identifiers from the public departure-airport metadata, sorts them deterministically, and checks up to `maxRoutes` destinations.

Returned rows are sorted by current fare and then travel date.
Use:

- `isCheapestForRoute` for the cheapest date within each route;
- `routeLowestFare` to compare route minima;
- `currentFare` plus `currency` for numeric sorting;
- `sourceUrl` to verify the option on Ryanair.

`maxItems` can stop collection before every requested route is exhausted.
Raise it when you need a more complete comparison.

### Monitor Ryanair prices on a schedule

Create an Apify Task with rolling date values, then schedule it daily or weekly.
Each run records `priceUpdatedAt`, so snapshots can be compared later.

A practical workflow is:

1. run the same route and rolling date window daily;
2. export each dataset to a database or spreadsheet;
3. join rows by `route` and `travelDate`;
4. compare `currentFare` with the preceding snapshot;
5. alert only after applying your own threshold and availability checks.

`previousFare` is populated only if Ryanair exposes it in the current API response.
For dependable history, retain prior run datasets rather than relying on that nullable field.

### Export and integrations

The default dataset supports JSON, JSONL, CSV, Excel, XML, and RSS exports.
You can also connect a Task to:

- Google Sheets;
- Make;
- Zapier;
- webhooks;
- cloud storage;
- SQL or analytics pipelines.

Keep `currentFare` numeric during export.
Use `currency` alongside it because prices from different markets are not directly comparable.

### Use the Ryanair scraper API

Replace `APIFY_TOKEN` with your token.

#### cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~ryanair-flight-fares-cheapest-routes/runs?token=APIFY_TOKEN&waitForFinish=120" \
  -H "Content-Type: application/json" \
  -d '{"departureIata":"DUB","arrivalIata":"STN","dateFrom":"today+7","dateTo":"today+21","maxItems":30}'
```

#### JavaScript

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/ryanair-flight-fares-cheapest-routes').call({
  departureIata: 'DUB',
  arrivalIata: 'STN',
  dateFrom: 'today+7',
  dateTo: 'today+21',
  maxItems: 30,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### Python

```python
from apify_client import ApifyClient
import os

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/ryanair-flight-fares-cheapest-routes').call(run_input={
    'departureIata': 'DUB',
    'arrivalIata': 'STN',
    'dateFrom': 'today+7',
    'dateTo': 'today+21',
    'maxItems': 30,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

### Use Ryanair fare data through MCP

Add the Actor to Claude Code:

```bash
claude mcp add --transport http apify \
  "https://mcp.apify.com?tools=automation-lab/ryanair-flight-fares-cheapest-routes"
```

#### Claude Desktop, Cursor, and VS Code

Claude Desktop, Cursor, and VS Code can use this MCP server configuration:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/ryanair-flight-fares-cheapest-routes"
    }
  }
}
```

Example prompts:

- “Find the cheapest Ryanair dates from DUB to STN between today+7 and today+30.”
- “Compare up to five Ryanair destinations from BGY next month and return each route minimum.”
- “Run my saved Ryanair fare Task and summarize changes against yesterday's dataset.”

### Limits and expected behavior

- Only public Ryanair fare-calendar data is extracted.
- The Actor does not log in, book flights, hold inventory, or calculate baggage fees.
- Dates must be future dates and the requested range cannot exceed 180 days.
- Route-discovery mode checks only direct airport routes exposed by Ryanair and respects `maxRoutes`.
- Calendar fares may not include a flight number.
- `previousFare` can be null even when a current fare exists.
- Prices and availability can change between extraction and booking.
- A fare can differ by market, currency, passengers, promotion, or booking context.
- The Actor currently models one adult and one-way public calendar fares.
- An upstream error fails the run after bounded retries; it is not converted into an empty success.

### Troubleshooting

#### Why did the run return fewer records than days?

Unavailable dates are excluded by default, `maxItems` may have been reached, or Ryanair may expose no fare for some days.
Enable `includeUnavailable` to inspect calendar status rows.

#### Why is `flightNumber` null?

Ryanair's public Fare Finder calendar currently exposes schedule timestamps but often not the operating flight number.
The Actor keeps the field nullable and never guesses it.

#### Why is `previousFare` null?

That value depends on Ryanair including a `previousPrice` field in the current response.
Keep scheduled snapshots if you need a dependable historical comparison.

#### Why did an airport fail validation?

Use a three-letter active Ryanair airport IATA code.
The Actor rejects unknown airport codes after loading Ryanair's active airport list.

#### Why did a route produce no priced rows?

The route may not operate in the requested period, may be sold out, or may not have public calendar data in the selected market.
Try `includeUnavailable: true` and verify the route/date directly on Ryanair.

### Responsible use and legality

This Actor accesses public fare and airport information without a login.
Use it in accordance with applicable laws, Ryanair's terms, Apify's terms, and your organization's policies.

Do not use the output to mislead travelers, impersonate Ryanair, automate bookings, or evade access controls.
Respect reasonable run frequency and retain only data needed for a legitimate purpose.
Ryanair owns its trademarks and source data; this Actor is an independent extraction tool and is not affiliated with or endorsed by Ryanair.

### FAQ

#### Does the Actor need a proxy?

No proxy is used by the current implementation.
There is no automatic residential fallback.

#### Can it search round trips?

No.
The current product returns one-way public calendar fares.
Run separate outbound and inbound searches if that fits your analysis, but do not treat them as a guaranteed combined booking price.

#### Can it find the cheapest destination from an airport?

Yes, within the direct routes and limits requested.
Omit `arrivalIata`, set `maxRoutes`, and compare `routeLowestFare` across returned routes.

#### Can I schedule it?

Yes.
Use rolling dates such as `today+7` and `today+30` in an Apify Task, then attach a schedule and an integration.

#### Does it include baggage rules or carry-on size?

No.
The Actor extracts fare-calendar data, not Ryanair baggage policy content or ancillary fees.

#### Are prices guaranteed?

No.
Always verify price and availability on the linked Ryanair booking page before making a purchase or publishing a deal.

### Related automation-lab Actors

For broader travel research, combine fare snapshots with other public travel datasets from the [automation-lab Actor portfolio](https://apify.com/automation-lab).
Use each Actor's documented scope independently, and join records only when route, location, date, and currency semantics are compatible.

# Actor input Schema

## `departureIata` (type: `string`):

Three-letter IATA code for the departure airport, such as DUB, STN, or BGY.

## `arrivalIata` (type: `string`):

Three-letter destination IATA code. Leave empty to compare destinations exposed from the departure airport.

## `dateFrom` (type: `string`):

First travel date. Use YYYY-MM-DD, today, or today+N.

## `dateTo` (type: `string`):

Last travel date, up to 180 days after Date from. Use YYYY-MM-DD, today, or today+N.

## `maxItems` (type: `integer`):

Maximum number of matching fare-date records saved to the dataset.

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

Maximum destinations checked when Arrival airport is empty.

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

Three-letter fare currency. Defaults to the departure airport currency.

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

Market locale used for fares and booking links, such as en-ie or en-gb.

## `language` (type: `string`):

Two-letter language code for airport names.

## `includeUnavailable` (type: `boolean`):

Include sold-out or unavailable calendar rows, which can have a null fare.

## Actor input object example

```json
{
  "departureIata": "DUB",
  "dateFrom": "today+7",
  "dateTo": "today+30",
  "maxItems": 20,
  "maxRoutes": 10,
  "market": "en-ie",
  "language": "en",
  "includeUnavailable": false
}
```

# Actor output Schema

## `dataset` (type: `string`):

Current fares, schedules, availability, and cheapest options.

## `overview` (type: `string`):

Table view of the most useful fare fields.

# 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 = {
    "departureIata": "DUB",
    "dateFrom": "today+7",
    "dateTo": "today+30",
    "maxItems": 20,
    "maxRoutes": 10,
    "market": "en-ie",
    "language": "en",
    "includeUnavailable": false
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/ryanair-flight-fares-cheapest-routes").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 = {
    "departureIata": "DUB",
    "dateFrom": "today+7",
    "dateTo": "today+30",
    "maxItems": 20,
    "maxRoutes": 10,
    "market": "en-ie",
    "language": "en",
    "includeUnavailable": False,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/ryanair-flight-fares-cheapest-routes").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 '{
  "departureIata": "DUB",
  "dateFrom": "today+7",
  "dateTo": "today+30",
  "maxItems": 20,
  "maxRoutes": 10,
  "market": "en-ie",
  "language": "en",
  "includeUnavailable": false
}' |
apify call automation-lab/ryanair-flight-fares-cheapest-routes --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,automation-lab/ryanair-flight-fares-cheapest-routes"
        }
    }
}

```

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/E5jCG7ggSTp9D69m8/builds/6mdAClR0dXJTTOrHm/openapi.json