# Ryanair Scraper — Flight Prices & Availability (`studio-amba/ryanair-scraper`) Actor

Scrape live flight prices and availability from Ryanair's public fare-finder: routes, flight numbers, departure/arrival times, and daily price calendars for any origin airport, date range, and one-way or round-trip search.

- **URL**: https://apify.com/studio-amba/ryanair-scraper.md
- **Developed by:** [Studio Amba](https://apify.com/studio-amba) (community)
- **Categories:** Travel
- **Stats:** 1 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 1,000 result scrapeds

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

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

# README

### What does Ryanair Scraper do?

**Ryanair Scraper** extracts live flight prices and availability directly
from [Ryanair's](https://www.ryanair.com) public fare-finder API — the same
data that powers the fare search on ryanair.com. Give it an origin airport
and it returns the cheapest fares to every destination Ryanair flies there,
or set a destination too and get a day-by-day price calendar for that exact
route. No login or booking session required.

Use it to collect structured flight data via the Apify platform with full
**API access, scheduling, integrations**, and no need to run a browser
yourself — Ryanair's fare-finder is a plain JSON API with no anti-bot
protection, so this actor is fast and cheap to run.

### Why use Ryanair Scraper?

- **Price monitoring** — Track fares on specific routes over time and catch
  price drops before they disappear
- **Cheapest-day finder** — See a full month's price calendar for a route to
  spot the cheapest day to fly
- **Route research** — Discover every destination Ryanair flies from a given
  airport and compare prices in one pass
- **Fare analytics** — Build datasets for route pricing trends, seasonality,
  and demand signals
- **Meta-search / travel apps** — Feed live Ryanair pricing into your own
  booking tool or comparison site
- **Corporate travel** — Check fares for upcoming business trips in bulk

### How to use Ryanair Scraper

1. Go to the **Input** tab
2. Enter an **Origin airport** IATA code (e.g. `DUB`, `STN`, `BCN`)
3. Optionally enter a **Destination airport** — leave it empty to explore
   fares to every destination from the origin, or set it to get a daily
   price calendar for that one route
4. Set a **Departure date from/to** range, and optionally a return date
   range for round-trip searches
5. Click **Start** and wait for the run to finish
6. Download your data from the **Output** tab in JSON, CSV, Excel, or other
   formats

### Input

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `origin` | String | No | Departure airport IATA code (default: `DUB`) |
| `destination` | String | No | Arrival airport IATA code. Leave empty for explorer mode (default) |
| `tripType` | String | No | `oneway` or `roundtrip` (default: `oneway`) |
| `dateFrom` | String | No | Start of the outbound date window, `YYYY-MM-DD` (default: 7 days out) |
| `dateTo` | String | No | End of the outbound date window, `YYYY-MM-DD` (default: 30 days after `dateFrom`) |
| `inboundDateFrom` | String | No | Start of the return date window, round-trip only |
| `inboundDateTo` | String | No | End of the return date window, round-trip only |
| `currency` | String | No | Price currency code, e.g. `EUR`, `GBP`, `PLN` (default: `EUR`) |
| `market` | String | No | Ryanair language-market pair, e.g. `en-ie`, `de-de` (default: `en-ie`) |
| `maxResults` | Integer | No | Maximum fare results to return (default: 200) |

#### Two search modes

**Explorer mode** (no `destination` set): one API call returns the cheapest
fare to every destination Ryanair flies from `origin` within the date range.
Fast, and this is what runs when you use the default input. Rows include the
real flight number and exact departure/arrival time for the cheapest flight
found.

**Route calendar mode** (`destination` set): scans day-by-day pricing for
that exact route across the date range (up to 3 calendar months per run, to
keep run time bounded). Each row is one day, with price and an `available`
flag reflecting whether Ryanair reports that day as sold out. Flight numbers
aren't exposed by this calendar endpoint — most Ryanair routes only operate
one rotation a day, so the day itself is effectively the flight.

### Output

| Field | Type | Example |
|-------|------|---------|
| `route` | String | `"DUB-BCN"` |
| `origin` / `destination` | String | `"DUB"` / `"BCN"` |
| `originName` / `destinationName` | String | `"Dublin"` / `"Barcelona"` |
| `tripType` | String | `"oneway"` |
| `leg` | String | `"outbound"`, `"inbound"`, or `"both"` (round-trip pair) |
| `outboundFlightNumber` | String or null | `"FR6395"` |
| `outboundDepartureTime` / `outboundArrivalTime` | String | `"2026-08-04T21:45:00"` |
| `inboundFlightNumber` | String or null | `"FR509"` (round-trip only) |
| `price` | Number | `24.99` |
| `currency` | String | `"EUR"` |
| `previousPrice` | Number or null | `29.99` |
| `fareClass` | String | `"REGULAR"` |
| `available` | Boolean | `true` |
| `searchDate` | String or null | `"2026-08-04"` (route-calendar mode only) |
| `url` | String | Deep link to book on ryanair.com |

### Example output

```json
{
    "route": "DUB-BCN",
    "origin": "DUB",
    "originName": "Dublin",
    "destination": "BCN",
    "destinationName": "Barcelona",
    "tripType": "oneway",
    "leg": "outbound",
    "outboundFlightNumber": "FR6395",
    "outboundDepartureTime": "2026-08-04T21:45:00",
    "outboundArrivalTime": "2026-08-05T01:15:00",
    "inboundFlightNumber": null,
    "inboundDepartureTime": null,
    "inboundArrivalTime": null,
    "price": 24.99,
    "currency": "EUR",
    "previousPrice": null,
    "fareClass": "REGULAR",
    "available": true,
    "searchDate": null,
    "dateRangeFrom": "2026-08-01",
    "dateRangeTo": "2026-09-15",
    "url": "https://www.ryanair.com/ie/en/trip/flights/select?adults=1&teens=0&children=0&infants=0&dateOut=2026-08-04&originIata=DUB&destinationIata=BCN",
    "scrapedAt": "2026-07-16T19:22:04.438Z"
}
```

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

Ryanair's fare-finder is a plain public JSON API with no anti-bot layer, so
this actor makes lightweight direct HTTP requests — no browser, no residential
proxy needed for normal use. One explorer-mode run (all destinations from an
origin) is a single request; a route-calendar run makes one request per
calendar month scanned (max 3). This is one of the cheapest actor types to
run — expect a large multiple of results per $1 of Apify platform credits
compared to browser-based scrapers. The Apify Free plan includes $5 of
monthly credits.

### Limitations

- **Explorer mode gives one fare per destination.** It returns Ryanair's
  cheapest fare to each destination within your date window, not every
  flight on every day. Use route-calendar mode (set a destination) for a
  full daily price breakdown on one route.
- **No fare-bundle breakdown.** Ryanair's public fare-finder only exposes
  its single standard fare price — "Plus"/"Flexi" bundle upgrades require an
  authenticated booking session that isn't publicly accessible, so
  `fareClass` is always `"REGULAR"`.
- **No flight numbers in route-calendar mode.** The day-by-day calendar
  endpoint doesn't return flight numbers, only price and availability per
  day.
- **Round-trip route calendar covers one month per leg.** To keep run time
  bounded, round-trip calendar mode scans the outbound leg across up to 3
  months but the inbound leg only for the month containing
  `inboundDateFrom`.
- Data is scraped from the public website and may change without notice.
- Respect Ryanair's terms of service and use responsibly.

### FAQ and support

**Is it legal to scrape Ryanair?**
Ryanair Scraper accesses only publicly available fare-finder data that any
visitor can retrieve without logging in or bypassing payment. Always review
and comply with the target website's Terms of Service before use.

**Why does explorer mode only show one flight per destination?**
Ryanair's fare-finder API returns the single cheapest fare per destination
when searching across a date range without a specific day. To see every day
on a route, set a `destination` and use route-calendar mode instead.

**I found a bug or need help**
Please submit an issue on the [Issues tab](https://console.apify.com/actors/ryanair-scraper/issues) and we'll get back to you quickly. For custom scraping solutions, reach out via the same channel.

### How to scrape Ryanair data

1. Go to this actor's page on the [Apify Store](https://apify.com/store).
2. Click **Try for free** to open it in Apify Console.
3. Enter your origin airport, and optionally a destination and date range.
4. Choose one-way or round-trip, and set currency if you need something
   other than EUR.
5. Click **Start** and wait for the run to finish — most runs complete in
   under a minute.
6. Download your data in JSON, CSV, Excel, or connect it to your workflow
   via the Apify API.

You can also schedule daily runs to track fares on a route over time, or
integrate results directly into your own booking or comparison tool using
the [Apify API](https://docs.apify.com/api).

### Need this data on a schedule, or a custom version?

We run this scraper as a managed service for businesses: scheduled runs,
price-drop alerts, delta detection, and delivery to your inbox, Google
Sheets, or API — maintenance included. We can also build a custom version
with multi-airport sweeps, seat-map data, or your exact fields.

See [studioamba.dev/services](https://studioamba.dev/services/) or email
<hello@studioamba.dev> for a free data sample.
We maintain 300+ European web scrapers and answer within one business day.

# Actor input Schema

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

Departure airport IATA code (e.g. 'DUB' for Dublin, 'STN' for London Stansted, 'BCN' for Barcelona).

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

Arrival airport IATA code (e.g. 'BCN' for Barcelona). Leave empty to explore the cheapest fare to every destination Ryanair flies from the origin — this is the default behaviour.

## `tripType` (type: `string`):

One-way or round-trip search.

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

Start of the outbound departure date window, in YYYY-MM-DD format.

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

End of the outbound departure date window, in YYYY-MM-DD format. With a destination set, this can span multiple months (up to 3 are scanned per run) to build a daily price calendar.

## `inboundDateFrom` (type: `string`):

Start of the return/inbound departure date window, in YYYY-MM-DD format. Only used when Trip type is 'roundtrip'.

## `inboundDateTo` (type: `string`):

End of the return/inbound departure date window, in YYYY-MM-DD format. Only used when Trip type is 'roundtrip'.

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

Currency code for prices (e.g. EUR, GBP, PLN, SEK).

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

Ryanair language-market pair, controls language of airport names and the booking URL locale (e.g. 'en-ie', 'en-gb', 'de-de', 'es-es').

## `maxResults` (type: `integer`):

Maximum number of fare results to return. In explorer mode (no destination) this caps how many destinations are returned; in route-calendar mode (destination set) it caps how many day-fares are returned.

## `proxyConfiguration` (type: `object`):

Optional. Ryanair's fare-finder API is publicly accessible with no anti-bot protection, so this actor works without a proxy by default. Kept for high-volume use or if Ryanair adds rate-limiting later.

## Actor input object example

```json
{
  "origin": "DUB",
  "tripType": "oneway",
  "dateFrom": "2026-07-30",
  "dateTo": "2026-08-29",
  "currency": "EUR",
  "market": "en-ie",
  "maxResults": 20,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# 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 = {
    "origin": "DUB",
    "tripType": "oneway",
    "dateFrom": "2026-07-30",
    "dateTo": "2026-08-29",
    "currency": "EUR",
    "market": "en-ie",
    "maxResults": 20,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("studio-amba/ryanair-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 = {
    "origin": "DUB",
    "tripType": "oneway",
    "dateFrom": "2026-07-30",
    "dateTo": "2026-08-29",
    "currency": "EUR",
    "market": "en-ie",
    "maxResults": 20,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("studio-amba/ryanair-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 '{
  "origin": "DUB",
  "tripType": "oneway",
  "dateFrom": "2026-07-30",
  "dateTo": "2026-08-29",
  "currency": "EUR",
  "market": "en-ie",
  "maxResults": 20,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call studio-amba/ryanair-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/acts/NJl5wQOvruKlMzUGw/builds/m9Yvwc0dI0QtrVaXF/openapi.json