# Ryanair Scraper \[Only $1.5] Flight Fares & Cheapest Routes (`memo23/ryanair-scraper`) Actor

\[Only $1.5] Scrape Ryanair fares — cheapest one-way and round-trip prices by route and flexible date window, plus an explore mode that finds the cheapest fare to every destination from an origin. Returns price, flight number, schedule, duration, airports and booking links. Open data, no proxy

- **URL**: https://apify.com/memo23/ryanair-scraper.md
- **Developed by:** [Muhamed Didovic](https://apify.com/memo23) (community)
- **Categories:** Travel, AI, Agents
- **Stats:** 40 total users, 26 monthly users, 91.4% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 fare 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/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

**Pull Ryanair fares into a clean dataset — no account, no proxy, no hassle.** Give it a route and a flexible date window and get back the cheapest one-way and round-trip prices, or use **Explore mode** to find the cheapest fare to *every* destination from an origin. Each fare comes with price, flight number, schedule, duration, airports, and a ready-to-book link. JSON or CSV out, billed per result.

#### How it works

![How Ryanair Scraper works](https://raw.githubusercontent.com/muhamed-didovic/muhamed-didovic.github.io/main/assets/how-it-works-ryanair.png)

#### ✨ Why use this scraper?

Tracking flight prices? Building a fare-alert app? Researching routes? Ryanair's own site only lets you look one route at a time — this actor turns it into structured rows you can pipe anywhere, in bulk.

- ✈️ **Cheapest one-way fares** — for any route across a flexible date window (one cheapest fare per available day).
- 🛫 **All flights per day** — set `allFlights: true` and get **every scheduled departure** for each day (flight number, times, duration), with the day's cheapest fare attached — not just the cheapest flight.
- 🔁 **Round-trip combinations** — the cheapest outbound + inbound pairing across two date windows, with a combined total price.
- 🌍 **Explore mode (cheapest to anywhere)** — give it just an origin and a date window, and get the cheapest fare to **every** Ryanair destination. Perfect for "where can I fly cheap this weekend?".
- 🗓️ **Flexible date windows** — search a whole range, not just one day.
- 🔗 **Bookable links** — every fare row includes a Ryanair deep-link with your passenger mix pre-filled.
- 🪪 **No account, no proxy, no anti-bot** — runs straight out of the box.
- 💸 **The fares Google Flights misses** — Ryanair under-feeds Google/GDS, so these budget prices often aren't on the big aggregators.

#### 🎯 Use cases

| Team | What they build |
|------|-----------------|
| **Travel apps / OTAs** | Live Ryanair fare feeds for price comparison and alerts |
| **Price-monitoring** | Track a route's cheapest fare over time |
| **Content / deals sites** | "Cheapest flights from {city}" pages via Explore mode |
| **Data teams** | A structured budget-airline fare feed for dashboards |
| **Travellers** | Find the cheapest dates and destinations to fly |

#### 📥 Inputs

| Input | What you get |
|---|---|
| `origin` + `destination` + dates | cheapest **one-way** fares for that route across the window |
| `origin` + `destination` + dates, `allFlights: true` | **every scheduled flight** per day on that route (times + flight numbers, day's cheapest fare attached) |
| `origin` + `destination` + return dates, `tripType: roundTrip` | cheapest **round-trip** combinations |
| `origin` only (no `destination`) | **Explore** — cheapest fare to every destination |

Airports are IATA codes (e.g. `DUB`, `STN`, `BCN`). Comma-separate `origin`/`destination` for multiple routes in one run.

#### ⚙️ Input parameters

| Parameter | Type | Default | Description |
|---|---|---|---|
| `origin` | string | `DUB` | Origin airport IATA code(s), comma-separated. |
| `destination` | string | `STN` | Destination IATA code(s). **Leave empty for Explore mode.** |
| `tripType` | string | `oneWay` | `oneWay` or `roundTrip`. |
| `allFlights` | boolean | `false` | One-way fixed routes: every scheduled flight per day, not just the day's cheapest fare. |
| `departDateFrom` / `departDateTo` | string | today / +7d | Outbound date window (YYYY-MM-DD), up to 62 days per route per run. |
| `returnDateFrom` / `returnDateTo` | string | — | Inbound window (round-trip only). |
| `currency` | string | `EUR` | Price currency, e.g. `EUR`, `USD`, `GBP`. |
| `adults` / `teens` / `children` / `infants` | integer | `1`/`0`/`0`/`0` | Passenger mix (for the booking link). |
| `maxResults` | integer | `1000` | Hard cap on total fare rows. |

#### 📦 Output samples

```json
{ "tripType": "oneWay", "carrierCode": "FR", "carrierName": "Ryanair",
  "price": 14.98, "currency": "EUR", "flightNumber": "FR292",
  "fromCode": "DUB", "fromName": "Dublin", "toCode": "STN", "toName": "London Stansted",
  "departureDate": "2026-07-07T22:00:00", "arrivalDate": "2026-07-07T23:20:00",
  "durationMinutes": 80, "stops": 0, "bookingUrl": "https://www.ryanair.com/gb/en/trip/flights/select?..." }

{ "tripType": "oneWay", "carrierCode": "FR", "flightNumber": "FR202",
  "price": null, "currency": "EUR", "isDayCheapest": false,
  "dayCheapestPrice": 31.99, "dayCheapestFlightNumber": "FR30",
  "fromCode": "DUB", "toCode": "STN", "departureDate": "2026-09-01T11:30:00",
  "arrivalDate": "2026-09-01T12:50:00", "durationMinutes": 80, "stops": 0,
  "bookingUrl": "https://www.ryanair.com/gb/en/trip/flights/select?..." }

{ "tripType": "roundTrip", "carrierCode": "FR", "totalPrice": 58.98, "currency": "EUR",
  "fromCode": "DUB", "toCode": "STN",
  "outbound-price": 29.99, "outbound-flight-number": "FR292", "outbound-departure": "2026-07-01T07:10:00",
  "return-price": 28.99, "return-flight-number": "FR293", "return-departure": "2026-07-08T19:45:00",
  "bookingUrl": "https://www.ryanair.com/gb/en/trip/flights/select?...&isReturn=true" }
```

#### 🗂 Key output fields

| Mode | Fields |
|---|---|
| `oneWay` / explore | `price`, `currency`, `flightNumber`, `fromCode/fromName/fromCity/fromCountry`, `toCode/toName/toCity/toCountry`, `departureDate`, `arrivalDate`, `durationMinutes`, `stops`, `bookingUrl` |
| `allFlights` rows | all one-way fields plus `isDayCheapest`, `dayCheapestPrice`, `dayCheapestFlightNumber` (`price` is set on the day's cheapest flight only) |
| `roundTrip` | `totalPrice`, `currency`, `from*`/`to*`, `outbound-*` (price/flight-number/departure/arrival/duration), `return-*`, `bookingUrl` |

#### ❓ FAQ

**Do I need a Ryanair account or proxy?**
No — the actor uses Ryanair's open fares data. No login, no proxy, no captcha.

**Why do I only get one flight per day?**
By default the actor returns each day's **cheapest** fare per route — that's what Ryanair's fare-finder data exposes, and it's ideal for price tracking. Want the full timetable instead? Set `allFlights: true` on a one-way route and you get **every scheduled departure** per day with flight numbers and times. Ryanair's open data doesn't price each flight individually, so each row carries the day's cheapest fare (`dayCheapestPrice`) — the flight it belongs to has it as `price` and `isDayCheapest: true`.

**How long can the date window be?**
Up to **62 days (~2 months) per route per run** — longer windows are truncated. For a longer horizon, split it across runs (e.g. one run per 2-month block).

**What is Explore mode?**
Leave `destination` empty and the actor returns the cheapest fare to **every** Ryanair destination from your origin over the date window — ideal for "where can I fly cheap?" features.

**Why aren't these fares on Google Flights?**
Ryanair under-participates in Google/GDS feeds, so its budget fares are frequently missing from the big aggregators — this scrapes them directly from the source.

**How current are the prices?**
They're pulled live at run time. Re-run on a schedule to track fares over time.

#### 💬 Support

- Issues / feature requests: the **Issues** tab on the actor's Apify Console page.
- Author: <https://muhamed-didovic.github.io/> · <muhamed.didovic@gmail.com>

#### 🔎 Explore more scrapers

**✈️ More flight scrapers:**

- [Google Flights Scraper](https://apify.com/memo23/google-flights-scraper) — mainstream carrier fares, itineraries & multi-city
- [Skyscanner Flight Scraper](https://apify.com/memo23/skyscanner-scraper) — 180+ fields per itinerary, Best/Cheapest/Fastest tags, OTA aggregation
- [Award Flights Scraper](https://apify.com/memo23/award-flights-scraper) — miles & points award availability (Flightpoints + Roame)

Pair this with the Google Flights Scraper for full coverage (mainstream carriers + the budget fares Google misses). See [140+ other scrapers](https://apify.com/memo23) — travel, real estate, jobs, SEO, social media, and more.

***

### 🤖 For AI Agents & LLM Apps

Compact reference for AI agents calling this actor via the [Apify MCP server](https://mcp.apify.com) or the Apify API (actor: `memo23/ryanair-scraper`).

**Purpose:** Scrape Ryanair fares — cheapest one-way and round-trip prices for a route across a flexible date window, or Explore mode (cheapest fare to every destination from an origin). Returns the budget fares that Google/GDS aggregators often miss.

**Minimal input:**

```json
{ "origin": "DUB", "destination": "STN", "maxResults": 10 }
```

Explore mode (cheapest fare to anywhere): omit `destination` — `{ "origin": "DUB", "maxResults": 10 }`.

**Output:** one dataset row per fare. One-way / explore rows: `tripType`, `carrierCode`, `carrierName`, `price`, `currency`, `flightNumber`, `fromCode`, `fromName`, `fromCity`, `fromCountry`, `toCode`, `toName`, `toCity`, `toCountry`, `departureDate`, `arrivalDate`, `durationMinutes`, `stops`, `bookingUrl`. Round-trip rows: `totalPrice`, `currency`, `from*`/`to*`, `outbound-*` (price/flight-number/departure/arrival/duration), `return-*`, `bookingUrl`.

**Behaviors an agent should know:**

- Default behaviour returns **one cheapest fare per route per day**. Set `allFlights: true` (one-way fixed routes only) to get **every scheduled flight** per day; those rows add `isDayCheapest`, `dayCheapestPrice`, `dayCheapestFlightNumber`, and `price` is only set on the day's cheapest flight.
- Date windows are capped at **62 days per route per run** — split longer horizons across runs.
- Set `maxResults` to cap total rows (default `1000`); a wide date window across several routes can return a lot.
- `tripType: "roundTrip"` needs a `destination` plus `returnDateFrom`/`returnDateTo`; omitting `destination` triggers Explore mode regardless of `tripType`.
- `origin` and `destination` accept comma-separated IATA codes for multiple routes in one run.
- Dates default to today → +7 days when omitted; use `departDateFrom`/`departDateTo` (`YYYY-MM-DD`) to widen the window.
- No account, proxy, or anti-bot handling required — fares are pulled live from Ryanair's open fares data.
- Pay-per-result billing (per fare row) — see the Pricing tab on the actor page for the current rate.

***

### ⚠️ Disclaimer

This Actor is an independent tool and is not affiliated with, endorsed by, or sponsored by Ryanair DAC or any of its subsidiaries. All trademarks are the property of their respective owners. The scraper accesses only publicly available fare data; users are responsible for ensuring their use complies with Ryanair's Terms of Service and applicable law (GDPR, etc.).

***

### SEO Keywords

ryanair scraper, scrape ryanair, ryanair fares api, ryanair price scraper, ryanair flight scraper, cheapest ryanair flights, ryanair fare finder, flight price scraper, low cost carrier scraper, budget flight scraper, ryanair one way fares, ryanair round trip, ryanair timetable scraper, ryanair flight schedule, all ryanair flights per day, flight price monitoring, fare alert api, cheapest flights to anywhere, ryanair deals scraper, flight data api, airfare scraper, europe flight prices, ryanair booking links

# Actor input Schema

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

Origin airport IATA code. Comma-separate for several origins (e.g. `DUB,STN`).

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

Destination airport IATA code(s), comma-separated. **Leave empty for Explore mode** — the cheapest one-way fare to every destination from the origin.

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

`oneWay` (default) or `roundTrip`. Round-trip combines the cheapest outbound + inbound fares and needs a destination + return date window.

## `allFlights` (type: `boolean`):

One-way fixed routes only. Return EVERY scheduled flight for each day in the window — flight number, departure/arrival times — instead of one cheapest fare per day. Ryanair's open fares data doesn't price each flight individually, so every row carries the day's cheapest fare as `dayCheapestPrice`, and the flight it belongs to has it as `price` with `isDayCheapest: true`. Expect several times more rows on busy routes.

## `departDateFrom` (type: `string`):

Earliest outbound date (YYYY-MM-DD). Defaults to today.

## `departDateTo` (type: `string`):

Latest outbound date (YYYY-MM-DD). Defaults to 7 days after the start.

## `returnDateFrom` (type: `string`):

Earliest inbound date (YYYY-MM-DD). Required for round-trip.

## `returnDateTo` (type: `string`):

Latest inbound date (YYYY-MM-DD).

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

Currency code for prices, e.g. `EUR`, `USD`, `GBP`.

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

Ryanair market the fares are priced for, e.g. `en-gb`, `en-ie`, `es-es`, `de-de`.

## `maxPrice` (type: `integer`):

Keep only fares at or below this price (in the chosen currency). Leave empty for no limit.

## `sortBy` (type: `string`):

Order the saved fares. Options: `sourceOrder` (default), `cheapest`, `earliestDeparture`, `shortestDuration`.

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

Also emit a row (with `price: null`, `available: false`) for dates that have no Ryanair fare — useful for a complete date calendar.

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

Number of adults (used for the booking deep-link).

## `teens` (type: `integer`):

Number of teens (12–15).

## `children` (type: `integer`):

Number of children (2–11).

## `infants` (type: `integer`):

Number of infants (under 2).

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

Hard cap on the total number of fare rows returned.

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

Optional. Ryanair's fares API is open, so a proxy isn't required — but for very large multi-route or wide-window runs you can route requests through a proxy to avoid IP rate-limits. Paying users are automatically routed through premium rotating residential proxies.

## Actor input object example

```json
{
  "origin": "DUB",
  "destination": "STN",
  "tripType": "oneWay",
  "allFlights": false,
  "currency": "EUR",
  "market": "en-gb",
  "sortBy": "sourceOrder",
  "includeUnavailable": false,
  "adults": 1,
  "teens": 0,
  "children": 0,
  "infants": 0,
  "maxResults": 1000,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# 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",
    "destination": "STN"
};

// Run the Actor and wait for it to finish
const run = await client.actor("memo23/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",
    "destination": "STN",
}

# Run the Actor and wait for it to finish
run = client.actor("memo23/ryanair-scraper").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "origin": "DUB",
  "destination": "STN"
}' |
apify call memo23/ryanair-scraper --silent --output-dataset

```

## MCP server setup

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

```

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

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/CNqShsJIZyAw8WP1v/builds/2wIdVhzObxSdmZQna/openapi.json