# EU Import Data API (`sourcing-data-studio/eu-import-data-api`) Actor

Unofficial EU import data API: monthly EU trade statistics. Reads Eurostat Comext and returns import or export value in euros, weight, supplementary units and unit values by product code, EU reporter country and partner country.

- **URL**: https://apify.com/sourcing-data-studio/eu-import-data-api.md
- **Developed by:** [Sourcing Data Studio](https://apify.com/sourcing-data-studio) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.60 / 1,000 trade records

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

Size an EU market before you buy stock. EU Import Data API returns monthly Eurostat Comext trade by HS or CN8 product code, EU country and partner country: value in euros, weight, units and euro unit values. Ask how much Germany imported from China under a code last year, or compare the partner countries you name. One clean row per month. You pay only for rows saved: $0.002 per trade record on the Free tier, so a typical query (one product code, 5 EU countries, one partner country, 12 months) costs $0.12.

Unofficial: not affiliated with or endorsed by Eurostat or the European Commission.

Source: Eurostat, Comext dataset DS-045409 (EU trade since 1988 by HS2-4-6 and CN8). Computed unit values are this Actor's own calculation.

Importers, sellers and analysts use this EU import data API to size a market before they buy or list a product. It gives EU market size by product from official trade statistics. Typical questions: how much did Germany import from China in smartphones (HS code 85171300) last year, which countries ship the most furniture into the EU, or what is the average euro price per kilogram of a product in each EU country. It works as an EU imports by HS code API and as an EU export data API, and it answers EU imports from China questions for any product code.

### What does EU Import Data API do?

- Reads the public Eurostat Comext statistics API (dataset DS-045409). No login, no API key.
- Takes product codes with 2, 4, 6 or 8 digits (HS2, HS4, HS6 or CN8), reporting countries, partner countries, import or export, and a month range.
- Returns one row per month, reporting country, partner country and product code.
- Adds two unit values: euros per kilogram and euros per supplementary unit. They are this Actor's own calculation, not Eurostat figures.
- Skips combinations with no trade. Empty combinations are never charged.
- Charges one event per saved row. Failed requests, empty combinations and duplicates are never charged.
- Writes a run summary with totals, failures, warnings and the source line to the key-value store.
- Works from Apify Console, the Apify API, n8n, Make and AI agents through the Apify MCP server.

This is a Eurostat Comext API for trade statistics, a Eurostat trade data API and an HS code trade data API for spreadsheets and databases. It is an EU trade statistics API in a flat format, so you do not need to read the JSON-stat format of the source yourself.

### Output example

These rows come from a real run.

```json
[
  {
    "reporter": "DE",
    "partner": "CN",
    "productCode": "85171300",
    "flow": "import",
    "period": "2025-03",
    "valueEur": 25319670,
    "quantityKg": 58776,
    "supplementaryQuantity": 162758,
    "unitValueEurPerKg": 430.7825,
    "unitValueEurPerUnit": 155.5664,
    "datasetUpdated": "2026-09-15T09:00:00.000Z",
    "source": "Eurostat Comext DS-045409",
    "retrievedAt": "2026-10-06T01:53:56.860Z"
  },
  {
    "reporter": "FR",
    "partner": "CN",
    "productCode": "85171300",
    "flow": "import",
    "period": "2025-03",
    "valueEur": 75425906,
    "quantityKg": 172656,
    "supplementaryQuantity": 607830,
    "unitValueEurPerKg": 436.8566,
    "unitValueEurPerUnit": 124.0905,
    "datasetUpdated": "2026-09-15T09:00:00.000Z",
    "source": "Eurostat Comext DS-045409",
    "retrievedAt": "2026-10-06T01:53:56.860Z"
  },
  {
    "reporter": "NL",
    "partner": "CN",
    "productCode": "85171300",
    "flow": "import",
    "period": "2025-03",
    "valueEur": 567757105,
    "quantityKg": 678867,
    "supplementaryQuantity": 1814666,
    "unitValueEurPerKg": 836.3304,
    "unitValueEurPerUnit": 312.8714,
    "datasetUpdated": "2026-09-15T09:00:00.000Z",
    "source": "Eurostat Comext DS-045409",
    "retrievedAt": "2026-10-06T01:53:56.860Z"
  }
]
```

### What data can you get with EU Import Data API?

| Field | Type | Description |
|---|---|---|
| `reporter` | string | EU member state that declared the trade to Eurostat (the reporting country), as a 2-letter code such as DE. Greece is GR. |
| `partner` | string | Trading partner as Eurostat codes it: a 2-letter country code such as CN, or an aggregate: WORLD (all countries), EXT_EU27_2020 (all countries outside the EU) or INT_EU27_2020 (the other EU member states). |
| `productCode` | string | Product code of the record: an HS2, HS4, HS6 or 8-digit CN8 code, kept as text so leading zeros stay. |
| `flow` | string | import or export, seen from the reporting country. |
| `period` | string | Month of the trade, written YYYY-MM. |
| `valueEur` | number | Value of the goods in euros (Eurostat indicator VALUE_IN_EUROS). |
| `quantityKg` | number | Weight in kilograms (Eurostat indicator QUANTITY_IN_100KG multiplied by 100). It is 0 for goods counted in other units, such as electricity, and for very small shipments. |
| `supplementaryQuantity` | number, optional | Quantity in the product's supplementary unit, for example number of items (Eurostat indicator SUPPLEMENTARY_QUANTITY). The unit depends on the product. It is null, or 0 in older years, when the product has no supplementary unit. |
| `unitValueEurPerKg` | number, optional | Euros per kilogram: valueEur divided by quantityKg, rounded to 4 decimals. This Actor's own calculation. Null when quantityKg is 0. |
| `unitValueEurPerUnit` | number, optional | Euros per supplementary unit: valueEur divided by supplementaryQuantity, rounded to 4 decimals. This Actor's own calculation. Null without a supplementary quantity. |
| `datasetUpdated` | string, optional | Time of the last Eurostat update of dataset DS-045409 when the record was read, as ISO 8601 UTC. The newest months can change in later updates. |
| `source` | string | Name of the source: Eurostat Comext DS-045409. |
| `retrievedAt` | string | ISO 8601 time (UTC) when this Actor read the record. |

How to read the values:

- A **reporter** is the EU country that declared the trade. For an import, the **partner** is the country of origin. For an export, it is the destination.
- Weight in the source is given in 100 kg. The Actor multiplies it by 100, so `quantityKg` is in kilograms.
- `unitValueEurPerKg` and `unitValueEurPerUnit` are the average declared value of all goods in that product code and month. They are not shop prices.
- The newest months can change when Eurostat updates the dataset. `datasetUpdated` tells you which update the row comes from.
- Rows are saved newest month first: the newest month of every reporter and partner, then the second newest, and so on. Sort them yourself if you want another order.

### How to use EU Import Data API

1. Click **Try for free** on this page.
2. Enter one or more **Product codes** as text, for example `85171300`. Keep the quotes so leading zeros stay.
3. Choose the **Reporting countries** and **Partner countries**, and the **Trade flow**. The defaults are DE, FR, NL, IT and ES, partner CN, and import.
4. Enter the **First month** and **Last month** as YYYY-MM. If you leave the first month empty, you get the newest 3 months that have data for each combination, from the 12 months up to the last month.
5. Set **Maximum trade records**. The run stops as soon as that many rows are saved. If your request covers more rows than that, the run log warns you at the start, and the run summary says `truncated: true` when the maximum cut the result (see Limits).
6. Click **Start**. Download the results as JSON, CSV or Excel, or read them through the API.

### Input examples

#### Smartphone imports

```json
{
  "productCodes": [
    "85171300"
  ],
  "reporters": [
    "DE",
    "FR",
    "NL",
    "IT",
    "ES"
  ],
  "partners": [
    "CN"
  ],
  "flow": "import",
  "periodFrom": "2024-01",
  "periodTo": "2024-12",
  "maxItems": 100
}
```

#### Furniture by origin country

```json
{
  "productCodes": [
    "9403"
  ],
  "reporters": [
    "DE"
  ],
  "partners": [
    "CN",
    "VN",
    "PL",
    "TR"
  ],
  "flow": "import",
  "periodFrom": "2023-01",
  "periodTo": "2024-12",
  "maxItems": 200
}
```

#### Latest months car exports

```json
{
  "productCodes": [
    "87032319"
  ],
  "reporters": [
    "DE"
  ],
  "partners": [
    "CN"
  ],
  "flow": "export",
  "maxItems": 50
}
```

### How much does EU Import Data API cost?

| Event | You pay for | Free | Bronze | Silver | Gold |
|---|---|---|---|---|---|
| Trade record | One monthly trade record (reporter, partner, product, value, weight) saved to the dataset. Failed requests and empty cells are never charged. | $0.002 | $0.002 | $0.0018 | $0.0016 |

Prices are per event. Your tier follows your Apify subscription plan.

On the Free tier, $0.002 per trade record means:

- 100 trade records cost $0.20.
- 1,000 trade records cost $2.00.
- A typical query (one product code, 5 EU countries, one partner country, 12 months) is 60 trade records and costs $0.12.

One trade record is one month, reporting country, partner country and product code.

Apify also charges a tiny start fee per run (apify-actor-start, $0.00005 per GB of memory). Failed requests, empty combinations and duplicates are never charged. To cap your spending, set **Maximum cost per run** in the run options; the run stops cleanly when that budget is used.

### Use EU Import Data API from the API, n8n, Make or an AI agent

#### Apify API

Run the Actor and get the trade records in one call:

**curl**

```bash
curl -X POST "https://api.apify.com/v2/acts/sourcing-data-studio~eu-import-data-api/run-sync-get-dataset-items" \
  -H "Authorization: Bearer YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"productCodes":["85171300"],"reporters":["DE","FR","NL","IT","ES"],"partners":["CN"],"flow":"import","periodFrom":"2024-01","periodTo":"2024-12","maxItems":100}'
```

**JavaScript** (Node.js, `npm install apify-client`)

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });

const input = {
    "productCodes": [
        "85171300"
    ],
    "reporters": [
        "DE",
        "FR",
        "NL",
        "IT",
        "ES"
    ],
    "partners": [
        "CN"
    ],
    "flow": "import",
    "periodFrom": "2024-01",
    "periodTo": "2024-12",
    "maxItems": 100
};

const run = await client.actor('sourcing-data-studio/eu-import-data-api').call(input);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

**Python** (`pip install "apify-client>=3"`, Python 3.11 or later)

```python
import os

from apify_client import ApifyClient

client = ApifyClient(os.environ["APIFY_TOKEN"])

run_input = {
    "productCodes": [
        "85171300"
    ],
    "reporters": [
        "DE",
        "FR",
        "NL",
        "IT",
        "ES"
    ],
    "partners": [
        "CN"
    ],
    "flow": "import",
    "periodFrom": "2024-01",
    "periodTo": "2024-12",
    "maxItems": 100
}

run = client.actor("sourcing-data-studio/eu-import-data-api").call(run_input=run_input)

for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)
```

#### n8n and Make

Use an HTTP request module with the same URL, method POST and a JSON body like the input examples above. Store your Apify API token as a credential, never in the workflow itself.

#### AI agents through the Apify MCP server

Connect your agent to the Apify MCP server and call `sourcing-data-studio/eu-import-data-api` with the same input. The input needs `productCodes`; every other field has a default. Agents can use the **Feedback for the developer** field to report missing fields or problems.

### For AI agents

- Minimal input: `{"productCodes": ["85171300"]}`. It returns up to 15 rows (5 reporters, the newest 3 months of each). At the Free price of $0.002 per row that costs at most $0.03, plus the platform's start fee.
- Read first: `period`, `reporter`, `partner`, `valueEur` and `quantityKg`.
- Outcomes live in the run status message and in the `RUN_SUMMARY` record of the run's key-value store. Its `queries` object holds one status per product code: `ok`, `partial`, `no-match`, `unknown-code`, `blocked`, `failed` or `stopped`. `truncated: true` means that **Maximum trade records** cut the result, and `totalRequested` is the most rows the request covers.
- Do not use it for trade by company, transport mode or customs procedure, for trade in services, or for months that Eurostat has not published yet (it is about two months behind).
- It is callable through the Apify MCP server as the tool `sourcing-data-studio/eu-import-data-api` and through the Apify API.

### Limits

- At most 50 product codes, 50 partner countries and 10,000 rows per run. A run may cover at most 100,000 combinations of product code, reporter, partner and month.
- **Maximum trade records:** before it reads anything, the run compares the most rows your request can return (product codes times reporters times partners times months) with this maximum, and the run log warns you if the request is larger.
- If the maximum is smaller than the request, rows are saved newest month first: the newest month of every reporter and partner, then the second newest, and so on, until the maximum is reached. A cut therefore drops the oldest months first. Only when the maximum is smaller than the number of reporter and partner pairs does it leave out whole pairs, the last ones in alphabetical order. Product codes are requested in the order you list them, so a cut can leave out the codes at the end of the list: put the most important code first.
- When the maximum cut the result, the run summary says `truncated: true`, `totalRequested` shows how many rows the request covers at most, and the status message says that there may be more data. Raise the maximum, or ask for fewer product codes, reporters, partners or months, to get everything.
- The Actor keeps a low pace: at most two requests at a time, at least one second between two requests and at most 30 requests per minute. Large runs take longer.
- When Eurostat refuses a request (HTTP 401, 403 or 407), the Actor records it once in the run summary as `blocked`, does not ask again and charges nothing. After HTTP 429 (too many requests) it waits as long as Eurostat asks, up to 60 seconds, and asks again from the same address. It does not ask again if Eurostat asks for a longer pause or says that no request is left. The Actor never changes its address, and never switches a proxy on, to get around a refusal.
- When 5 requests in a row fail, the run stops early and says so in the run summary. Run it again later.
- Switzerland (CH) and Liechtenstein (LI) cannot be reporting countries. Eurostat does not allow resale of trade data declared by them. They can be partner countries.
- Austria (AT) cannot be used with 8-digit product codes, because Eurostat does not allow resale of Austria's data at 8-digit (CN8) level. Use a 2, 4 or 6-digit code for Austria. The input check explains this when you try.
- Eurostat publishes with a delay of about two months, so the newest months may be missing.
- Rows are de-duplicated within a run, not across runs.

### FAQ

#### Which data does EU Import Data API collect?

Only public statistics from Eurostat Comext: trade value, weight and supplementary quantity by month, reporting country, partner country and product code. It does not log in and does not set cookies. It does not collect company names, contact persons, phone numbers, email addresses or any data about individuals. It does not collect trade by company, transport mode or customs procedure. Those are not part of this dataset.

#### Why did my run return 0 rows?

Either there was no trade for your combination in those months, a product code is not listed by Eurostat, or the months are not published yet. The run summary in the **Storage** tab lists product codes Eurostat does not list, partner codes Eurostat does not list and failed requests. Nothing is charged in these cases.

#### Why does the run summary say truncated?

Because **Maximum trade records** cut the result: the run saved that many rows and stopped with rows or requests left behind, so there may be more data than you got. The oldest months are left out first. `totalRequested` is the most rows the request can return. Combinations without trade are not rows, so a run can end below it with nothing cut. Raise the maximum, or narrow the request, to get the rest.

#### Why is Greece GR and not EL?

Eurostat Comext uses GR. The Actor also accepts EL and turns it into GR, for reporting countries and for partner countries. UK is turned into GB. Lower-case codes work too.

#### Why is the weight 0 or the unit value empty?

Some goods are counted in other units, and very small flows can be rounded to 0 kg. Then `unitValueEurPerKg` is null. Many product codes have no supplementary unit. Then `supplementaryQuantity` is null, or 0 in older years, and `unitValueEurPerUnit` is null.

#### Can I schedule EU Import Data API?

Yes. Save your input as a task and add a schedule in Apify Console, for example monthly, after Eurostat has published new data.

#### May I use the data commercially?

Eurostat allows reuse, commercial or not, with acknowledgement of the source. Keep the source line from the top of this page next to the data. The exceptions above (CH, LI and Austria at 8 digits) are blocked by the Actor.

### Feedback

Tell us what to add next in the **Feedback for the developer** input field, or open an issue in the **Issues** tab. Feedback is saved with the run summary.

# Changelog

This Actor's version history is a separate document: https://apify.com/sourcing-data-studio/eu-import-data-api/changelog.md

# Actor input Schema

## `productCodes` (type: `array`):

Required. The goods to look up, as text codes with 2, 4, 6 or 8 digits (HS2, HS4, HS6 or the EU's 8-digit CN8 code). Examples: "85171300" for smartphones, "8517" for telephone sets and other apparatus, "85" for all electrical machinery. Write codes in quotes so leading zeros stay. Dots and spaces are ignored, so 8517.13.00 works. At least one request is made per code, so use at most 50 codes. 8-digit codes cannot be combined with reporter AT (Austria), because Eurostat does not allow resale of Austria's 8-digit data. Codes that Eurostat does not list are reported in the run summary and never charged.

## `reporters` (type: `array`):

The EU member states whose customs declarations you want, as 2-letter codes: AT, BE, BG, CY, CZ, DE, DK, EE, ES, FI, FR, GR, HR, HU, IE, IT, LT, LU, LV, MT, NL, PL, PT, RO, SE, SI or SK. Greece is GR; EL is also accepted. The default is DE, FR, NL, IT and ES. Each reporter gives one record per month: its trade with each partner. Switzerland (CH) and Liechtenstein (LI) cannot be reporters, because Eurostat does not allow resale of their data. Austria (AT) cannot be used with 8-digit product codes for the same reason.

## `partners` (type: `array`):

The countries the goods come from (for imports) or go to (for exports), as 2-letter ISO codes such as CN (China), US, GB (United Kingdom; UK is also accepted), VN, TR or IN. Also accepted: WORLD (all countries), EXT_EU27_2020 (all countries outside the EU) and INT_EU27_2020 (the other EU member states). The default is CN. Use at most 50 partners. A code that Eurostat does not list gives no records and a warning in the run summary.

## `flow` (type: `string`):

import: goods the reporting country buys from the partner. export: goods it sells to the partner. The default is import.

## `periodFrom` (type: `string`):

First month to include, written YYYY-MM, for example 2025-01. The earliest month is 1988-01. If you leave it empty, the run looks at the 12 months up to the last month and gives you the newest 3 months that have data for each reporter, partner and product. Eurostat publishes with a delay of about two months, so the newest months may be missing.

## `periodTo` (type: `string`):

Last month to include, written YYYY-MM, for example 2025-03. If empty, the run goes up to the current month. A month in the future means the current month. If you give only the last month, you get the newest 3 months with data in the 12 months up to it. The run covers at most 100,000 combinations of product code, reporter, partner and month.

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

Maximum number of monthly trade records to save and pay for in this run, across all product codes, countries and months. One record is one reporter, partner, product code and month. The run stops as soon as this many records are saved. If your request covers more records, the run log warns you at the start, the newest months of each reporter and partner are saved first, and the run summary says truncated. The default is 100.

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

Optional. The Eurostat API is public and answers direct requests, so no proxy is used by default. Use a proxy only if your network needs one. The Actor sends all requests of a run from one address and never uses another address to get around a refusal (HTTP 401, 403, 407 or 429).

## `maxRequestRetries` (type: `integer`):

How many times a failed request is retried, with a growing pause between tries. A refusal (HTTP 401, 403 or 407) is never retried. After HTTP 429 the Actor waits as long as Eurostat asks, up to 60 seconds, and asks again from the same address. Failed requests are never charged. The run stops early when 5 requests in a row fail.

## `debugLog` (type: `boolean`):

Print detailed debug messages to the run log.

## `feedback` (type: `string`):

Optional. Tell us which product codes, countries or fields you need next, or what went wrong. It is saved with the run summary. Do not include personal data. AI agents may also use this field to report problems.

## Actor input object example

```json
{
  "productCodes": [
    "85171300"
  ],
  "reporters": [
    "DE",
    "FR",
    "NL"
  ],
  "partners": [
    "CN"
  ],
  "flow": "import",
  "periodFrom": "2025-01",
  "periodTo": "2025-03",
  "maxItems": 10,
  "proxyConfiguration": {
    "useApifyProxy": false
  },
  "maxRequestRetries": 3,
  "debugLog": false
}
```

# 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 = {
    "productCodes": [
        "85171300"
    ],
    "reporters": [
        "DE",
        "FR",
        "NL"
    ],
    "partners": [
        "CN"
    ],
    "periodFrom": "2025-01",
    "periodTo": "2025-03",
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("sourcing-data-studio/eu-import-data-api").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 = {
    "productCodes": ["85171300"],
    "reporters": [
        "DE",
        "FR",
        "NL",
    ],
    "partners": ["CN"],
    "periodFrom": "2025-01",
    "periodTo": "2025-03",
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("sourcing-data-studio/eu-import-data-api").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 '{
  "productCodes": [
    "85171300"
  ],
  "reporters": [
    "DE",
    "FR",
    "NL"
  ],
  "partners": [
    "CN"
  ],
  "periodFrom": "2025-01",
  "periodTo": "2025-03",
  "maxItems": 10
}' |
apify call sourcing-data-studio/eu-import-data-api --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,sourcing-data-studio/eu-import-data-api"
        }
    }
}
```

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/KnU0fQI0SYgN2YfIP/builds/LQMXIrVZkbQqTghYb/openapi.json