# Ryanair Flights Scraper - Fares and Routes (`benthepythondev/ryanair-flights-scraper`) Actor

Find Ryanair's cheapest public one-way fares by origin, destination and flexible date window. Export price, schedule, airport metadata, flight number and booking URL.

- **URL**: https://apify.com/benthepythondev/ryanair-flights-scraper.md
- **Developed by:** [Ben](https://apify.com/benthepythondev) (community)
- **Categories:** Travel, Business, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.50 / 1,000 results

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 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

## Ryanair Flights Scraper - Fares and Routes

Find Ryanair's cheapest public one-way fares for a route or discover the lowest-priced destination from an origin airport. The Actor turns Ryanair's live fare-search response into a clean dataset with prices, dates, flight numbers, airport details, and a direct booking URL. It runs through lightweight HTTP requests, needs no airline account, and can export results to JSON, CSV, Excel, XML, or an API integration.

### What this Actor is for

Ryanair serves hundreds of airports, but comparing flexible dates and many destination options manually is slow. This Actor is designed for travel research workflows that need repeatable structured fare data rather than screenshots or copied search pages.

Common uses include:

- finding the cheapest Ryanair destination from a chosen airport;
- monitoring a specific route over rolling date windows;
- building low-fare alerts in Make, Zapier, n8n, or a custom service;
- comparing departure airports for a planned trip;
- feeding fare observations into a travel dashboard or spreadsheet;
- researching seasonal route and price patterns;
- enriching destination content with current example fares.

The source endpoint returns the cheapest available fare for each matching route in the selected window. It is a fare-discovery dataset, not a full inventory of every seat or fare class on every flight.

### Input

Set one or more three-letter departure airport codes. Destination codes are optional: leave them empty to explore the cheapest destination options from each origin, or add one or more codes to narrow the search.

```json
{
  "departureAirports": ["SOF"],
  "arrivalAirports": ["BRS"],
  "daysAheadStart": 1,
  "daysAheadEnd": 30,
  "currency": "EUR",
  "market": "en-gb",
  "maxResultsPerOrigin": 20
}
````

You can use relative dates for scheduled monitoring or supply exact `dateFrom` and `dateTo` values in `YYYY-MM-DD` format. Relative dates make saved Tasks durable because the search window moves forward automatically each day.

#### Input fields

| Field | Description |
|---|---|
| `departureAirports` | One or more three-letter origin airport codes. |
| `arrivalAirports` | Optional destination codes. Empty means cheapest-destination discovery. |
| `dateFrom` | Optional exact search start date. |
| `dateTo` | Optional exact search end date. |
| `daysAheadStart` | Relative start when `dateFrom` is empty. |
| `daysAheadEnd` | Relative end when `dateTo` is empty. |
| `currency` | Three-letter display currency such as `EUR` or `GBP`. |
| `market` | Ryanair language-market code such as `en-gb` or `de-de`. |
| `maxResultsPerOrigin` | Safety limit for each route-search request. |

### Output

Each dataset item represents one unique cheapest-fare observation. Core fields include:

- `flight_number` and Ryanair's source flight key;
- local departure and arrival timestamps;
- travel date;
- current and previous price when available;
- currency code and symbol;
- departure and arrival airport code, name, city, and country;
- airport coordinates and time zone from Ryanair's public airport directory;
- source search window and requested route;
- direct Ryanair booking URL;
- price-update timestamp and scrape timestamp;
- `rank_by_price` across the final unique result set.

Example item:

```json
{
  "flight_number": "FR4130",
  "departure_airport_code": "SOF",
  "departure_city": "Sofia",
  "arrival_airport_code": "BRS",
  "arrival_city": "Bristol",
  "departure_at_local": "2026-07-18T22:55:00",
  "arrival_at_local": "2026-07-19T00:25:00",
  "price": 14.99,
  "currency": "EUR",
  "rank_by_price": 1,
  "booking_url": "https://www.ryanair.com/gb/en/trip/flights/select?..."
}
```

### Run it on a schedule

Use an Apify Task with relative day settings to create a rolling monitor. A daily Task can look 1-30 days ahead, write each result to the dataset, and trigger a webhook when a route drops below your chosen price. Keep historical datasets if you want to calculate price movement over time.

For multiple origins, use a short bounded list and let each run complete before scheduling the next. The Actor validates airport-code shape, date order, maximum date span, and request count to prevent accidental oversized runs.

### Integrations

The default dataset is available through the Apify API and native integrations. Typical workflows are:

1. schedule a daily Task;
2. retrieve dataset items in n8n, Make, Zapier, or Python;
3. filter by destination, date, or maximum price;
4. send an email, Slack message, Telegram alert, or database update;
5. retain observations for route-level trend analysis.

### Pricing

This Actor uses pay-per-event pricing: a small start event plus a charge for each unique fare saved to the default dataset. Duplicate source rows are removed before storage, so repeated entries are not billed twice in one run. Apify compute and proxy usage, if any, follows the platform plan of the account running the Actor.

### Reliability and scope

The Actor uses Ryanair's public website APIs with browser-compatible request headers and bounded retries. No browser or residential proxy is required for the normal data path. The default input uses a small live search and relative dates so Apify's automated checks can keep validating non-empty output.

Fares are live observations and can change at any time. Availability, taxes, optional services, passenger-specific pricing, exchange rates, and final checkout conditions may change the amount shown during booking. Always verify a fare on Ryanair before making a purchase decision.

### FAQ

#### Does this book flights?

No. It collects public fare observations and provides a booking URL. Payment and booking remain on Ryanair.

#### Can I search without a destination?

Yes. Leave `arrivalAirports` empty to discover the cheapest available route options from each departure airport.

#### Can I monitor exact dates?

Yes. Set `dateFrom` and `dateTo`. For recurring Tasks, relative day settings are usually better because they do not expire.

#### Does it return every flight in the date range?

No. The public fare-finder response focuses on cheapest route options. This Actor accurately preserves that scope instead of presenting the result as complete schedule inventory.

#### Why might a search return no rows?

The airport may not be served by Ryanair, the route may not operate in the selected window, or the supplied currency/market combination may be unavailable. Expand the window or verify the airport codes.

#### Can I export to CSV or Excel?

Yes. Open the run dataset and choose JSON, CSV, Excel, XML, RSS, or the API endpoint.

#### Is an API key required?

No airline API key or account is required.

#### How do I report an issue?

Open an issue on the Actor page with the input that failed and the run ID. If the Actor saved you time, a Store review helps other users evaluate it and helps prioritize ongoing maintenance.

### You might also like

- [Google Flights Search Scraper](https://apify.com/store?search=google%20flights)
- [Flight Data Scrapers](https://apify.com/store?search=flight%20data)
- [Travel and Hotel Scrapers](https://apify.com/store?search=travel%20scraper)

**Keywords:** Ryanair scraper, Ryanair API, flight fare scraper, cheap flights API, airline price monitor, flexible date flight search, Ryanair routes, airfare dataset, flight price alerts, travel data scraper

# Actor input Schema

## `departureAirports` (type: `array`):

Three-letter Ryanair departure airport codes. Each origin is searched independently.

## `arrivalAirports` (type: `array`):

Optional destination codes. Leave empty to discover the cheapest destination from each origin.

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

Optional YYYY-MM-DD start date. Leave empty to use the relative day setting.

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

Optional YYYY-MM-DD end date. Leave empty to use the relative day setting.

## `daysAheadStart` (type: `integer`):

Used when no exact start date is supplied.

## `daysAheadEnd` (type: `integer`):

Used when no exact end date is supplied.

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

Three-letter display currency, for example EUR or GBP.

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

Language-market code used by Ryanair, for example en-gb, de-de, or it-it.

## `maxResultsPerOrigin` (type: `integer`):

Maximum cheapest-fare rows retained for each origin/destination search.

## Actor input object example

```json
{
  "departureAirports": [
    "SOF",
    "BER"
  ],
  "arrivalAirports": [
    "BRS"
  ],
  "dateFrom": "",
  "dateTo": "",
  "daysAheadStart": 1,
  "daysAheadEnd": 30,
  "currency": "EUR",
  "market": "en-gb",
  "maxResultsPerOrigin": 20
}
```

# Actor output Schema

## `results` (type: `string`):

No description

# 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 = {
    "departureAirports": [
        "SOF",
        "BER"
    ],
    "arrivalAirports": [
        "BRS"
    ],
    "daysAheadStart": 1,
    "daysAheadEnd": 30,
    "currency": "EUR",
    "market": "en-gb",
    "maxResultsPerOrigin": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("benthepythondev/ryanair-flights-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 = {
    "departureAirports": [
        "SOF",
        "BER",
    ],
    "arrivalAirports": ["BRS"],
    "daysAheadStart": 1,
    "daysAheadEnd": 30,
    "currency": "EUR",
    "market": "en-gb",
    "maxResultsPerOrigin": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("benthepythondev/ryanair-flights-scraper").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 '{
  "departureAirports": [
    "SOF",
    "BER"
  ],
  "arrivalAirports": [
    "BRS"
  ],
  "daysAheadStart": 1,
  "daysAheadEnd": 30,
  "currency": "EUR",
  "market": "en-gb",
  "maxResultsPerOrigin": 20
}' |
apify call benthepythondev/ryanair-flights-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Ryanair Flights Scraper - Fares and Routes",
        "description": "Find Ryanair's cheapest public one-way fares by origin, destination and flexible date window. Export price, schedule, airport metadata, flight number and booking URL.",
        "version": "1.0",
        "x-build-id": "hhGwf7zRaCe36Gkp9"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/benthepythondev~ryanair-flights-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-benthepythondev-ryanair-flights-scraper",
                "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/benthepythondev~ryanair-flights-scraper/runs": {
            "post": {
                "operationId": "runs-sync-benthepythondev-ryanair-flights-scraper",
                "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/benthepythondev~ryanair-flights-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-benthepythondev-ryanair-flights-scraper",
                "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": [
                    "departureAirports"
                ],
                "properties": {
                    "departureAirports": {
                        "title": "Departure airport codes",
                        "type": "array",
                        "description": "Three-letter Ryanair departure airport codes. Each origin is searched independently.",
                        "default": [
                            "SOF"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "arrivalAirports": {
                        "title": "Arrival airport codes",
                        "type": "array",
                        "description": "Optional destination codes. Leave empty to discover the cheapest destination from each origin.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "dateFrom": {
                        "title": "Exact start date (optional)",
                        "type": "string",
                        "description": "Optional YYYY-MM-DD start date. Leave empty to use the relative day setting.",
                        "default": ""
                    },
                    "dateTo": {
                        "title": "Exact end date (optional)",
                        "type": "string",
                        "description": "Optional YYYY-MM-DD end date. Leave empty to use the relative day setting.",
                        "default": ""
                    },
                    "daysAheadStart": {
                        "title": "Relative start (days ahead)",
                        "minimum": 0,
                        "maximum": 365,
                        "type": "integer",
                        "description": "Used when no exact start date is supplied.",
                        "default": 1
                    },
                    "daysAheadEnd": {
                        "title": "Relative end (days ahead)",
                        "minimum": 0,
                        "maximum": 365,
                        "type": "integer",
                        "description": "Used when no exact end date is supplied.",
                        "default": 30
                    },
                    "currency": {
                        "title": "Currency",
                        "type": "string",
                        "description": "Three-letter display currency, for example EUR or GBP.",
                        "default": "EUR"
                    },
                    "market": {
                        "title": "Ryanair market",
                        "type": "string",
                        "description": "Language-market code used by Ryanair, for example en-gb, de-de, or it-it.",
                        "default": "en-gb"
                    },
                    "maxResultsPerOrigin": {
                        "title": "Maximum fares per route search",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum cheapest-fare rows retained for each origin/destination search.",
                        "default": 20
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
