# Irish Rail Scraper - Train Fares & Schedules (`studio-amba/irish-rail-scraper`) Actor

Scrape train schedules, fares, and real-time data from Irish Rail (irishrail.ie). Extract Intercity, DART, Commuter, and Enterprise routes across Ireland. No login required.

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

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

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

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

### How to scrape Irish Rail data

**Irish Rail Scraper** extracts train schedules, ticket fares, real-time status, and journey details from [Irish Rail](https://www.irishrail.ie) (Iarnrod Eireann) — Ireland's national railway operator. Irish Rail operates Intercity, DART, Commuter, and Enterprise (cross-border Belfast) services across the island.

This Actor uses a hybrid approach: it first queries the free Irish Rail Realtime API for live schedule data (train numbers, times, delays, status), then falls back to Playwright browser automation for fare extraction from the journey planner. **No login or cookies required.**

### Why use Irish Rail Scraper?

- **Schedule monitoring** — Track real-time train schedules between any two Irish stations with live delay data.
- **Price tracking** — Monitor ticket prices across routes and dates to find the cheapest fares.
- **Travel planning** — Compare journey options, durations, and train types for any Irish route.
- **Real-time delays** — Get live delay information and train status directly from the signaling system.
- **Market intelligence** — Collect structured Irish rail data for competitive analysis in travel or transport.
- **API access** — Get Irish Rail data via Apify API, webhooks, or scheduled runs. Integrate with Zapier, Make, Google Sheets, or your own applications.

### What data can you extract from Irish Rail?

| Field | Description |
|---|---|
| trainNumber | Train service code (e.g., A218, E109) |
| trainType | Service type (Intercity, DART, Commuter, Enterprise) |
| departureStation | Name of the departure station |
| arrivalStation | Name of the arrival station |
| departureTime | Scheduled departure time (HH:mm) |
| arrivalTime | Scheduled arrival time (HH:mm) |
| duration | Total travel time (e.g., 2h 35min) |
| price | Ticket price in EUR (from journey planner) |
| currency | Currency code (EUR) |
| travelClass | Seat class (1st, Standard) |
| changes | Number of transfers (0 = direct) |
| status | Real-time status (En Route, No Information) |
| lateMinutes | Minutes of delay (0 = on time) |
| url | Source URL |
| scrapedAt | Timestamp of extraction |

### How to use Irish Rail Scraper

1. Go to the Irish Rail Scraper [input page](https://console.apify.com/actors/irish-rail-scraper/input).
2. Enter your **origin station** (e.g., Dublin Heuston) and **destination station** (e.g., Cork).
3. Optionally set a **departure date** in YYYY-MM-DD format. If left empty, defaults to 14 days from today.
4. Set the number of **passengers** (default: 1).
5. Configure **max results** to limit the number of results returned.
6. Click **Start** and wait for the run to complete.
7. Download your data from the **Dataset** tab in JSON, CSV, Excel, or HTML format.

### Input parameters

| Parameter | Type | Default | Description |
|---|---|---|---|
| origin | string | Dublin Heuston | Departure station name |
| destination | string | Cork | Arrival station name |
| departureDate | string | 14 days from today | Travel date (YYYY-MM-DD) |
| passengers | integer | 1 | Number of adult passengers (1-9) |
| maxResults | integer | 50 | Maximum results to return |
| proxyConfiguration | object | IE proxy | Proxy settings for browser |

#### Example input

```json
{
    "origin": "Dublin Heuston",
    "destination": "Galway",
    "departureDate": "2026-07-15",
    "passengers": 2,
    "maxResults": 20
}
````

### Output example

```json
{
    "trainNumber": "A218",
    "trainType": "Intercity",
    "departureStation": "Dublin Heuston",
    "arrivalStation": "Cork",
    "departureTime": "09:00",
    "arrivalTime": "11:35",
    "duration": "2h 35min",
    "price": null,
    "currency": "EUR",
    "travelClass": null,
    "changes": 0,
    "status": "En Route",
    "lateMinutes": 0,
    "url": "https://www.irishrail.ie/en-ie/train-timetables/live-train-map",
    "scrapedAt": "2026-06-09T10:30:00.000Z"
}
```

### How much does it cost to scrape Irish Rail?

A typical run costs approximately **$0.03-0.10** in Apify platform credits. The Actor first uses the free Irish Rail Realtime API (which requires no browser), making it significantly cheaper than pure Playwright scrapers. The browser only launches as a fallback for fare extraction.

To keep costs down:

- The Realtime API strategy runs first and is very fast.
- Set `maxResults` to only what you need.
- Schedule runs during off-peak hours for faster page loading.

### Supported routes and services

Irish Rail operates services across the entire Irish rail network:

- **Intercity** — Dublin Heuston-Cork, Dublin Heuston-Galway, Dublin Heuston-Limerick, Dublin Heuston-Waterford, Dublin Heuston-Tralee, Dublin Heuston-Westport/Ballina.
- **Enterprise** — Dublin Connolly-Belfast Central (cross-border service, joint with Translink).
- **DART** — Dublin coastal commuter rail (Howth/Malahide to Greystones/Bray).
- **Commuter** — Dublin suburban services (Maynooth, Dunboyne, Drogheda, Kildare).
- **Western Rail Corridor** — Galway to Limerick.
- **Cork Suburban** — Cork to Cobh, Cork to Midleton.

### Station names

Use the official Irish Rail station names. Common examples:

| Station | Code | Routes |
|---|---|---|
| Dublin Heuston | HSTON | Cork, Galway, Limerick, Waterford, Tralee |
| Dublin Connolly | CNLLY | Belfast, Sligo, Rosslare, DART |
| Cork | CORK | Dublin, Cobh, Midleton, Tralee |
| Galway | GALWY | Dublin, Limerick |
| Limerick | LMRCK | Dublin, Galway, Ennis |
| Belfast Central | BFSTC | Dublin (Enterprise) |
| Waterford | WFORD | Dublin |

### Tips for best results

- **Use official station names** — The Actor matches against Irish Rail's station database. Use "Dublin Heuston" not just "Dublin" (there are multiple Dublin stations).
- **Check the route** — Dublin Heuston serves western/southern routes (Cork, Galway, Limerick). Dublin Connolly serves northern/eastern routes (Belfast, Sligo, DART).
- **Real-time data window** — The Realtime API returns trains within a 90-minute window from now. For future dates, the journey planner is used instead.
- **Proxy is optional** — The Realtime API works without proxies. Proxies are only needed for the journey planner fallback.

### Integrations

Connect Irish Rail Scraper to your workflow with:

- **Apify API** — Call programmatically from any language.
- **Webhooks** — Get notified when a run completes.
- **Scheduled runs** — Monitor prices or schedules daily or weekly.
- **Zapier / Make** — No-code integration with 5000+ apps.
- **Google Sheets** — Export results directly to a spreadsheet.

### FAQ

#### Is it legal to scrape Irish Rail?

This Actor extracts publicly available train schedule and real-time information. The primary data source is the official Irish Rail Realtime API, which is provided as a free public service. No login, authentication, or account is required. Always ensure your use case complies with applicable laws.

#### Why are prices sometimes null?

The Irish Rail Realtime API provides schedule and status data but not fares. Prices are only available when the Actor successfully extracts them from the journey planner website. If the journey planner is unreachable or the route is not bookable online, prices will be null.

#### Can I scrape multiple routes in one run?

Currently the Actor searches one route per run. To scrape multiple routes, trigger separate runs with different origin/destination combinations using the Apify API or scheduler.

#### What is the difference between the Realtime API and the journey planner?

The Realtime API gives live data (current trains, delays, positions) within a 90-minute window. The journey planner shows scheduled services for future dates with fare information. This Actor tries the Realtime API first for speed and reliability, then falls back to the journey planner.

#### How often is the real-time data updated?

Irish Rail's signaling system updates train positions in near real-time. For the most current delay information, run the Actor during the time window you are interested in.

### Support and feedback

If you encounter issues or have feature requests, please open an issue in the [Issues tab](https://console.apify.com/actors/irish-rail-scraper/issues). For custom scraping solutions, reach out via the Actor's page on the Apify Store.

# Actor input Schema

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

Departure station name (e.g., Dublin Heuston, Dublin Connolly, Galway, Limerick).

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

Arrival station name (e.g., Cork, Galway, Belfast Central, Limerick, Waterford).

## `departureDate` (type: `string`):

Travel date in YYYY-MM-DD format. Defaults to 14 days from today if not set.

## `passengers` (type: `integer`):

Number of adult passengers.

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

Maximum number of train results to return.

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

Proxy settings for the Playwright browser. Irish proxy recommended for best results.

## Actor input object example

```json
{
  "origin": "Dublin Heuston",
  "destination": "Cork",
  "passengers": 1,
  "maxResults": 50,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# 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": "Dublin Heuston",
    "destination": "Cork",
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("studio-amba/irish-rail-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": "Dublin Heuston",
    "destination": "Cork",
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("studio-amba/irish-rail-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": "Dublin Heuston",
  "destination": "Cork",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call studio-amba/irish-rail-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Irish Rail Scraper - Train Fares & Schedules",
        "description": "Scrape train schedules, fares, and real-time data from Irish Rail (irishrail.ie). Extract Intercity, DART, Commuter, and Enterprise routes across Ireland. No login required.",
        "version": "0.1",
        "x-build-id": "Rv2UeUvF8sLsoj4WP"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/studio-amba~irish-rail-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-studio-amba-irish-rail-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/studio-amba~irish-rail-scraper/runs": {
            "post": {
                "operationId": "runs-sync-studio-amba-irish-rail-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/studio-amba~irish-rail-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-studio-amba-irish-rail-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",
                "properties": {
                    "origin": {
                        "title": "Origin Station",
                        "type": "string",
                        "description": "Departure station name (e.g., Dublin Heuston, Dublin Connolly, Galway, Limerick).",
                        "default": "Dublin Heuston"
                    },
                    "destination": {
                        "title": "Destination Station",
                        "type": "string",
                        "description": "Arrival station name (e.g., Cork, Galway, Belfast Central, Limerick, Waterford).",
                        "default": "Cork"
                    },
                    "departureDate": {
                        "title": "Departure Date",
                        "type": "string",
                        "description": "Travel date in YYYY-MM-DD format. Defaults to 14 days from today if not set."
                    },
                    "passengers": {
                        "title": "Passengers",
                        "minimum": 1,
                        "maximum": 9,
                        "type": "integer",
                        "description": "Number of adult passengers.",
                        "default": 1
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 1,
                        "maximum": 200,
                        "type": "integer",
                        "description": "Maximum number of train results to return.",
                        "default": 50
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Proxy settings for the Playwright browser. Irish proxy recommended for best results."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
