# Eurostat Data Scraper — EU Statistics & Indicators (`logiover/eurostat-data-scraper`) Actor

Scrape Eurostat by dataset code or browse the catalog. Extract geo, time, value, unit, and all dimensions for GDP, population, employment, trade, and more. No API key, no login.

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

## Pricing

from $1.50 / 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/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

## Eurostat Data Scraper — EU Statistics, Indicators & Datasets API

Extract any Eurostat dataset as clean, flat rows — no API key, no login, unlimited results.

### What does Eurostat Data Scraper do?

Eurostat is the statistical office of the European Union and publishes authoritative data on GDP, population, employment, trade, inflation, energy, agriculture, and hundreds of other socioeconomic topics for EU member states and partner countries. This actor connects directly to the **official Eurostat dissemination API** (`https://ec.europa.eu/eurostat/api/dissemination/statistics/1.0/data/{dataset}`) which returns machine-readable **JSON-stat format** — a compact multi-dimensional representation used by statistical agencies worldwide.

The actor automatically decodes the JSON-stat structure: it reads the dimension metadata (country, time period, unit, frequency, and any dataset-specific dimensions like age, sex, or NACE industry code), then performs a Cartesian expansion to produce one flat row per valid data cell. Filters for country codes and time range are applied via the Eurostat API query parameters so only the data you need is transferred. A second mode, **catalog**, fetches the full Eurostat Table of Contents — over 6,000 datasets organised in a hierarchical theme tree — so you can discover dataset codes without leaving the actor.

### Who is it for?

- **Economists and researchers** who need time-series EU data for modelling, regression analysis, or academic papers without clicking through the Eurostat web interface.
- **Data journalists** tracking EU-wide trends in employment, cost of living, or energy prices across multiple countries and years.
- **Business analysts** comparing GDP, purchasing power, or trade flows across EU markets to inform market entry decisions.
- **Policy analysts and think tanks** monitoring Eurostat indicator updates for policy briefs and advocacy reports.
- **Developers and data engineers** building dashboards, data pipelines, or automated reports that need fresh EU statistics on a schedule.

### Use cases

- Download annual population data by age and sex for all 27 EU member states from `demo_pjan` to build demographic charts.
- Pull quarterly GDP growth rates from `namq_10_gdp` filtered to France, Germany, and Italy from 2015 onward for a eurozone comparison.
- Export harmonised consumer price indices (HICP) from `prc_hicp_midx` to track inflation across EU countries for a financial model.
- Browse the full Eurostat catalog in catalog mode to discover less-known datasets on agriculture, environment, or digital economy.
- Schedule monthly runs to keep a Google Sheet updated with the latest Eurostat employment figures from `lfsa_egan`.

### Why use Eurostat Data Scraper?

- **No API key required** — Eurostat's dissemination API is fully public and keyless; just pick a dataset code and run.
- **12+ output fields** — dataset code, country code, country name, time period, value, unit, frequency, status flag, and all extra dimensions (age, sex, industry, etc.) serialised as structured JSON.
- **Thousands of rows per run** — one dataset can contain millions of cells across 40+ countries and 30+ years; the actor streams them all without truncation.
- **Geo and time filters** — pass `geoFilter: ["DE","FR"]` and `timeFrom: "2010"` to request only the slice you need, reducing both run time and memory.
- **Two modes** — `datasetData` for deep extraction, `catalog` for exploring the 6,000+ dataset hierarchy.
- **Export to CSV, JSON, or Excel** — use Apify's built-in dataset export to download results in any format after the run.
- **Pay-per-result pricing** — you only pay for the rows the actor actually produces, making it cost-efficient for targeted queries.

### What data can you extract?

The actor produces one row per non-null data cell in the Eurostat dataset. Here is every field:

| Field | Type | Description |
|---|---|---|
| `dataset` | string | Eurostat dataset code (e.g. `demo_pjan`) |
| `datasetLabel` | string | Human-readable dataset title |
| `geo` | string | ISO 2-letter country/region code (e.g. `DE`, `EU27_2020`) |
| `geoLabel` | string | Country or region name (e.g. `Germany`) |
| `time` | string | Time period (e.g. `2023`, `2023-Q1`, `2023-01`) |
| `value` | string | Numeric value for this cell (as string; use number format in display) |
| `unit` | string | Unit code (e.g. `NR`, `PC`, `EUR_HAB`) |
| `unitLabel` | string | Unit label (e.g. `Number`, `Percentage`, `Euro per inhabitant`) |
| `freq` | string | Frequency code: `A` annual, `Q` quarterly, `M` monthly |
| `status` | string | Eurostat status flag: `b` break, `e` estimated, `p` provisional, empty = normal |
| `extraDimensions` | string | JSON object with additional dimensions (age, sex, NACE code, etc.) and their codes/labels |
| `updatedAt` | string | ISO date when Eurostat last updated this dataset |

**Example output row (demo_pjan — population by age and sex, Germany 2023):**

```json
{
  "dataset": "demo_pjan",
  "datasetLabel": "Population on 1 January by age and sex",
  "geo": "DE",
  "geoLabel": "Germany",
  "time": "2023",
  "value": "83118501",
  "unit": "NR",
  "unitLabel": "Number",
  "freq": "A",
  "status": "",
  "extraDimensions": "{\"age\":{\"code\":\"TOTAL\",\"label\":\"Total\"},\"sex\":{\"code\":\"T\",\"label\":\"Total\"}}",
  "updatedAt": "2024-09-25T11:00:00+0200"
}
````

### How to use

#### Option A — Fetch a specific dataset (datasetData mode)

1. Open the actor and set **Mode** to `Dataset Data`.
2. Enter the **Dataset Code** (e.g. `demo_pjan`). Find codes in the [Eurostat Data Browser](https://ec.europa.eu/eurostat/databrowser/) or use catalog mode.
3. Optionally add **Geo Filter** country codes (leave empty for all countries).
4. Optionally set **Time From** and **Time To** (e.g. `2010` and `2023`).
5. Set **Max Results** to `0` for no limit, or a number to cap rows.
6. Click **Start** and download your data as CSV, JSON, or Excel.

**Input example:**

```json
{
  "mode": "datasetData",
  "dataset": "demo_pjan",
  "geoFilter": ["DE", "FR", "IT", "ES", "PL"],
  "timeFrom": "2015",
  "timeTo": "2023",
  "maxResults": 0
}
```

#### Option B — Browse the catalog (catalog mode)

1. Set **Mode** to `Catalog`.
2. Leave all other fields at defaults.
3. Run — the actor fetches the full Eurostat Table of Contents and outputs each entry as a row with its code, title, type (folder/table/dataset), data range, and value count.

**Input example:**

```json
{
  "mode": "catalog",
  "maxResults": 500
}
```

Use the catalog output to find dataset codes, then switch to `datasetData` mode with the code you need.

### Input parameters

| Parameter | Type | Default | Description |
|---|---|---|---|
| `mode` | string | `datasetData` | `datasetData`: fetch and flatten a dataset. `catalog`: list all datasets. |
| `dataset` | string | `demo_pjan` | Eurostat dataset code. Required in datasetData mode. |
| `geoFilter` | array | `[]` | ISO-2 country codes to include (empty = all). Example: `["DE","FR","IT"]`. |
| `timeFrom` | string | — | Start period filter. Example: `2010` or `2010-Q1`. |
| `timeTo` | string | — | End period filter. Example: `2023` or `2023-Q4`. |
| `maxResults` | integer | `0` | Max rows to output. `0` = unlimited. |
| `proxyConfiguration` | object | Apify datacenter | Proxy settings. Datacenter works well for Eurostat's public API. |

**Full input JSON:**

```json
{
  "mode": "datasetData",
  "dataset": "nama_10_gdp",
  "geoFilter": ["DE", "FR", "IT", "ES", "NL", "BE", "PL", "SE"],
  "timeFrom": "2000",
  "timeTo": "2023",
  "maxResults": 0,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["SHADER"]
  }
}
```

### Output example

```json
[
  {
    "dataset": "demo_pjan",
    "datasetLabel": "Population on 1 January by age and sex",
    "geo": "DE",
    "geoLabel": "Germany",
    "time": "2023",
    "value": "83118501",
    "unit": "NR",
    "unitLabel": "Number",
    "freq": "A",
    "status": "",
    "extraDimensions": "{\"age\":{\"code\":\"TOTAL\",\"label\":\"Total\"},\"sex\":{\"code\":\"T\",\"label\":\"Total\"}}",
    "updatedAt": "2024-09-25T11:00:00+0200"
  },
  {
    "dataset": "demo_pjan",
    "datasetLabel": "Population on 1 January by age and sex",
    "geo": "FR",
    "geoLabel": "France",
    "time": "2023",
    "value": "68287000",
    "unit": "NR",
    "unitLabel": "Number",
    "freq": "A",
    "status": "p",
    "extraDimensions": "{\"age\":{\"code\":\"TOTAL\",\"label\":\"Total\"},\"sex\":{\"code\":\"T\",\"label\":\"Total\"}}",
    "updatedAt": "2024-09-25T11:00:00+0200"
  }
]
```

### Tips for best results

- **Find dataset codes** using catalog mode first or visit [Eurostat Data Browser](https://ec.europa.eu/eurostat/databrowser/) and copy the code from the URL.
- **Use geo filters** when you only need a handful of countries — this reduces response size from the API and speeds up the run.
- **Use time filters** for long time-series datasets with monthly data (e.g. `ei_cphi_m` has data back to 1996 across 30+ countries — that's millions of cells).
- **Check the `extraDimensions` field** — many datasets have dimensions like `age`, `sex`, `nace_r2`, or `indic_na`. Parse the JSON to filter further in your downstream pipeline.
- **Status flags matter** — `p` = provisional, `e` = estimated, `b` = break in series. Filter these out if you need only confirmed data.
- **Null values are skipped** — Eurostat uses null for missing country-year combinations; the actor already excludes these so your data is clean.
- **Schedule monthly runs** for datasets updated monthly (check `updatedAt` in results to see the cadence).
- **Combine with Google Sheets integration** to maintain a live EU statistics dashboard that auto-refreshes.
- **Dataset `demo_pjan`** (population) is a great starting point — it covers all EU countries, has age and sex breakdowns, and data back to 1960.
- **For GDP data**, try `nama_10_gdp` (annual national accounts) or `namq_10_gdp` (quarterly). For employment, try `lfsa_egan`.

### Integrations

**Google Sheets** — Connect via Apify's native Google Sheets integration to write results directly to a spreadsheet. Combine with a monthly schedule for an auto-updating EU statistics dashboard.

**Slack** — Use Apify's Slack integration to receive a notification with the run summary (row count, dataset, time range) whenever a scheduled run completes.

**Zapier / Make** — Trigger downstream workflows when new Eurostat data arrives. Example: push new population data to Airtable or update a CRM field with country GDP figures.

**Webhooks** — Configure a webhook on Actor run finish to send the dataset URL to your own endpoint for immediate ingestion.

**Schedule** — Set up a monthly or quarterly cron schedule in Apify to keep your dataset fresh as Eurostat publishes new releases.

### API usage

**cURL:**

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/logiover~eurostat-data-scraper/runs?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"dataset":"demo_pjan","geoFilter":["DE","FR"],"timeFrom":"2020"}'
```

**Node.js (Apify client):**

```javascript
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: 'YOUR_TOKEN' });
const run = await client.actor('logiover/eurostat-data-scraper').call({
  dataset: 'demo_pjan',
  geoFilter: ['DE', 'FR', 'IT'],
  timeFrom: '2015',
  timeTo: '2023',
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

**Python:**

```python
from apify_client import ApifyClient
client = ApifyClient("YOUR_TOKEN")
run = client.actor("logiover/eurostat-data-scraper").call(run_input={
    "dataset": "demo_pjan",
    "geoFilter": ["DE", "FR", "IT"],
    "timeFrom": "2015",
    "timeTo": "2023",
})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["geo"], item["time"], item["value"])
```

### Use with AI agents (MCP)

This actor is available via Apify's Model Context Protocol (MCP) server, which means you can plug it directly into Claude, GPT-4, or any MCP-compatible AI agent. Ask your agent: *"Use the Eurostat Data Scraper to fetch quarterly GDP data for France and Germany from 2010 to 2023, then draw a comparison chart."* The agent will call the actor, receive structured rows, and can immediately reason over the data without any manual download step.

### FAQ

#### Does this actor require an API key or account?

No. The Eurostat dissemination API is fully public and keyless. You only need your Apify token to run the actor itself, not any Eurostat credentials.

#### Which datasets are available?

Eurostat publishes over 6,000 tables and datasets covering population, GDP, employment, trade, agriculture, environment, energy, health, education, and more. Run catalog mode to see the full list. The [Eurostat Data Browser](https://ec.europa.eu/eurostat/databrowser/) is another good discovery tool.

#### How many rows can one run produce?

There is no hard limit. A dataset like `ei_cphi_m` (harmonised consumer prices, monthly) contains over 1 million cells across all countries and years. The actor streams all non-null rows. Use `maxResults` and time/geo filters to cap the output if needed.

#### What does a `null` value in the source mean?

Eurostat datasets often have missing cells where a country did not report data for a specific period. The actor **skips null cells** entirely, so every row you receive has a real numeric value.

#### Why are some values flagged with `p` or `e` in the status field?

Eurostat uses status flags: `p` = provisional (may be revised), `e` = estimated, `b` = break in series (methodology changed), `c` = confidential. Filter on `status === ""` if you only want confirmed, final data.

#### Can I export the data to Excel or CSV?

Yes. After a run, open the dataset in Apify and click Export → CSV or Excel. You can also use the API to download in any supported format programmatically.

#### How fast is the actor?

A typical country-filtered dataset (e.g. 5 countries, 10 years, annual frequency) finishes in under 30 seconds. Very large unfiltered datasets with monthly data and 40+ countries may take 2–5 minutes depending on response size.

#### Is the data real-time?

No. Eurostat publishes statistical data on a release calendar — annual data is typically updated once a year, quarterly data every 3 months, and monthly indicators within 30–60 days of the reference period. The `updatedAt` field in each row tells you when Eurostat last updated the dataset.

#### Can I fetch multiple datasets in one run?

The current version fetches one dataset per run. To fetch multiple datasets, start a separate run for each or use Apify's batch run API.

#### How do I know what dimensions a dataset has?

The `extraDimensions` field in your output shows all dimensions beyond the standard four (geo, time, unit, freq). For a full preview, run the actor once with a narrow geo/time filter and inspect the first few rows.

#### Is this actor related to other EU open data scrapers?

Yes — see also the [World Bank Data Scraper](https://apify.com/logiover/world-bank-data-scraper) and the [EU Companies Registry Scraper](https://apify.com/logiover/eu-companies-registry-scraper) for complementary datasets.

#### How often should I schedule runs?

Eurostat release calendars vary by dataset. Monthly indicators (HICP, unemployment) update roughly every 30 days. Annual datasets (population, national accounts) update once or twice a year. Check the `updatedAt` field after each run to see if fresh data has arrived.

### Is it legal?

Eurostat data is published by the European Commission under the [Eurostat copyright policy](https://ec.europa.eu/eurostat/about/policies/copyright), which permits free reuse for commercial and non-commercial purposes with attribution. The actor accesses only the official, publicly documented dissemination API and sends no authentication credentials. No personal data is collected. Always cite Eurostat as your source when publishing derived work.

### Related scrapers

- [World Bank Data Scraper](https://apify.com/logiover/world-bank-data-scraper) — Global development indicators, GDP, health, and education data for 200+ countries.
- [Comtrade Trade Data Scraper](https://apify.com/logiover/comtrade-trade-data-scraper) — UN international trade statistics by commodity, country, and year.
- [EU Companies Registry Scraper](https://apify.com/logiover/eu-companies-registry-scraper) — Company registration data from EU national business registers.
- [OpenAlex Academic Papers Scraper](https://apify.com/logiover/openalex-academic-papers-scraper) — Research papers citing Eurostat and other EU data sources.

# Actor input Schema

## `mode` (type: `string`):

datasetData: fetch and flatten a specific dataset. catalog: list all available datasets from the Eurostat Table of Contents.

## `dataset` (type: `string`):

Eurostat dataset code to fetch (e.g. 'demo\_pjan' = population, 'nama\_10\_gdp' = GDP, 'une\_rt\_a' = unemployment). Used in datasetData mode. Browse codes with catalog mode.

## `geoFilter` (type: `array`):

ISO 2-letter country/geo codes to filter by (e.g. DE, FR, IT). Sent to the Eurostat API for a server-side reduction. Leave empty to fetch ALL geos (can be very large for some datasets).

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

Start year/period (e.g. '2015' or '2015-Q1'). Sent to the API as a lower bound. Leave empty for no lower bound.

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

End year/period (e.g. '2023' or '2023-Q4'). Applied as an upper bound. Leave empty for no upper bound.

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

Maximum number of rows to output. Keeps empty-input runs fast. Raise it (or set 0 for no limit) to pull everything.

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

Apify proxy settings. Automatic proxy is recommended; the actor also falls back to a direct connection if the proxy is unavailable.

## Actor input object example

```json
{
  "mode": "datasetData",
  "dataset": "demo_pjan",
  "geoFilter": [
    "DE",
    "FR",
    "IT",
    "ES",
    "PL"
  ],
  "timeFrom": "2015",
  "maxResults": 5000,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

All records extracted by this run. Open the Dataset tab to browse, filter, and export as CSV, JSON, or Excel.

# 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 = {
    "dataset": "demo_pjan",
    "geoFilter": [
        "DE",
        "FR",
        "IT",
        "ES",
        "PL"
    ],
    "timeFrom": "2015",
    "maxResults": 5000
};

// Run the Actor and wait for it to finish
const run = await client.actor("logiover/eurostat-data-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 = {
    "dataset": "demo_pjan",
    "geoFilter": [
        "DE",
        "FR",
        "IT",
        "ES",
        "PL",
    ],
    "timeFrom": "2015",
    "maxResults": 5000,
}

# Run the Actor and wait for it to finish
run = client.actor("logiover/eurostat-data-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 '{
  "dataset": "demo_pjan",
  "geoFilter": [
    "DE",
    "FR",
    "IT",
    "ES",
    "PL"
  ],
  "timeFrom": "2015",
  "maxResults": 5000
}' |
apify call logiover/eurostat-data-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Eurostat Data Scraper — EU Statistics & Indicators",
        "description": "Scrape Eurostat by dataset code or browse the catalog. Extract geo, time, value, unit, and all dimensions for GDP, population, employment, trade, and more. No API key, no login.",
        "version": "1.0",
        "x-build-id": "pEFQ42iWDWATleta8"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/logiover~eurostat-data-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-logiover-eurostat-data-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/logiover~eurostat-data-scraper/runs": {
            "post": {
                "operationId": "runs-sync-logiover-eurostat-data-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/logiover~eurostat-data-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-logiover-eurostat-data-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": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "datasetData",
                            "catalog"
                        ],
                        "type": "string",
                        "description": "datasetData: fetch and flatten a specific dataset. catalog: list all available datasets from the Eurostat Table of Contents.",
                        "default": "datasetData"
                    },
                    "dataset": {
                        "title": "Dataset Code",
                        "type": "string",
                        "description": "Eurostat dataset code to fetch (e.g. 'demo_pjan' = population, 'nama_10_gdp' = GDP, 'une_rt_a' = unemployment). Used in datasetData mode. Browse codes with catalog mode.",
                        "default": "demo_pjan"
                    },
                    "geoFilter": {
                        "title": "Geo Filter (country codes)",
                        "type": "array",
                        "description": "ISO 2-letter country/geo codes to filter by (e.g. DE, FR, IT). Sent to the Eurostat API for a server-side reduction. Leave empty to fetch ALL geos (can be very large for some datasets).",
                        "default": [
                            "DE",
                            "FR",
                            "IT",
                            "ES",
                            "PL"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "timeFrom": {
                        "title": "Time From",
                        "type": "string",
                        "description": "Start year/period (e.g. '2015' or '2015-Q1'). Sent to the API as a lower bound. Leave empty for no lower bound.",
                        "default": "2015"
                    },
                    "timeTo": {
                        "title": "Time To",
                        "type": "string",
                        "description": "End year/period (e.g. '2023' or '2023-Q4'). Applied as an upper bound. Leave empty for no upper bound."
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of rows to output. Keeps empty-input runs fast. Raise it (or set 0 for no limit) to pull everything.",
                        "default": 5000
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Apify proxy settings. Automatic proxy is recommended; the actor also falls back to a direct connection if the proxy is unavailable.",
                        "default": {
                            "useApifyProxy": true
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
