# Eurostat Scraper: EU Statistics by Dataset | $1/1K (`one_dollar_store/eurostat-statistics-scraper`) Actor

$1 per 1,000 results, platform usage included. Eurostat tables from the official API as flat rows, one per observation: period, value, flag and every dimension with its code and label (country, unit, sex, age and more). Filter by country and time. No key.

- **URL**: https://apify.com/one_dollar_store/eurostat-statistics-scraper.md
- **Developed by:** [One Dollar Store](https://apify.com/one_dollar_store) (community)
- **Categories:** Business, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $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

## Eurostat Scraper: EU statistics by table, country and period

**$1 per 1,000 observations. Platform usage included. No rental, no minimum.**

Pull any table from Eurostat, the statistics office of the European Union, as flat rows: one row per number. Give it the table code (for example `une_rt_m` for monthly unemployment), narrow it by country or any other dimension, pick a period, and get period, value, flag and every dimension with both its label and its code. It reads the official Eurostat dissemination API. No key and no account with Eurostat.

[Open it in Apify Console](https://console.apify.com/actors/pOtvpuG0aGzsYDF1I/input)

### What it costs

| Observations | This actor |
|---|---|
| 1,000 | $1.00 |
| 10,000 | $10.00 |
| 100,000 | $100.00 |

Plus $0.001 per run. One flat price, platform usage included, so there is no separate compute or proxy bill. Only observation rows are charged. A run returns at most 10,000 rows, so 100,000 observations is ten runs, for example one per group of countries. A weekly refresh of 2,000 observations costs about $2.00 a run, or about $8.00 a month.

### Why use it

- **Official data, no key.** The rows come straight from the Eurostat API. Nothing to sign up for on the Eurostat side.
- **Labels and codes side by side.** Each dimension is on the row as readable text (`Germany`) and as its code (`geoCode`: `DE`), so the rows are ready for a spreadsheet and for a join on codes.
- **Narrow by country, unit, sex, age or anything else the table has.** Write filters like `geo=DE,FR` and the actor asks Eurostat for just those cells, so you do not download a whole table to throw most of it away.
- **Periods the way Eurostat writes them.** A first and last period (`2020-01`, `2024-Q4`, `2023`) or just the latest N periods.
- **Flags with their meaning.** Provisional or estimated values carry `flag` and `flagMeaning`. Missing values are not rows.
- **Labels in English, French or German.**
- **Safe for scheduled jobs.** A table code that does not exist, or a selection with no data, ends cleanly with zero rows and a message. It does not crash.

### Quick start

1. Open the actor, keep the example values, press **Start**.
2. Or paste this input, which returns Germany's monthly unemployment for the latest three months:

```json
{ "datasets": ["une_rt_m"], "filters": ["geo=DE"], "lastTimePeriod": 3, "maxItems": 100 }
```

3. Download the results as JSON, CSV or Excel, or read them through the API.

To find a table code, open the table in the Eurostat Data Browser: the code is in the address, and the page lists it as the online data code. To find a table's dimensions, run it once with a small `maxItems` and look at the rows: every field that sits next to a `...Code` field is a dimension you can filter on. A dimension whose label is the same as its code appears once, without `...Code`.

### Use it from code

```bash
curl -X POST "https://api.apify.com/v2/acts/one_dollar_store~eurostat-statistics-scraper/run-sync-get-dataset-items?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"datasets": ["une_rt_m"], "filters": ["geo=DE"], "lastTimePeriod": 3, "maxItems": 100}'
```

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("one_dollar_store/eurostat-statistics-scraper").call(
    run_input={"datasets": ["nama_10_gdp"], "filters": ["geo=DE,FR", "unit=CP_MEUR", "na_item=B1GQ"],
               "sinceTimePeriod": "2020", "untilTimePeriod": "2024", "maxItems": 100}
)
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["geo"], item["period"], item["value"])
```

### Use it from an AI assistant

Claude, ChatGPT, Cursor and other assistants can call this actor through Apify's MCP server. Add it with this server address:

```
https://mcp.apify.com?tools=one_dollar_store/eurostat-statistics-scraper
```

Then ask, for example: "Get the GDP at market prices of Germany and France for 2020 to 2024 from Eurostat table nama_10_gdp, in current prices."

### Switching from another Eurostat scraper

Tables are `datasets`, a list of codes. Filters are `filters`, one `dimension=code1,code2` per line. The time range is `sinceTimePeriod` and `untilTimePeriod`, or `lastTimePeriod` for the latest N periods. The core output fields are `dataset`, `period`, `value`, `flag`, then each dimension (such as `geo`, `unit`, `sex`) with its `...Code`. One row is one observation.

### Input

| Field | Type | Default | What it does |
|---|---|---|---|
| `datasets` | list of text | required | Eurostat table codes, one per line, for example `une_rt_m`, `nama_10_gdp` or `prc_hicp_manr`. Up to 20. Not case sensitive. |
| `filters` | list of text | none | One filter per line as `dimension=code` or `dimension=code1,code2`, for example `geo=DE,FR`. The same filters apply to every table in the run. |
| `lastTimePeriod` | number | none | Only the latest N periods of each series. Ignored when you set a first or last period. |
| `sinceTimePeriod` | text | none | First period, in the table's own format: `2020`, `2020-03`, `2020-Q1` or `2020-S1`. |
| `untilTimePeriod` | text | none | Last period, in the same format. Empty means up to the latest data. |
| `language` | choice | EN | Language of table titles and dimension labels: English, French or German. Codes do not change. |
| `maxItems` | number | 1000 | Most observations in the run, over all tables. Minimum 10, maximum 10,000. |

When there are more observations than `maxItems`, the run stops at that number, reading tables in the order you listed them and each table in Eurostat's own order. If you list several tables and the first one fills the limit, the later ones are not read, so give each table its own run when you need a fixed amount from each.

### Output fields

| Field | Meaning |
|---|---|
| `dataset`, `datasetTitle` | The table code (lower case) and its title in the chosen language. |
| `period` | The time period of the observation as Eurostat writes it: `2024`, `2024-03`, `2024-Q1`, `2024-S1`. |
| One field per dimension, for example `geo`, `unit`, `sex`, `age`, `freq` | The label of the category, such as `Germany`. A table's dimensions differ from table to table. |
| The same name plus `Code`, for example `geoCode`, `unitCode` | The code of the category, such as `DE`. It is left out when the label and the code are the same. |
| `value` | The observation, as a number. Missing values are not returned. |
| `flag`, `flagMeaning` | Eurostat's status flag, such as `p` for provisional or `e` for estimated, and what it stands for. Left out for ordinary values. |
| `lastUpdated` | When Eurostat last updated the table. |
| `datasetUrl` | Link to the table in the Eurostat Data Browser. |
| `source`, `scrapedAt` | Where the row came from and when this run read it. |

### Sample results

Real rows from a test run on 20 October 2026: GDP at market prices in current prices for Germany and France, 2020 to 2024 (table `nama_10_gdp`).

```json
[
  {"dataset": "nama_10_gdp", "datasetTitle": "Gross domestic product (GDP) and main components (output, expenditure and income) - annual data", "freq": "Annual", "freqCode": "A", "unit": "Current prices, million euro", "unitCode": "CP_MEUR", "na_item": "Gross domestic product at market prices", "na_itemCode": "B1GQ", "geo": "Germany", "geoCode": "DE", "period": "2020", "value": 3477670, "lastUpdated": "2026-10-19T23:00:00+0200", "datasetUrl": "https://ec.europa.eu/eurostat/databrowser/view/nama_10_gdp/default/table", "source": "Eurostat", "scrapedAt": "2026-10-20T08:36:18.778Z"},
  {"dataset": "nama_10_gdp", "datasetTitle": "Gross domestic product (GDP) and main components (output, expenditure and income) - annual data", "freq": "Annual", "freqCode": "A", "unit": "Current prices, million euro", "unitCode": "CP_MEUR", "na_item": "Gross domestic product at market prices", "na_itemCode": "B1GQ", "geo": "Germany", "geoCode": "DE", "period": "2023", "value": 4254930, "flag": "p", "flagMeaning": "provisional", "lastUpdated": "2026-10-19T23:00:00+0200", "datasetUrl": "https://ec.europa.eu/eurostat/databrowser/view/nama_10_gdp/default/table", "source": "Eurostat", "scrapedAt": "2026-10-20T08:36:18.972Z"},
  {"dataset": "nama_10_gdp", "datasetTitle": "Gross domestic product (GDP) and main components (output, expenditure and income) - annual data", "freq": "Annual", "freqCode": "A", "unit": "Current prices, million euro", "unitCode": "CP_MEUR", "na_item": "Gross domestic product at market prices", "na_itemCode": "B1GQ", "geo": "France", "geoCode": "FR", "period": "2024", "value": 2935236.2, "flag": "p", "flagMeaning": "provisional", "lastUpdated": "2026-10-19T23:00:00+0200", "datasetUrl": "https://ec.europa.eu/eurostat/databrowser/view/nama_10_gdp/default/table", "source": "Eurostat", "scrapedAt": "2026-10-20T08:36:19.232Z"}
]
```

The second row carries the flag `p`: Eurostat marks the most recent years of these accounts as provisional.

### Limits

- **10,000 observations per run, over all tables.** For more, run again with other countries or other periods.
- **Speed.** Eurostat answered in about half a second to just over a second for filtered requests in our tests. A run of 3,000 rows took 259 seconds, about 12 rows a second, so 10,000 rows take around 15 minutes, and the run timeout is set to one hour by default. If you lower it, the run stops cleanly before the limit and keeps what it has.
- **Big tables.** One request is read up to 8 MB. If you ask for a large table with no filters and no period, the actor reads the latest period only and says so in the run log and in `RUN_SUMMARY`. For a chosen part of a big table, add filters or a shorter time range. The latest period of `nama_10_gdp` with no filters is 58,656 cells and took about 15 seconds.
- **Filters apply to every table.** A filter on a dimension that a table does not have makes Eurostat refuse that table, and the actor skips it with a message. When the tables differ, use one run per table.
- **Typos.** A table code that does not exist ends with zero rows. A wrong category code (for example `geo=XX`) matches no values and ends with zero rows and a message. A dimension name that does not exist ends with the message Eurostat gives.
- **Rate limit.** The actor sends one request at a time, at most one per second, with a User-Agent that names the actor, and it tries a failed request up to three times with a pause between tries.
- **Data changes.** Eurostat revises figures. Compare `lastUpdated` between runs, and use `flag` to see which values are still provisional.
- **Time formats differ by table.** A yearly table wants `2024`, a monthly one `2024-03`, a quarterly one `2024-Q1`. Use the table's own format.

### FAQ

**How much does it cost to collect 10,000 observations?**
$10, plus $0.001 for each run.

**Do I pay for compute or proxy on top?**
No. Platform usage is included in the $1 per 1,000 price. No proxy is used.

**Do I need an API key or a Eurostat account?**
No. The actor reads the public Eurostat API.

**How do I get one country only?**
Add the filter `geo=DE`, with the country code Eurostat uses. For several, `geo=DE,FR,IT`. Eurostat uses `EL` for Greece and `UK` for the United Kingdom.

**Why do some rows have a flag?**
Eurostat marks values that are provisional, estimated, forecast or of low reliability. `flagMeaning` gives the plain words in the language you chose.

**How current is the data?**
The actor reads Eurostat at the moment you run it. `lastUpdated` shows when the table last changed.

**Is it legal?**
The actor reads statistics that Eurostat publishes openly for reuse, and it does not log in to anything. How you use the data is up to you: follow Eurostat's copyright and reuse notice and the law where you live.

**Is this an official Eurostat product?**
No. It is an independent tool and is not affiliated with or endorsed by Eurostat or the European Commission.

**Do I need an Apify account?**
Yes. Actors run from an Apify account, and a free account is enough to start: it includes $5 of platform usage every month. You can [sign up here](https://www.apify.com?fpr=ymnoit). This is a referral link and it costs you nothing.

**Is there a limit on the free plan?**
Yes. A run started from a free plan account delivers the first 10 results, then ends with a message and a link to the plans. Any paid plan returns everything you ask for, up to your own limit. The price per result is the same on every plan.

### More from The One Dollar Store

Every actor here costs $1 per 1,000 results, platform usage included. See the whole store: https://apify.com/one_dollar_store

**Open data and statistics**

- [Socrata Open Data Search](https://apify.com/one_dollar_store/socrata-open-data-search): Datasets and rows from city and state portals.
- [Internet Archive Scraper](https://apify.com/one_dollar_store/internet-archive-items-scraper): Books, media and web items from archive.org.
- [World Bank Indicators](https://apify.com/one_dollar_store/world-bank-indicators): Country indicators by year.
- [Wikipedia Pageviews](https://apify.com/one_dollar_store/wikipedia-pageviews-stats): Daily and monthly views per article.
- [GDELT Scraper](https://apify.com/one_dollar_store/gdelt-news-events-scraper): Worldwide news articles by theme and tone.

### Changelog

- October 2026: first release.

# Actor input Schema

## `datasets` (type: `array`):

Eurostat table codes, one per line, for example une_rt_m (monthly unemployment), nama_10_gdp (GDP and main components) or prc_hicp_manr (inflation). The code is shown on each table's page in the Eurostat Data Browser. Codes are not case sensitive.

## `filters` (type: `array`):

Narrow the table, one filter per line, written as dimension=code or dimension=code1,code2. For example geo=DE,FR for Germany and France, or unit=PC_ACT. The same filters apply to every table in the run. Leave empty to take every value of every dimension.

## `lastTimePeriod` (type: `integer`):

Only the most recent N periods of each series, for example the last 12 months. Ignored when you set a first or last period below.

## `sinceTimePeriod` (type: `string`):

Start of the time range, in the table's own format: 2020 for years, 2020-03 for months, 2020-Q1 for quarters, 2020-S1 for half years.

## `untilTimePeriod` (type: `string`):

End of the time range, in the same format as the first period. Leave empty for up to the latest data.

## `language` (type: `string`):

Language of table titles and dimension labels. Codes do not change.

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

The run stops after this many observations in total. Minimum 10, maximum 10,000.

## Actor input object example

```json
{
  "datasets": [
    "une_rt_m",
    "prc_hicp_manr"
  ],
  "filters": [
    "geo=DE,FR",
    "sex=T"
  ],
  "lastTimePeriod": 12,
  "sinceTimePeriod": "2020-01",
  "untilTimePeriod": "2024-12",
  "language": "EN",
  "maxItems": 100
}
```

# Actor output Schema

## `results` (type: `string`):

No description

## `summary` (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 = {
    "datasets": [
        "une_rt_m"
    ],
    "filters": [
        "geo=DE"
    ],
    "lastTimePeriod": 3,
    "language": "EN",
    "maxItems": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("one_dollar_store/eurostat-statistics-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 = {
    "datasets": ["une_rt_m"],
    "filters": ["geo=DE"],
    "lastTimePeriod": 3,
    "language": "EN",
    "maxItems": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("one_dollar_store/eurostat-statistics-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 '{
  "datasets": [
    "une_rt_m"
  ],
  "filters": [
    "geo=DE"
  ],
  "lastTimePeriod": 3,
  "language": "EN",
  "maxItems": 100
}' |
apify call one_dollar_store/eurostat-statistics-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,one_dollar_store/eurostat-statistics-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/pOtvpuG0aGzsYDF1I/builds/8E29ATGz8zarCDsUB/openapi.json