# Ryanair API — Cheap Flight Fares & Prices | $0.99/1k (`glasswing/ryanair-flights-scraper`) Actor Cheapest Ryanair fares from any airport or route: one row per flight with date, price, currency, departure and arrival airports and times, and a booking link. Search by airport, route or date range, cap the price. No login, no API key. Export CSV, JSON or Excel. - **URL**: https://apify.com/glasswing/ryanair-flights-scraper.md - **Developed by:** [Raffy](https://apify.com/glasswing) (community) - **Categories:** Travel, E-commerce, Developer tools - **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks - **User rating**: No ratings yet ## Pricing from $0.99 / 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/actors/running/actors-in-store.md#pay-per-event ## What's an Apify Actor? An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes. 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. Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md. ## 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. Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run. For examples already wired to this Actor's own input schema, see the [API](#api) section below. Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`). # README ### What does Ryanair Flight Fares do? Ryanair Flight Fares extracts **cheap flight prices** from [Ryanair](https://www.ryanair.com/) and delivers them as clean, structured JSON, CSV or Excel. It works as a **Ryanair API alternative**: give it a departure airport (`STN`) or a route (`DUB-STN`) and a date window, and get the cheapest one-way fare for every destination back in seconds, without a browser, without residential proxies and without writing a scraper yourself. Typical use cases: - Run a travel-deal site or newsletter that needs today's cheapest fares out of a set of airports. - Monitor one route over time and alert when the price drops below a threshold. - Research where an airport can be reached from cheaply this month, for route planning or content. It does **not** log in, read paywalled content or collect private user data. It reads only the airline's publicly available fare finder. ### Why use Ryanair Flight Fares? - **Fast and cheap.** Pure HTTP extraction (no headless browser), so runs finish in seconds and cost fractions of a cent per fare. The default run returns 20 fares in about 9 seconds. - **Honest results.** Every row carries a `status` (`ok`, `not_found`, `error`), so you (or an AI agent calling this Actor) can tell "no fares in that window" apart from "the site could not be read". You are only billed for `ok` rows. - **Runs anywhere Apify runs.** Schedule it, call it from the API, chain it with other Actors, or receive results via integrations (Google Sheets, Slack, webhooks, Zapier, Make). - **Every row is bookable.** The `url` of each row is the airline's own booking page for exactly that flight and date, so a result goes straight into a deal post or an alert. ### What data can Ryanair Flight Fares extract? | Field | Type | Description | |---|---|---| | `departureAirport` | string | IATA code of the departure airport, e.g. `STN` | | `departureAirportName` | string | Departure airport name, e.g. `London Stansted` | | `departureCity` | string | City the departure airport serves | | `departureCountry` | string | Country of the departure airport | | `arrivalAirport` | string | IATA code of the arrival airport, e.g. `AHO` | | `arrivalAirportName` | string | Arrival airport name, e.g. `Alghero` | | `arrivalCity` | string | City the arrival airport serves | | `arrivalCountry` | string | Country of the arrival airport | | `departureDateTime` | string | Local departure time at the departure airport (ISO 8601, no zone) | | `arrivalDateTime` | string | Local arrival time at the arrival airport (ISO 8601, no zone) | | `flightNumber` | string | Flight number, e.g. `FR230` | | `price` | number | Cheapest one-way fare found for that route and date | | `currency` | string | ISO 4217 currency code, e.g. `GBP` | | `previousPrice` | number | The fare before the latest change, when the airline reports one | | `newRoute` | boolean | `true` when the airline flags the route as newly launched | | `priceUpdated` | string | ISO 8601 time the airline last repriced the fare | | `url` | string | Booking page for this exact flight | | `status` | string | `ok`, `not_found` or `error` (see below) | | `error` | string | Reason when `status` is not `ok` | | `scrapedAt` | string | ISO 8601 time of extraction | One row is the cheapest fare found for one destination inside your date window, which is how the airline's own fare finder answers. #### Result status (tri-state output) | `status` | Meaning | Billed? | |---|---|---| | `ok` | The fare was found and extracted. | Yes | | `not_found` | Ryanair answered, but has no fares for that airport, route or date window (including an airport it does not serve). | No | | `error` | Ryanair could not be read after retries (network error, block, or API change). `error` says why. | No | ### How to scrape Ryanair with Ryanair Flight Fares 1. Open the Actor in Apify Console and click **Try for free**. 2. Type one or more departure airports into **Airports or routes** as IATA codes (`STN`, `DUB-STN`), or type one into **Search query**. 3. Optionally set **Earliest/Latest departure date**, a **Market** (sets the booking link's language, e.g. `.com/gb/en/...`) and a **Maximum fare**. 4. Set **Maximum results** (start with the default 20 to see the output) and click **Start**. The run takes about 10 seconds for the default input. 5. Open the **Output** tab or **Export** the dataset as JSON, CSV, Excel, XML or HTML. To automate it, use the **API** tab (Node.js, Python, curl examples) or add a **Schedule**. ### How much does it cost to scrape Ryanair? This Actor uses **pay-per-event** pricing: | Event | Price | |---|---| | Actor start | $0.005 per run | | Result (`status: ok` row) | $0.00099 per fare | Example: 1,000 fares cost about $1.00 ($0.005 to start plus 1,000 x $0.00099). Rows with `status` `not_found` or `error` are never billed. Platform compute is included, so the start fee and the price per result are the whole price list. The free Apify plan's $5 of monthly credit covers about 5,000 fares in a single run. You can cap spending per run with **Maximum results** and in the run's **Max total charge** option. ### Input See the **Input** tab for the full schema. The main options: | Field | Type | Default | Description | |---|---|---|---| | `startUrls` | array of strings | `["STN"]` | Departure airports (`STN`), routes (`STN-ALC`) or ready-made fare-finder URLs | | `query` | string | - | One airport or route, used instead of the list above | | `dateFrom` | string | a week from today | Earliest outbound departure date, `YYYY-MM-DD` | | `dateTo` | string | 30 days after `dateFrom` | Latest outbound departure date, `YYYY-MM-DD` | | `market` | string | `en-gb` | Booking-link locale, e.g. `en-gb` for a `.com/gb/en/...` link. Does **not** change `currency` — that follows the departure airport's own country. | | `maxPrice` | integer | - | Only return fares at or below this amount, in whatever currency the departure airport's fares are quoted in | | `maxItems` | integer | `20` | Stop after this many rows | | `proxyConfiguration` | object | Apify Proxy off | Optional; datacenter proxy is enough if needed | Example input: ```json { "startUrls": ["STN", "DUB-STN"], "dateFrom": "2026-11-10", "dateTo": "2026-12-10", "market": "en-gb", "maxPrice": 40, "maxItems": 20 } ``` ### Output You can download the dataset in various formats such as JSON, HTML, CSV or Excel. Example rows, taken from a real run: ```json [ { "url": "https://www.ryanair.com/gb/en/trip/flights/select?adults=1&dateOut=2026-10-11&originIata=STN&destinationIata=AHO&isConnectedFlight=false&isReturn=false", "status": "ok", "scrapedAt": "2026-09-25T01:14:01.402Z", "departureAirport": "STN", "departureAirportName": "London Stansted", "departureCity": "London", "departureCountry": "United Kingdom", "arrivalAirport": "AHO", "arrivalAirportName": "Alghero", "arrivalCity": "Alghero", "arrivalCountry": "Italy", "departureDateTime": "2026-10-11T06:25:00", "arrivalDateTime": "2026-10-11T09:55:00", "flightNumber": "FR230", "price": 14.99, "currency": "GBP", "newRoute": false, "priceUpdated": "2026-09-25T00:19:49.000Z" }, { "url": "https://www.ryanair.com/gb/en/trip/flights/select?adults=1&dateOut=2026-10-07&originIata=STN&destinationIata=AOI&isConnectedFlight=false&isReturn=false", "status": "ok", "scrapedAt": "2026-09-25T01:14:01.402Z", "departureAirport": "STN", "departureAirportName": "London Stansted", "departureCity": "London", "departureCountry": "United Kingdom", "arrivalAirport": "AOI", "arrivalAirportName": "Ancona", "arrivalCity": "Ancona", "arrivalCountry": "Italy", "departureDateTime": "2026-10-07T06:35:00", "arrivalDateTime": "2026-10-07T09:50:00", "flightNumber": "FR124", "price": 14.99, "currency": "GBP", "newRoute": false, "priceUpdated": "2026-09-25T00:20:18.000Z" } ] ``` ### Tips - Keep `maxItems` small while testing, then raise it. - Pass several airports in one run instead of many single-airport runs; you pay the start fee once. - A wider date window finds more destinations, because the fare finder returns the cheapest date per destination inside the window. - Set `market` to match the booking-link language you want (e.g. `en-ie` for `.com/ie/en/...` links); `currency` will not change with it. - Mixing departure airports from different countries in one run (e.g. `STN` and `DUB`) mixes currencies in the output — check `currency` per row, and note that a single `maxPrice` is applied in each departure airport's own currency, not converted. - If you see `error` rows mentioning blocking, enable Apify Proxy (datacenter) in **Proxy configuration**. ### Limitations - One airline. This Actor reads Ryanair's own fare finder, so it does not compare Ryanair against other carriers. - **`market` does not set the currency.** Verified: the same route returns the identical price and `currency` under every market value. Ryanair quotes each fare in the currency of the departure airport's own country (Dublin is always EUR, Stansted is always GBP) regardless of `market`; `market` only changes the language/locale of the booking `url`. - One-way fares only, and one row per destination: the cheapest date inside your window, not every flight on every date. Every destination Ryanair serves from the airport comes back in one request (for example about 150 from Stansted and 115 from Dublin). - Fares are what the airline advertises at the time of the run, excluding bags, seats and other extras, and they change constantly. Re-run before acting on a price. - Results reflect the public fare finder at the time of the run; Ryanair may change its API (it has moved from `v3` to `v4` before), in which case rows come back as `error` and the Actor is updated quickly (report it in the **Issues** tab). ### FAQ #### Is it legal to scrape Ryanair? Scraping publicly available data is generally legal, but you are responsible for how you use the output. Read the legal notice below and Ryanair's terms of service, and do not collect personal data without a legitimate reason. #### Can I use this Actor from an AI agent or MCP client? Yes. Every row is self-describing (`status` + `error`), inputs are plain strings, and results can be fetched via the dataset API or the Apify MCP server. #### Why did I get fewer rows than `maxItems`? The airport serves fewer destinations in that date window, your `maxPrice` excluded the rest, or the run hit your **Max total charge** limit. Check the run log for "Stopping gracefully". #### Can I search a specific route? Yes. Write it as two IATA codes, `DUB-STN`, either in the list or in the query. You then get the cheapest date for that route inside your window. #### What if a field is missing? Optional fields such as `previousPrice` are omitted when Ryanair does not publish them. If a field that should always be present is missing, open an issue in the **Issues** tab with the run ID. ### Related Actors - [AutoScout24 Scraper](https://apify.com/glasswing/autoscout24-scraper) - use it to price a rental-market alternative, used cars, once you land. - [Rightmove Scraper](https://apify.com/glasswing/rightmove-scraper) - use it to check UK property and rental prices for a trip that turns into a longer stay. - [Cars.com Scraper](https://apify.com/glasswing/cars-scraper) - use it for US used-car listings and dealer data on the other end of the flight. - [Google Maps Scraper — Business Leads with Emails](https://apify.com/glasswing/google-maps-leads-2-49-1k) - use it to find local businesses at the destination. ### Legal and data-protection notice This Actor extracts only data that Ryanair publishes publicly; it does not extract private user data such as e-mail addresses, phone numbers, gender or precise location, and it does not log in or read anything behind access controls. However, your results could still contain personal data. Personal data is protected by the GDPR in the European Union and by other regulations around the world. You should not scrape personal data unless you have a legitimate reason to do so. If you are unsure whether your reason is legitimate, consult your lawyers. You are responsible for complying with Ryanair's terms of service and applicable law when using the extracted data. This Actor is an independent tool and is not affiliated with, endorsed by or sponsored by Ryanair or its owners. All trademarks belong to their respective owners. # Changelog This Actor's version history is a separate document: https://apify.com/glasswing/ryanair-flights-scraper/changelog.md # Actor input Schema ## `startUrls` (type: `array`): One per line: a departure airport as an IATA code (`STN`), a route (`STN-ALC`), or a ready-made fare-finder API URL. Every entry is searched over the date window below. Leave as is to use the example, or use Query instead. ## `query` (type: `string`): Alternative to the list above: one departure airport (`DUB`) or one route (`DUB-STN`), as IATA codes. When set, the built-in example above is skipped. ## `dateFrom` (type: `string`): First outbound departure date to search, as `YYYY-MM-DD`, e.g. `2026-10-06`. Defaults to one week from today, so the default run never goes stale. ## `dateTo` (type: `string`): Last outbound departure date to search, as `YYYY-MM-DD`, e.g. `2026-11-05`. Defaults to 30 days after the earliest date. ## `market` (type: `string`): Ryanair market/locale for the booking link in each row's `url` (e.g. `en-gb` gives a ryanair.com/gb/en/... link). It does not change `currency`: each fare comes back in the currency Ryanair itself quotes for that departure airport's country, regardless of this setting (a Dublin departure is always EUR, a Stansted departure is always GBP). ## `maxPrice` (type: `integer`): Optional. Only return fares at or below this amount, in the market's currency (e.g. `50` for fares at or below 50 GBP when the market is `en-gb`). ## `maxItems` (type: `integer`): Stop after this many records have been saved to the dataset. Each saved record with status `ok` is one billable result. Keep it small for test runs. ## `proxyConfiguration` (type: `object`): Optional. The Actor is HTTP-only and works from datacenter IPs. Enable Apify Proxy (datacenter group is the default) only if the target blocks direct requests; residential proxies are not needed and not recommended for this Actor. ## Actor input object example ```json { "startUrls": [ "STN" ], "query": "DUB-STN", "market": "en-gb", "maxItems": 20, "proxyConfiguration": { "useApifyProxy": false } } ``` # 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 '' with your token const client = new ApifyClient({ token: '', }); // Prepare Actor input const input = { "startUrls": [ "STN" ], "market": "en-gb", "maxItems": 20, "proxyConfiguration": { "useApifyProxy": false } }; // Run the Actor and wait for it to finish const run = await client.actor("glasswing/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 '' with your token. client = ApifyClient("") # Prepare the Actor input run_input = { "startUrls": ["STN"], "market": "en-gb", "maxItems": 20, "proxyConfiguration": { "useApifyProxy": False }, } # Run the Actor and wait for it to finish run = client.actor("glasswing/ryanair-flights-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 '{ "startUrls": [ "STN" ], "market": "en-gb", "maxItems": 20, "proxyConfiguration": { "useApifyProxy": false } }' | apify call glasswing/ryanair-flights-scraper --silent --output-dataset ``` ## MCP server setup ```json { "mcpServers": { "apify": { "type": "http", "url": "https://mcp.apify.com/?tools=fetch-actor-details,glasswing/ryanair-flights-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 ` 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/Xy3XagkWHYmkTvDG6/builds/P8diz5FGmrYCem8s8/openapi.json