# Eurostat EU Statistics Scraper (`parseforge/eurostat-scraper`) Actor

Scrape European Union statistical data from Eurostat. Get GDP, unemployment, inflation, population, trade, and economic indicators for all 27 EU member states plus candidate countries with time series data going back decades.

- **URL**: https://apify.com/parseforge/eurostat-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Developer tools, Business, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

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

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

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

![ParseForge Banner](https://raw.githubusercontent.com/ParseForge/apify-assets/main/banner.jpg)

## 🇪🇺 Eurostat EU Statistics Scraper

European economic and social statistics live inside thousands of datasets - population, GDP, unemployment, inflation, energy, trade, agriculture, and more. This tool pulls any Eurostat dataset into a flat, analysis-ready format so you skip the manual download-and-wrangle step.

> **The Eurostat Scraper collects official European Union statistics from any Eurostat dataset with country filters, time ranges, and automatic dimension unfolding into clean tabular rows.**

### ✨ What Does It Do

- 📊 **Any Eurostat dataset** - population, GDP, inflation, unemployment, trade, energy, and thousands more
- 🗺️ **Country filtering** - pull data for specific EU countries, candidate states, or EU27 totals
- 📅 **Time range filtering** - limit results to a specific start and end period
- 🔄 **Auto-flatten dimensions** - the JSON-stat format is unfolded into one row per data point with labels
- 🌍 **Multi-country comparisons** - pull data for several countries in one run
- 🏷️ **Human-readable labels** - every dimension code comes with its localized label

### 🔧 Input

- **Dataset Code** - the Eurostat dataset identifier (e.g. `demo_gind` for population, `nama_10_gdp` for GDP, `une_rt_a` for unemployment, `prc_hicp_manr` for inflation)
- **Geographic Filter** - 2-letter country codes comma-separated (e.g. `DE,FR,IT`) or `EU27_2020` for EU total
- **Time From / Time To** - start and end period (`2020` for yearly, `2020-01` for monthly)
- **Max Items** - free users get 10 data points, paid users up to 1,000,000

```json
{
    "datasetCode": "une_rt_a",
    "geo": "DE,FR,IT,ES,PL",
    "timeFrom": "2020",
    "timeTo": "2024",
    "maxItems": 500
}
````

### 📊 Output

Each row is a single data point with dimensions, value, and labels. Download as JSON, CSV, or Excel.

| 📌 Field | 📄 Description |
|----------|---------------|
| 💯 value | The numeric data point |
| 📁 dataset | Eurostat dataset code |
| 📋 datasetLabel | Human-readable dataset title |
| 🌍 geo | Country code |
| 🏷️ geo\_label | Country full name |
| ⏱️ time | Time period (year/month/quarter) |
| 📊 unit | Measurement unit code |
| 🏷️ unit\_label | Unit description (persons, EUR, %) |

```json
{
    "value": 3.1,
    "dataset": "une_rt_a",
    "datasetLabel": "Unemployment rate - annual data",
    "freq": "A",
    "freq_label": "Annual",
    "age": "TOTAL",
    "age_label": "Total",
    "unit": "PC_ACT",
    "unit_label": "Percentage of active population",
    "sex": "T",
    "sex_label": "Total",
    "geo": "DE",
    "geo_label": "Germany",
    "time": "2024",
    "time_label": "2024",
    "scrapedAt": "2026-04-10T12:00:00.000Z"
}
```

### 💎 Why Choose the Eurostat Scraper?

| Feature | Our Tool | Manual Eurostat Download |
|---------|----------|--------------------------|
| Auto-flatten JSON-stat | ✅ One row per data point | ❌ Nested format |
| Multi-dataset support | ✅ Any dataset code | ⚠️ Per-dataset downloads |
| Country + time filters | ✅ Built-in | ✅ But manual UI |
| Dimension labels | ✅ Included | ⚠️ Codes only |
| Scheduled refresh | ✅ Daily/monthly | ❌ Manual downloads |
| Export to JSON/CSV/Excel | ✅ Yes | ⚠️ Limited formats |

### 📋 How to Use

1. **Sign Up** - [Create a free account w/ $5 credit](https://console.apify.com/sign-up?fpr=vmoqkp)
2. **Configure** - enter a dataset code, optionally filter by country and date
3. **Run It** - click Start and get flat stats ready for analysis

No coding, no JSON-stat wrangling, no copy-paste from tables.

### 🎯 Business Use Cases

- 📊 **Economic research** - track GDP, inflation, and unemployment across EU countries
- 💹 **Financial analysts** - feed Eurostat indicators into macro models and dashboards
- 🏛️ **Policy analysts** - compare labor force, migration, and education stats across member states
- 📰 **Journalists** - pull fresh stats for data journalism pieces on the EU
- 🎓 **Academic research** - download historical time series for papers on European economics
- 🌍 **Consulting firms** - build country profiles with population, trade, and sector data

### ❓ FAQ

🇪🇺 **What is Eurostat?**
Eurostat is the official statistical office of the European Union, publishing harmonized statistics on EU member states and candidate countries.

🔍 **How do I find a dataset code?**
Browse the Eurostat data catalogue on the official Eurostat website. Common codes include `demo_gind` (population), `nama_10_gdp` (GDP), `une_rt_a` (unemployment), and `prc_hicp_manr` (inflation).

🗺️ **Which countries are covered?**
All 27 EU member states plus candidate countries, EFTA states, and selected non-EU countries depending on the dataset.

⏱️ **What time periods are available?**
Varies by dataset - some go back to the 1960s, others start later. Use the Time From / Time To fields to narrow your range.

📊 **What does "auto-flatten" mean?**
Eurostat publishes data in JSON-stat, a compact nested format. This tool expands it into one row per data point, with every dimension included as a column.

### 🔗 Integrate Eurostat Scraper with any app

- [Make](https://docs.apify.com/platform/integrations/make) - automate stats imports
- [Zapier](https://docs.apify.com/platform/integrations/zapier) - push new data releases to your workflows
- [Slack](https://docs.apify.com/platform/integrations/slack) - post monthly stats updates
- [Google Sheets](https://docs.apify.com/platform/integrations/drive) - build live dashboards
- [Webhooks](https://docs.apify.com/platform/integrations/webhooks) - trigger workflows on completion

### 💡 Recommended Actors

Looking for more data collection tools? Check out these related actors:

| Actor | Description | Link |
|-------|-------------|------|
| GSA eLibrary Scraper | US government contract data | [Link](https://apify.com/parseforge/gsa-elibrary-scraper) |
| FINRA BrokerCheck Scraper | Broker registration data | [Link](https://apify.com/parseforge/finra-brokercheck-scraper) |
| Pitchbook Funds Scraper | Private fund profiles | [Link](https://apify.com/parseforge/pitchbook-funds-scraper) |
| LoopNet Business Listings Scraper | Commercial real estate listings | [Link](https://apify.com/parseforge/loopnet-scraper) |
| Franchise Direct Scraper | Franchise opportunity listings | [Link](https://apify.com/parseforge/franchisedirect-scraper) |

**Pro Tip:** 💡 Browse the full [ParseForge catalog](https://apify.com/parseforge) to find more data tools.

### 🆘 Need Help?

- Check the FAQ section above for common questions
- Visit the [Apify documentation](https://docs.apify.com) for platform guides
- Contact us at [Tally contact form](https://tally.so/r/BzdKgA)

### ⚠️ Disclaimer

> This Actor is an independent tool and is not affiliated with, endorsed by, or connected to Eurostat, the European Commission, or any EU institution. It collects only publicly available statistical data.

# Actor input Schema

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

Free users: Limited to 10 data points. Paid users: Optional, max 1,000,000

## `datasetCode` (type: `string`):

Eurostat dataset code. Examples: 'demo\_gind' (population), 'nama\_10\_gdp' (GDP), 'une\_rt\_a' (unemployment), 'prc\_hicp\_manr' (inflation), 'nrg\_ind\_peh' (energy).

## `geo` (type: `string`):

Country codes, comma-separated (e.g. 'DE,FR,IT'). Use 'EU27\_2020' for EU total.

## `timeFrom` (type: `string`):

Start period (e.g. '2020' for yearly, '2020-01' for monthly).

## `timeTo` (type: `string`):

End period.

## Actor input object example

```json
{
  "maxItems": 10,
  "datasetCode": "demo_gind"
}
```

# Actor output Schema

## `overview` (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 = {
    "maxItems": 10,
    "datasetCode": "demo_gind"
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/eurostat-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 = {
    "maxItems": 10,
    "datasetCode": "demo_gind",
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/eurostat-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 '{
  "maxItems": 10,
  "datasetCode": "demo_gind"
}' |
apify call parseforge/eurostat-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Eurostat EU Statistics Scraper",
        "description": "Scrape European Union statistical data from Eurostat. Get GDP, unemployment, inflation, population, trade, and economic indicators for all 27 EU member states plus candidate countries with time series data going back decades.",
        "version": "1.0",
        "x-build-id": "H7DReLkvtC7iDhEuC"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~eurostat-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-eurostat-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/parseforge~eurostat-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-eurostat-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/parseforge~eurostat-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-eurostat-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": {
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Free users: Limited to 10 data points. Paid users: Optional, max 1,000,000"
                    },
                    "datasetCode": {
                        "title": "Dataset Code",
                        "type": "string",
                        "description": "Eurostat dataset code. Examples: 'demo_gind' (population), 'nama_10_gdp' (GDP), 'une_rt_a' (unemployment), 'prc_hicp_manr' (inflation), 'nrg_ind_peh' (energy)."
                    },
                    "geo": {
                        "title": "Geographic Filter",
                        "type": "string",
                        "description": "Country codes, comma-separated (e.g. 'DE,FR,IT'). Use 'EU27_2020' for EU total."
                    },
                    "timeFrom": {
                        "title": "Time From",
                        "type": "string",
                        "description": "Start period (e.g. '2020' for yearly, '2020-01' for monthly)."
                    },
                    "timeTo": {
                        "title": "Time To",
                        "type": "string",
                        "description": "End period."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
