# European Airport Traffic Statistics (Eurostat) (`open_skies_data/european-airport-traffic`) Actor

Returns monthly passengers and air cargo tonnes for European airports (EU, EFTA and EU candidate countries): one row per airport, month and metric, with the same month last year and the % change. Filter by country or airport. Source: Eurostat.

- **URL**: https://apify.com/open\_skies\_data/european-airport-traffic.md
- **Developed by:** [Jofre Masip](https://apify.com/open_skies_data) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$1.00 / 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

## ✈️ European Airport Traffic Data — Passengers & Air Cargo (Eurostat)

**Monthly passenger numbers and air cargo tonnes for hundreds of European airports, in one clean table, with the year-over-year change already calculated.**

Stop downloading monthly spreadsheets from dozens of airport operators and statistics offices. This Actor pulls the official figures from Eurostat, cleans them up and gives you a ready-to-use dataset in seconds: Excel, CSV, JSON, Google Sheets or API.

- 🛫 **Passengers, cargo tonnes and flights** for every major airport in the EU, EFTA and candidate countries
- 📈 **Year-over-year change** on every row, no formulas needed
- 🗓️ **3 years of monthly history** by default, or any period you choose
- 🌍 **Filter by country or airport**: Spain, France, Germany, Italy, Portugal and more
- ✅ **Official, verifiable source**: Eurostat, free to reuse commercially with attribution. Every row links to the original dataset
- 💸 **Pay only for the rows you get**: a full country with 3 years of data costs about $1.50

### What can you use it for?

| You are… | Use it to… |
|---|---|
| ✈️ **Airline network planner** | Compare airports and spot growing markets before opening a route |
| 🏢 **Airport or tourism board** | Benchmark your traffic against competing airports every month |
| 📦 **Air cargo or logistics company** | Track freight volumes by airport and see where demand is moving |
| 💼 **Investor or equity analyst** | Follow traffic trends at airports run by listed operators |
| 📊 **Consultant or researcher** | Build market studies and reports without manual data collection |
| 📰 **Journalist** | Get the latest figures and the change versus last year in one click |

### How to use it

1. Click **Try for free**.
2. Choose the **countries** (for example `ES` for Spain) or specific **airports**.
3. Pick what you need: **Passengers**, **Cargo (tonnes)**, or both.
4. Press **Start**. In a few seconds you get a table you can export or connect to your tools.

💡 **Tip:** schedule it to run every month and send the results straight to Google Sheets, Excel, Slack or your database with Apify integrations. Your dashboard updates itself.

### Input examples

**All Spanish airports, passengers and cargo, last 3 years**

```json
{ "countries": ["ES"] }
```

**Madrid, Barcelona and Paris CDG, international passengers only, since January 2025**

```json
{
  "airports": ["MAD", "BCN", "CDG"],
  "measures": ["PAS_CRD"],
  "coverage": "INTL",
  "fromPeriod": "2025-01"
}
```

**Only large airports in Germany and Italy (over 500,000 passengers a month)**

```json
{ "countries": ["DE", "IT"], "measures": ["PAS_CRD"], "minValue": 500000 }
```

Airports can be written as IATA codes (`MAD`), ICAO codes (`LEMD`) or Eurostat codes (`ES_LEMD`).

### Output

Results are grouped by airport, busiest airports first, with months in order. Example (illustrative figures):

| Airport | ICAO | Country | Month | Metric | Value | Unit | Same month last year | Change vs last year (%) |
|---|---|---|---|---|---|---|---|---|
| Adolfo Suarez Madrid-Barajas | LEMD | Spain | 2026-03 | Passengers | 5,300,000 | passengers | 5,000,000 | 6.0 |
| Adolfo Suarez Madrid-Barajas | LEMD | Spain | 2026-03 | Cargo | 69,952.7 | tonnes | 60,000 | 16.6 |
| Barcelona/El Prat | LEBL | Spain | 2026-03 | Passengers | 4,400,000 | passengers | 4,000,000 | 10.0 |

Each row in JSON:

```json
{
  "airport": "Barcelona/El Prat",
  "icaoCode": "LEBL",
  "iataCode": "BCN",
  "municipality": "Barcelona",
  "country": "Spain",
  "countryCode": "ES",
  "month": "2026-03",
  "metric": "Passengers",
  "unit": "passengers",
  "value": 4400000,
  "valuePreviousYear": 4000000,
  "changeVsPreviousYearPct": 10.0,
  "trafficType": "All traffic",
  "source": "Eurostat",
  "sourceDataset": "avia_paoa",
  "sourceUrl": "https://ec.europa.eu/eurostat/databrowser/view/avia_paoa/default/table",
  "eurostatLastUpdate": "2026-09-28"
}
```

| Field | Meaning |
|---|---|
| `airport` | Airport name |
| `icaoCode` | Four-letter ICAO airport code |
| `iataCode`, `municipality` | Three-letter IATA code and municipality where the airport is located |
| `country`, `countryCode` | Country name and Eurostat country code |
| `month` | Month, as YYYY-MM |
| `metric` | Passengers, Cargo, Passenger flights, Cargo flights or Passengers on board |
| `unit` | passengers, tonnes or flights |
| `value` | Figure for that month (arrivals + departures; cargo = freight and mail loaded and unloaded) |
| `valuePreviousYear` | Same month one year earlier |
| `changeVsPreviousYearPct` | Change versus the same month last year, in % |
| `trafficType` | All traffic, Domestic, International, Intra-EU or Extra-EU |
| `source`, `sourceDataset` | Data provider and Eurostat dataset code |
| `sourceUrl` | Link to the original dataset on Eurostat, to check any figure |
| `eurostatLastUpdate` | Date Eurostat last updated the dataset |

### How much does it cost?

You pay **$1 per 1,000 rows**. One row is one airport, one month and one metric.

| What you ask for | Approx. rows | Approx. cost |
|---|---|---|
| One airport, passengers + cargo, 3 years | ~70 | $0.07 |
| One country (e.g. Spain), passengers + cargo, 3 years | ~1,500 | $1.50 |
| All of Europe, passengers + cargo, 3 years | ~30,000 | $30 |

Use **Maximum rows** to cap the cost of any run.

### 🤖 Use it with AI agents

This Actor works as a tool for AI assistants and agents (ChatGPT, Claude, Cursor and others) through the [Apify MCP server](https://docs.apify.com/integrations/mcp). Once connected, your assistant can answer questions like:

- *"How many passengers did Madrid-Barajas handle each month in 2025, and how did that compare with 2024?"*
- *"Which Spanish airports moved the most air cargo last year?"*
- *"Compare monthly passengers at Barcelona, Palma and Málaga over the last 3 years."*

Why it works well for agents:

- ⚡ **Fast:** a typical run finishes in under 30 seconds, well within agent time limits.
- 📦 **Compact output:** clean rows with plain field names, no HTML or nested objects. Ask for only the fields you need to keep answers short.
- 🔓 **No login or API keys needed:** it reads official open data.
- 🧾 **Verifiable:** every row includes a link to the original Eurostat dataset, so the agent can cite its source.
- 💸 **Pay per row:** agents only pay for the data they actually use.

Example agent call: `{ "airports": ["MAD"], "measures": ["PAS_CRD"], "fromPeriod": "2025-01" }`

To connect it, add the Apify MCP server to your AI tool and include this Actor (`european-airport-traffic`) among its tools. See the [Apify MCP documentation](https://docs.apify.com/integrations/mcp) for setup.

### FAQ

**Where does the data come from?**
From Eurostat, the statistical office of the European Union: datasets `avia_paoa` (passengers) and `avia_gooa` (freight and mail). Airports report these figures under EU Regulation (EC) 437/2003.

**How recent is the data?**
Eurostat publishes airport data with a delay of a few months, and each country reports at its own pace, so the latest months may not be available for every airport yet. Every run returns the most recent version published.

**Which airports are included?**
Airports with more than about 150,000 passengers a year in EU, EFTA and candidate countries.

**Why can figures differ slightly from an airport operator's own report?**
Eurostat uses harmonised European definitions (for example, how transit passengers are counted), so its numbers can differ a little from national or operator reports. The advantage is that every airport is measured the same way.

**Can I use the data commercially?**
Yes. Eurostat allows free reuse of its data, including commercially, as long as Eurostat is credited as the source and any changes are indicated (see its [reuse policy](https://ec.europa.eu/eurostat/about-us/policies/copyright)). Every row includes the source and a link to the original dataset. In line with that policy, this Actor only returns data for EU, EFTA and EU candidate countries.

**Can I get it in Excel or Google Sheets?**
Yes. Export any run as Excel, CSV or JSON, or connect it to Google Sheets through Apify integrations.

**Something missing?**
Open an issue on the **Issues** tab. Feature requests are welcome.

### Data source, reliability and changes

- **Source:** Eurostat, the statistical office of the European Union. Passengers: [`avia_paoa`](https://ec.europa.eu/eurostat/databrowser/view/avia_paoa/default/table). Cargo: [`avia_gooa`](https://ec.europa.eu/eurostat/databrowser/view/avia_gooa/default/table).
- **Who reports the figures:** airports and national civil aviation authorities, under EU Regulation (EC) No 437/2003 on air transport statistics.
- **What this Actor changes:** it tidies airport and country names, rounds cargo tonnes to one decimal, calculates the change versus the same month last year, and sorts the results. The passenger, cargo and flight figures themselves are passed through as Eurostat publishes them.
- **Airport codes and municipalities:** IATA codes and municipalities come from [OurAirports](https://ourairports.com/data/) (public domain).
- **Coverage:** EU, EFTA and EU candidate countries, in line with Eurostat's reuse policy.

*Source: Eurostat. Data modified as described above; Eurostat has no responsibility for these changes. This Actor is independent and not affiliated with or endorsed by Eurostat or any airport operator.*

# Actor input Schema

## `countries` (type: `array`):

Two-letter Eurostat country codes to include, e.g. ES (Spain), FR, DE, IT, PT, EL or GR (Greece). Leave empty for all countries. Default: all countries.

## `airports` (type: `array`):

Optional list of airports. Accepts IATA codes (MAD, BCN, CDG), ICAO codes (LEMD, LEBL, LFPG) or Eurostat codes (ES\_LEMD). Can be combined with countries. Default: all airports.

## `measures` (type: `array`):

Metrics to return. PAS\_CRD = passengers, FRM\_LD\_NLD = cargo in tonnes (freight and mail), CAF\_PAS = passenger flights, CAF\_FRM = cargo flights, PAS\_BRD = passengers on board. Default: PAS\_CRD and FRM\_LD\_NLD.

## `coverage` (type: `string`):

Traffic type: TOTAL (all), NAT (domestic), INTL (international), INTL\_IEU27\_2020 (within the EU), INTL\_XEU27\_2020 (to and from outside the EU). Default: TOTAL.

## `fromPeriod` (type: `string`):

First month to return, format YYYY-MM, e.g. 2024-01. Default: 3 years ago. Eurostat publishes with a delay of a few months.

## `toPeriod` (type: `string`):

Last month to return, format YYYY-MM. Default: latest month published.

## `minValue` (type: `integer`):

Only return rows whose value is at least this number (passengers, tonnes or flights depending on the metric). Useful to keep large airports only. Default: no minimum.

## `maxItems` (type: `integer`):

Maximum number of rows to return. Use it to limit output size and cost. Default: no limit.

## Actor input object example

```json
{
  "countries": [
    "ES"
  ],
  "measures": [
    "PAS_CRD",
    "FRM_LD_NLD"
  ],
  "coverage": "TOTAL"
}
```

# 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 = {
    "countries": [
        "ES"
    ],
    "measures": [
        "PAS_CRD",
        "FRM_LD_NLD"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("open_skies_data/european-airport-traffic").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 = {
    "countries": ["ES"],
    "measures": [
        "PAS_CRD",
        "FRM_LD_NLD",
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("open_skies_data/european-airport-traffic").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 '{
  "countries": [
    "ES"
  ],
  "measures": [
    "PAS_CRD",
    "FRM_LD_NLD"
  ]
}' |
apify call open_skies_data/european-airport-traffic --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,open_skies_data/european-airport-traffic"
        }
    }
}
```

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/ft7imVLnSBpb25NLz/builds/HCLBKK6HD87qQ6AKX/openapi.json