# Italo Scraper - Italian High-Speed Train Fares (`studio-amba/italo-scraper`) Actor

Scrape Italo high-speed train fares, schedules, and availability. Search Italian routes like Roma-Milano, Roma-Napoli, Firenze-Venezia to get train numbers, departure/arrival times, prices by class (Smart, Comfort, Prima, Club Executive), and seat availability. No login or cookies required.

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

## Pricing

from $1.20 / 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.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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 Italo Scraper do?

**Italo Scraper** extracts high-speed train fares, schedules, and seat availability from [Italo](https://www.italotreno.com), Italy's premium private high-speed rail operator. Search any Italo route and get structured data including train numbers, departure and arrival times, journey durations, prices by travel class, and availability status.

Italo operates high-speed trains (up to 300 km/h) on major Italian routes including Roma-Milano, Roma-Napoli, Firenze-Venezia, Torino-Napoli, and Bologna-Salerno. This actor extracts the same fare data you see when searching on italotreno.com.

No login, cookies, or Italo account required. The actor runs on the [Apify platform](https://apify.com), giving you API access, scheduling, webhooks, and integrations with tools like Zapier, Make, Google Sheets, and Slack.

### Why use Italo Scraper?

- **Price monitoring** — Track fare changes on popular routes like Roma-Milano or Roma-Napoli. Schedule daily runs to find the cheapest Italo tickets before they sell out.
- **Travel comparison** — Compare Italo fares against Trenitalia (the other Italian high-speed operator) to find the best deal. Build travel aggregation dashboards.
- **Revenue management research** — Analyze Italo's dynamic pricing patterns, class distribution, and availability across routes and dates.
- **Business intelligence** — Hotels, tour operators, and travel agencies can use Italo schedule data to plan packages, coordinate transfers, and inform guests about train options.
- **Academic research** — Study high-speed rail pricing, competition dynamics between Italo and Trenitalia, or Italian transport infrastructure.

### How to scrape Italo data

1. Go to the [Italo Scraper](https://apify.com/studio-amba/italo-scraper) page on Apify Store.
2. Click **Try for free** to open the actor in Apify Console.
3. Enter your **origin** and **destination** (e.g. "Roma" and "Milano").
4. Optionally set a **departure date** (YYYY-MM-DD, or DD/MM/YYYY). If omitted, it defaults to 7 days from today.
5. Click **Start** and wait for the run to complete.
6. Download your data as JSON, CSV, Excel, or connect it to your app via the Apify API.

### Input

| Field | Type | Description | Default |
|-------|------|-------------|---------|
| `origin` | string | Departure city or station name | Roma |
| `destination` | string | Arrival city or station name | Milano |
| `departureDate` | string | Travel date (YYYY-MM-DD or DD/MM/YYYY). A past date searches today (tomorrow after 18:00 Italian time) and says so in the status message. A value that is not a date stops the run with a message naming it | 7 days from now |
| `passengers` | integer | Number of adult passengers (1-9). `price` is always the fare for one adult | 1 |
| `maxResults` | integer | Maximum results to return | 50 |
| `proxyConfiguration` | object | Proxy settings. The automatic pool is the default; RESIDENTIAL + country IT is available if you are blocked | Apify Proxy (automatic) |

#### Example input

```json
{
    "origin": "Roma",
    "destination": "Milano",
    "departureDate": "2026-07-15",
    "passengers": 1,
    "maxResults": 50
}
```

The actor resolves city names against Italo's own live station list, so short names like "Roma", "Milano", "Napoli" and full names like "Roma Termini", "Torino Porta Susa" both work, and so does a station code such as `RMT`. A city that has one aggregate entry (Roma, Napoli, Venezia) is searched across all of that city's Italo stations.

Italo also sells tickets to cities it reaches through a connection, such as Pisa, Livorno, Siena and La Spezia. Those names resolve to the city's main station in Italo's list ("Pisa" becomes Pisa Centrale). Names are matched on whole words, so "San Benedetto" finds San Benedetto del Tronto and never a station that only contains the letters.

If a name is not in Italo's station list, the run stops immediately and names it, together with the closest entries in the list. Italo serves the Torino-Milano-Bologna-Firenze-Roma-Napoli-Salerno spine plus Venezia, Verona, Brescia, Genova, Padova, Ferrara, Rimini, Bari and Reggio Emilia; it does not serve Sicily or Sardinia.

When Italo answers but has nothing on sale for the pair and date (a date beyond its roughly six-month sale window, or no direct service that day), the run succeeds with zero results and says so in its status message rather than reporting a failure.

### Output

The actor stores results in a dataset. Each item represents one train service with a specific fare class. You can download the dataset in various formats such as JSON, HTML, CSV, or Excel.

#### Example output

```json
{
    "trainNumber": "9921",
    "departureStation": "Roma Termini",
    "arrivalStation": "Milano Centrale",
    "departureStationCode": "RMT",
    "arrivalStationCode": "MC_",
    "departureTime": "2026-07-15T08:00:00+02:00",
    "arrivalTime": "2026-07-15T10:55:00+02:00",
    "duration": "2h 55m",
    "price": 39.90,
    "currency": "EUR",
    "travelClass": "Smart",
    "availability": "Available",
    "carrier": "Italo",
    "url": "https://www.italotreno.com/en",
    "scrapedAt": "2026-07-01T12:00:00.000Z"
}
```

### Data fields

| Field | Type | Description |
|-------|------|-------------|
| `trainNumber` | string | Italo train service number |
| `departureStation` | string | Departure station name (e.g. Milano Centrale, Milano Rogoredo) |
| `arrivalStation` | string | Arrival station name (e.g. Napoli Centrale, Napoli Afragola) |
| `departureStationCode` | string | Italo's code for the departure station (e.g. `RMT`) |
| `arrivalStationCode` | string | Italo's code for the arrival station (e.g. `MC_`) |
| `departureTime` | string | Departure date and time in Italian local time, with UTC offset (`+02:00` in summer, `+01:00` in winter) |
| `arrivalTime` | string | Arrival date and time in Italian local time, with UTC offset |
| `duration` | string | Journey duration (e.g. "2h 55m") |
| `price` | number | Ticket price in EUR for one adult, whatever `passengers` is set to (null if unavailable) |
| `currency` | string | Currency code (EUR) |
| `travelClass` | string | Service class: Smart, Comfort, Prima, Club Executive, Flex, Economy, Low Cost |
| `availability` | string | Seat availability: Available, Sold out, Few seats left |
| `carrier` | string | Train operator (Italo) |
| `url` | string | Search URL on Italo |
| `scrapedAt` | string | Timestamp when data was collected |

### Italo travel classes

| Class | Description |
|-------|-------------|
| Smart | Standard class with comfortable seats, Wi-Fi, power outlets |
| Comfort | Extra legroom, wider seats, dedicated quiet zone |
| Prima | Premium class with leather seats, welcome drink, snacks |
| Club Executive | Top-tier: lounge access, meal service, extra-wide leather seats |

### Italo routes covered

Italo serves all major Italian cities with high-speed connections:

- **Roma Termini** <-> Milano Centrale (2h 55m)
- **Roma Termini** <-> Napoli Centrale (1h 10m)
- **Roma Termini** <-> Firenze S.M.N. (1h 30m)
- **Roma Termini** <-> Venezia Santa Lucia (3h 30m)
- **Roma Termini** <-> Torino Porta Susa (4h 15m)
- **Milano Centrale** <-> Bologna Centrale (1h 05m)
- **Milano Centrale** <-> Venezia Santa Lucia (2h 15m)
- **Napoli Centrale** <-> Firenze S.M.N. (2h 50m)
- **Bologna Centrale** <-> Firenze S.M.N. (0h 35m)

Plus secondary stops at Salerno, Padova, Verona, Brescia, Reggio Emilia AV, Ferrara, and more.

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

A typical run searching one route returns 20-80 results (depending on available trains and classes). This actor charges $0.02 per run (start fee, based on its 4 GB memory allocation) plus $0.002 per result — a 50-result run costs about $0.12.

For scheduled monitoring (e.g. checking Roma-Milano prices daily), expect to spend a few dollars a month depending on how many routes you track.

### Tips

- **Use simple city names** — "Roma", "Milano", "Napoli" work fine. The actor resolves them to the correct Italo station automatically.
- **Book early for best fares** — Italo's dynamic pricing means fares increase as departure date approaches. Schedule weekly scrapes to track price trends.
- **The default proxy is enough.** Italo's booking API answers Apify's automatic datacenter pool, which carries no per-GB charge, and the actor retries a refused request on a fresh session. Switch to RESIDENTIAL with country IT only if your runs report blocked requests.
- **Compare with Trenitalia** — Pair this actor with the [Trenitalia Scraper](https://apify.com/studio-amba/trenitalia-scraper) to compare fares between Italy's two high-speed rail operators.
- **Schedule runs** to build a price history. Italo fares on Roma-Milano can range from EUR 19.90 (Low Cost) to EUR 129.90 (Club Executive).

### Italo vs Trenitalia

Italy has two high-speed rail operators competing on the same routes:

| Feature | Italo | Trenitalia |
|---------|-------|------------|
| Operator | NTV (private) | Trenitalia (state-owned) |
| Train | AGV / Pendolino EVO | Frecciarossa / Frecciargento |
| Top speed | 300 km/h | 300 km/h |
| Roma-Milano | ~2h 55m | ~2h 55m |
| Classes | Smart, Comfort, Prima, Club Executive | Standard, Premium, Business, Executive |
| Pricing | Dynamic, often cheaper | Dynamic |

### FAQ and support

**Is it legal to scrape Italo?** This actor accesses publicly available train schedule and pricing information — the same data you see when searching on italotreno.com. No login or authentication is required.

**Why are some prices null?** When a fare class is sold out or not available for a route, the price is returned as null and availability shows "Sold out" or "Check online".

**Can I search routes Italo doesn't serve?** Italo only operates on specific high-speed corridors in Italy. If you search a route that Italo doesn't serve (e.g. small regional towns), the actor will return zero results. Check the routes list above.

**Results look empty?** Make sure your station names are correct. Try simple names like "Roma" or "Milano". A date in the past searches today (tomorrow after 18:00 Italian time), and the status message says so. If your scheduled task uses a fixed date, leave `departureDate` empty instead and every run searches 7 days ahead. A date beyond Italo's sale window succeeds with zero results and a status message.

For bugs or feature requests, open an issue in the [Issues tab](https://apify.com/studio-amba/italo-scraper/issues). For custom scraping solutions, contact us through the Apify platform.

# Actor input Schema

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

Departure city or station name (e.g. 'Roma', 'Milano', 'Napoli', 'Firenze', 'Venezia', 'Torino', 'Bologna'). Common city names are auto-resolved to the correct Italo station.

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

Arrival city or station name (e.g. 'Milano', 'Roma', 'Napoli', 'Firenze', 'Venezia'). Common city names are auto-resolved to the correct Italo station.

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

Travel date in YYYY-MM-DD format (e.g. '2026-10-15'); DD/MM/YYYY also works. Leave empty to search 7 days from today, which is what a scheduled task should do. A date that has already passed searches today (tomorrow after 18:00 Italian time), and the run's status message says so.

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

Number of adult passengers (1-9).

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

Maximum number of train fare results to return.

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

Proxy settings. Italo's booking API answers Apify's automatic datacenter pool, so that is the default and it carries no per-GB charge. Switch to RESIDENTIAL with country IT if your runs report blocked requests.

## Actor input object example

```json
{
  "origin": "Roma",
  "destination": "Milano",
  "passengers": 1,
  "maxResults": 50,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# 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": "Roma",
    "destination": "Milano",
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("studio-amba/italo-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": "Roma",
    "destination": "Milano",
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("studio-amba/italo-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": "Roma",
  "destination": "Milano",
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call studio-amba/italo-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,studio-amba/italo-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/1w2VSvhpDi1ZxPZz3/builds/d5jJCNQqPvllzpUIJ/openapi.json