# EU EURES Jobs Scraper (`parseforge/eu-eures-jobs-scraper`) Actor

Export European job vacancies from the EURES European Job Mobility Portal. Search by keyword, country, occupation, contract type, and education level across 30+ European countries. Pull title, employer, location, salary, requirements, and posting date.

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

## Pricing

from $3.75 / 1,000 result items

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://github.com/ParseForge/apify-assets/blob/ad35ccc13ddd068b9d6cba33f323962e39aed5b2/banner.jpg?raw=true)

## 🇪🇺 EU EURES Jobs Scraper

> 🚀 **Export cross-border European job postings in seconds.** Search the EURES European Job Mobility Portal across **32 EU/EEA countries**, by keyword, country, contract type, education level, and experience. No login, no manual CSV wrangling.

> 🕒 **Last updated:** 2026-05-21 · **📊 34 fields** per record · **🇪🇺 32 countries** · **💼 cross-border jobs** · **🌐 daily refresh**

The **EU EURES Jobs Scraper** exports vacancies from the European Employment Services (EURES) portal, the official labor-mobility platform of the European Commission. Each record returns **24 fields**, including job ID, EURES reference, title, employer name and country, full position location, occupation codes (ESCO), sector, contract type, working time, education and experience requirements, languages, salary range, publication date and deadline, full job description, apply URL, and detail URL.

Coverage spans **all 27 EU member states plus EEA partners** (Iceland, Liechtenstein, Norway, Switzerland) and the United Kingdom (legacy data), with vacancies sourced from national public employment services and registered employer partners across every economic sector.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| EU recruiters, mobility platforms, labor economists, ATS integrators, relocation services, journalists | Cross-border talent search, EU labor-market dashboards, ESCO occupation analytics, salary benchmarking, mobility research, talent-pipeline enrichment |

---

### 📋 What the EU EURES Jobs Scraper does

Five filtering workflows in a single run:

- 🔎 **Keyword search.** Free-text search like `software engineer`, `nurse`, `chef`, applied across every posting.
- 🇪🇺 **Country filter.** Restrict to one or many EU/EEA countries.
- 📜 **Contract type filter.** Permanent, temporary, apprenticeship, internship, seasonal.
- ⏰ **Working time filter.** Full-time or part-time.
- 🎓 **Education and experience filters.** From "no formal qualification" through doctorate, and from "less than 1 year" through "5+ years".

Each record carries identifiers (job ID, EURES reference), employer info (name, country), full location (country, city, region, address), ESCO occupation codes, sector, contract and working-time classification, education and experience requirements, language requirements (with proficiency level), salary range, publication and deadline dates, full description, and ready-to-use apply and detail URLs.

> 💡 **Why it matters:** EURES is the only pan-European job board with a unified taxonomy and cross-border focus. Pulling vacancies yourself means handling pagination, ESCO code resolution, and per-country quirks. This Actor returns a clean per-job row ready for your ATS, dashboard, or labor-market model.

---

### 🎬 Full Demo

_🚧 Coming soon: a 3-minute walkthrough showing how to go from sign-up to a downloaded EURES dataset._

---

### ⚙️ Input

<table>
<thead>
<tr><th>Input</th><th>Type</th><th>Default</th><th>Behavior</th></tr>
</thead>
<tbody>
<tr><td><code>maxItems</code></td><td>integer</td><td><code>10</code></td><td>Records to return. Free plan caps at 10, paid plan at 1,000,000.</td></tr>
<tr><td><code>keyword</code></td><td>string</td><td><code>"software engineer"</code></td><td>Free-text job keyword.</td></tr>
<tr><td><code>countries</code></td><td>array</td><td><code>[]</code></td><td>Filter to specific EU/EEA countries. Empty = all 32.</td></tr>
<tr><td><code>contractType</code></td><td>array</td><td><code>[]</code></td><td>Permanent, temporary, apprenticeship, internship, seasonal, no-info.</td></tr>
<tr><td><code>workingTime</code></td><td>array</td><td><code>[]</code></td><td>Full-time, part-time.</td></tr>
<tr><td><code>educationLevel</code></td><td>array</td><td><code>[]</code></td><td>None through doctorate.</td></tr>
<tr><td><code>experienceLevel</code></td><td>array</td><td><code>[]</code></td><td>less-than-1-year, 1-2-years, 2-5-years, 5+-years.</td></tr>
</tbody>
</table>

**Example: every software engineering permanent job in Germany and Belgium.**

```json
{
    "maxItems": 200,
    "keyword": "software engineer",
    "countries": ["DE", "BE"],
    "contractType": ["permanent"],
    "workingTime": ["full-time"]
}
````

**Example: nursing roles requiring 2-5 years of experience across the Nordics.**

```json
{
    "maxItems": 100,
    "keyword": "nurse",
    "countries": ["DK", "FI", "IS", "NO", "SE"],
    "experienceLevel": ["2-5-years"]
}
```

> ⚠️ **Good to Know:** EURES aggregates from national public employment services, so per-country field completeness varies. Salary, education level, and language requirements are populated when the source service supplies them. Title, employer, country, and apply URL are present on virtually every record.

***

### 📊 Output

Each EURES job record contains **24 fields**. Download the dataset as CSV, Excel, JSON, or XML.

#### 🧾 Schema

| Field | Type | Example |
|---|---|---|
| 🆔 `jobId` | string | `"MTE3Mjg4MjYgNDQx"` |
| 🔖 `reference` | string | `"11728826"` |
| 💼 `title` | string | `"Software Engineer"` |
| 🏢 `employerName` | string | `"ODOO"` |
| 🏷️ `employerLegalId` | string | null | `"2281178395"` |
| 🇪🇺 `employerCountry` | string | `"BE"` |
| 📍 `positionLocation` | string | `"Louvain-la-Neuve, BE"` |
| 🇪🇺 `country` | string | `"BE"` |
| 🏙️ `city` | string | `"Louvain-la-Neuve"` |
| 🗺️ `region` | string | null | `"Walloon Brabant"` |
| 🏷️ `occupation` | string | `"Software developer"` |
| 🏷️ `sector` | string | null | `"j62.0.2"` |
| 📜 `contractType` | string | null | `"directhire"` |
| ⏰ `workingTime` | string | null | `"full-time"` |
| 🎓 `educationLevel` | string | null | `"bachelor"` |
| 🏆 `experienceYears` | number | null | `0` |
| 🗣️ `languages` | array | `[{"code": "en", "level": null}]` |
| 💰 `salary` | object | null | `{"min": 45000, "max": 60000, "currency": "EUR", "period": "annual"}` |
| 📅 `publicationDate` | ISO 8601 | `"2026-01-08T14:00:55.850Z"` |
| 📅 `applicationDeadline` | string | null | `"2026-06-30"` |
| 📄 `description` | string | full job description |
| 🔗 `applyUrl` | string | null | direct apply link |
| 🔗 `detailUrl` | string | `"https://europa.eu/eures/portal/jv-se/jv-details/..."` |
| 🕒 `scrapedAt` | ISO 8601 | `"2026-05-20T22:14:36.203Z"` |
| ❗ `error` | string | null | populated only on failure |

#### 📦 Sample records

<details>
<summary><strong>💻 Software Engineer at Odoo, Belgium</strong></summary>

```json
{
    "jobId": "MTE3Mjg4MjYgNDQx",
    "reference": "11728826",
    "title": "Software Engineer",
    "employerName": "ODOO",
    "employerLegalId": "2281178395",
    "employerCountry": "BE",
    "positionLocation": "Louvain-la-Neuve, BE",
    "country": "BE",
    "city": "Louvain-la-Neuve",
    "occupation": "Software developer",
    "sector": "j62.0.2",
    "contractType": "directhire",
    "experienceYears": 0,
    "languages": [{"code": "en", "level": null}],
    "numberOfPosts": 25,
    "publicationDate": "2026-01-08T14:00:55.850Z",
    "description": "Most of the time, we deliver a standard version of Odoo to our customers...",
    "source": "Forem",
    "detailUrl": "https://europa.eu/eures/portal/jv-se/jv-details/MTE3Mjg4MjYgNDQx?lang=en",
    "scrapedAt": "2026-05-20T22:14:36.203Z"
}
```

</details>

<details>
<summary><strong>👩‍⚕️ Registered Nurse, Sweden</strong></summary>

```json
{
    "jobId": "MTI0NTU3OTEgU0U=",
    "reference": "12455791",
    "title": "Registered Nurse (Norwegian-speaking)",
    "employerName": "Stockholm Region Vårdcentral",
    "employerCountry": "SE",
    "positionLocation": "Stockholm, SE",
    "country": "SE",
    "city": "Stockholm",
    "contractType": "permanent",
    "workingTime": "full-time",
    "educationLevel": "bachelor",
    "experienceYears": 3,
    "languages": [
        {"code": "sv", "level": "B2"},
        {"code": "no", "level": "B2"}
    ],
    "salary": {"min": 38000, "max": 46000, "currency": "SEK", "period": "monthly"},
    "publicationDate": "2026-04-15T09:12:00.000Z",
    "applicationDeadline": "2026-06-30",
    "detailUrl": "https://europa.eu/eures/portal/jv-se/jv-details/MTI0NTU3OTEgU0U=?lang=en",
    "scrapedAt": "2026-05-20T22:14:36.203Z"
}
```

</details>

<details>
<summary><strong>🍳 Seasonal Chef, Greece</strong></summary>

```json
{
    "jobId": "MTI2NDgwNTUgR1I=",
    "title": "Head Chef - Summer Season",
    "employerName": "Aegean Resort Group",
    "country": "GR",
    "city": "Mykonos",
    "contractType": "seasonal",
    "workingTime": "full-time",
    "experienceYears": 5,
    "languages": [
        {"code": "el", "level": "B1"},
        {"code": "en", "level": "B2"}
    ],
    "salary": {"min": 2200, "max": 3200, "currency": "EUR", "period": "monthly"},
    "applicationDeadline": "2026-05-31",
    "detailUrl": "https://europa.eu/eures/portal/jv-se/jv-details/MTI2NDgwNTUgR1I=?lang=en",
    "scrapedAt": "2026-05-20T22:14:36.203Z"
}
```

</details>

***

### ✨ Why choose this Actor

| | Capability |
|---|---|
| 🇪🇺 | **Pan-European coverage.** Vacancies from every EU member state plus EEA partners. |
| 🏷️ | **Unified taxonomy.** ESCO occupation codes give you a clean joining key across countries and languages. |
| 🎓 | **Rich requirements.** Education, experience, language proficiency, salary range surfaced per record. |
| ⚡ | **Fast.** 10 jobs in under 5 seconds, 10,000 jobs in under five minutes. |
| 🔁 | **Always fresh.** Every run pulls live vacancies, so your dataset reflects the current EURES state. |
| 🇪🇺 | **Official source.** Maintained by the European Commission and national public employment services. |
| 🚫 | **No keys to manage.** No personal token required. |

> 📊 EURES is the canonical reference for EU labor mobility, used by recruiters, governments, and academic researchers across the bloc.

***

### 📈 How it compares to alternatives

| Approach | Cost | Coverage | Refresh | Filters | Setup |
|---|---|---|---|---|---|
| **⭐ EU EURES Jobs Scraper** *(this Actor)* | $5 free credit, then pay-per-use | **32 countries** | **Live per run** | keyword, country, contract, time, education, experience | ⚡ 2 min |
| Build your own pipeline | Free, but engineering hours | Full EURES if you build it | Manual | DIY | 🐢 Days |
| Commercial European job aggregators | $500+/month | Vendor-curated subset | Vendor cadence | Vendor's | ⏳ Hours |
| Per-country national portals | Free | One country at a time | Variable | Per-portal | 🕒 Weeks |

Pick this Actor when you want every EURES vacancy across the EU in a single normalized shape with no per-country pipeline to maintain.

***

### 🚀 How to use

1. 📝 **Sign up.** [Create a free account with $5 credit](https://console.apify.com/sign-up?fpr=vmoqkp) (takes 2 minutes).
2. 🌐 **Open the Actor.** Go to the EU EURES Jobs Scraper page on the Apify Store.
3. 🎯 **Set input.** Type a keyword, pick countries, optionally add contract, education, or experience filters, set `maxItems`.
4. 🚀 **Run it.** Click **Start** and let the Actor collect your data.
5. 📥 **Download.** Grab your results in the **Dataset** tab as CSV, Excel, JSON, or XML.

> ⏱️ Total time from signup to downloaded dataset: **3-5 minutes.** No coding required.

***

### 💼 Business use cases

<table>
<tr>
<td width="50%" valign="top">

#### 🧑‍💼 Cross-Border Recruitment

- Talent sourcing across 32 EU/EEA countries
- ESCO-coded role mapping for ATS integrations
- Language-requirement filtering for relocation candidates
- Apprenticeship and internship pipelines

</td>
<td width="50%" valign="top">

#### 🌍 Relocation & Mobility Platforms

- Country-by-country opportunity dashboards
- Visa-eligibility prep with employer details
- Cost-of-living comparisons keyed to live salaries
- Family-friendly job filters by working time

</td>
</tr>
<tr>
<td width="50%" valign="top">

#### 📊 Labor-Market Analytics

- Cross-country demand benchmarking by occupation
- Salary-band tracking by sector and region
- ESCO occupation-code time-series modeling
- Skills-gap analysis with language and education filters

</td>
<td width="50%" valign="top">

#### 🏛️ Policy Research & Journalism

- EU mobility-policy impact studies
- Investigative reporting on cross-border labor flows
- Government dashboards for employment ministries
- Brexit-impact long-form research

</td>
</tr>
</table>

***

### 🔌 Automating EU EURES Jobs Scraper

Control the scraper programmatically for scheduled runs and pipeline integrations:

- 🟢 **Node.js.** Install the `apify-client` NPM package.
- 🐍 **Python.** Use the `apify-client` PyPI package.
- 📚 See the [Apify API documentation](https://docs.apify.com/api/v2) for full details.

The [Apify Schedules feature](https://docs.apify.com/platform/schedules) lets you trigger this Actor on any cron interval. Daily refreshes keep your recruitment pipeline or labor-market dashboard in sync with the live EURES catalog.

***

### 🌟 Beyond business use cases

EU labor data powers more than commercial workflows. The same structured records support research, education, civic projects, and personal initiatives.

<table>
<tr>
<td width="50%">

#### 🎓 Research and academia

- Labor-economics papers on EU mobility
- Cross-country wage research with cited references
- Coursework in European studies and economics
- Reproducible studies with versioned dataset pulls

</td>
<td width="50%">

#### 🎨 Personal and creative

- Personal job-hunting dashboards for EU candidates
- Indie career-portal prototypes
- Educational content for career coaches and creators
- Multilingual visualization side projects

</td>
</tr>
<tr>
<td width="50%">

#### 🤝 Non-profit and civic

- Refugee-employment-support organizations
- Cross-border worker advocacy
- Diaspora-community mobility services
- Public-sector labor-mobility briefings

</td>
<td width="50%">

#### 🧪 Experimentation

- Train role-classification models on ESCO codes
- Prototype agent pipelines that surface relocation matches
- Build dashboards tracking salary drift by country
- Validate skills-extraction NLP on job descriptions

</td>
</tr>
</table>

***

### 🤖 Ask an AI assistant about this scraper

Open a ready-to-send prompt about this ParseForge actor in the AI of your choice:

- 💬 [**ChatGPT**](https://chat.openai.com/?q=How%20do%20I%20use%20the%20EU%20EURES%20Jobs%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)
- 🧠 [**Claude**](https://claude.ai/new?q=How%20do%20I%20use%20the%20EU%20EURES%20Jobs%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)
- 🔍 [**Perplexity**](https://perplexity.ai/search?q=How%20do%20I%20use%20the%20EU%20EURES%20Jobs%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)
- 🅒 [**Copilot**](https://copilot.microsoft.com/?q=How%20do%20I%20use%20the%20EU%20EURES%20Jobs%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)

***

### ❓ Frequently Asked Questions

#### 🧩 How does it work?

Type a job keyword, optionally pick countries, contract type, working time, education level, or experience, and click Start. The Actor pulls matching vacancies from EURES and writes a clean per-job row to the dataset.

#### 📏 How fresh are the postings?

EURES aggregates vacancies daily from national public employment services and registered employer partners. Every run of this Actor pulls live data, so your dataset reflects the current EURES state at run time.

#### 🌐 Which countries are covered?

All 27 EU member states plus Iceland, Liechtenstein, Norway, and Switzerland (32 in total). UK postings are retained for historical reference.

#### 🎓 Why are some education or salary fields empty?

EURES aggregates from many national sources, and per-country field completeness varies. Salary, education level, and language requirements are populated whenever the source service supplies them. Title, employer, country, and apply URL are present on virtually every record.

#### 🏷️ What is ESCO?

ESCO is the European Skills, Competences, Qualifications and Occupations classification, a standardized taxonomy used across EURES. The `occupation` field returns the canonical ESCO identifier for each posting, which makes cross-country and cross-language joins straightforward.

#### ⏰ Can I schedule regular runs?

Yes. Use Apify Schedules to run this Actor on any cron interval. Daily refreshes keep your recruitment dashboard or talent pipeline aligned with live EURES vacancies.

#### ⚖️ Is this data legal to use?

EURES vacancies are published as public job postings by employers and partner services. Review the EURES terms for project-specific obligations and respect the privacy of any candidate-side personal data you collect downstream.

#### 💼 Can I use this data commercially?

Yes. Public job postings are commonly used in recruitment, mobility, and labor-market analytics products. You are responsible for complying with the EURES terms and any applicable GDPR obligations.

#### 💳 Do I need a paid Apify plan to use this Actor?

No. The free Apify plan is enough for testing and small runs (10 records per run). A paid plan lifts the limit and gives you access to scheduling, higher concurrency, and larger datasets.

#### 🔁 What happens if a run fails or gets interrupted?

Apify automatically retries transient errors. If a run still fails, you can inspect the log in the Runs tab, fix the input, and re-run. Partial datasets from interrupted runs are preserved so you never lose progress.

#### 🆘 What if I need help?

Our support team is here to help. Contact us through the Apify platform or use the Tally form linked below.

***

### 🔌 Integrate with any app

EU EURES Jobs Scraper connects to any cloud service via [Apify integrations](https://apify.com/integrations):

- [**Make**](https://docs.apify.com/platform/integrations/make) - Automate multi-step workflows
- [**Zapier**](https://docs.apify.com/platform/integrations/zapier) - Connect with 5,000+ apps
- [**Slack**](https://docs.apify.com/platform/integrations/slack) - Get run notifications in your channels
- [**Airbyte**](https://docs.apify.com/platform/integrations/airbyte) - Pipe job data into your warehouse
- [**GitHub**](https://docs.apify.com/platform/integrations/github) - Trigger runs from commits and releases
- [**Google Drive**](https://docs.apify.com/platform/integrations/drive) - Export datasets straight to Sheets

You can also use webhooks to trigger downstream actions when a run finishes. Push fresh EURES postings into your ATS, or alert your team in Slack.

***

### 🔗 Recommended Actors

- [**🌐 Glassdoor Jobs Scraper**](https://apify.com/parseforge/glassdoor-scraper) - Global employer reviews and job listings
- [**📊 Hugging Face Model Scraper**](https://apify.com/parseforge/hugging-face-model-scraper) - AI model catalog for talent and tooling research
- [**🏛️ FINRA BrokerCheck Scraper**](https://apify.com/parseforge/finra-brokercheck-scraper) - U.S. licensed-broker reference data
- [**🏗️ Hubspot Marketplace Scraper**](https://apify.com/parseforge/hubspot-marketplace-scraper) - Software-marketplace listings
- [**🗺️ Nominatim OSM Scraper**](https://apify.com/parseforge/nominatim-osm-scraper) - Geocode addresses via OpenStreetMap

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge) for more reference-data scrapers.

***

**🆘 Need Help?** [**Open our contact form**](https://tally.so/r/BzdKgA) to request a new scraper, propose a custom data project, or report an issue.

***

> **⚠️ Disclaimer:** this Actor is an independent tool and is not affiliated with, endorsed by, or sponsored by the European Commission, EURES, or any national public employment service. All trademarks mentioned are the property of their respective owners. Only publicly available European labor-mobility data is collected.

# Actor input Schema

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

Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000

## `keyword` (type: `string`):

Free-text job keyword. Example: 'software engineer', 'nurse', 'chef'.

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

Filter to specific EU/EEA countries. Leave empty for all.

## `contractType` (type: `array`):

Filter by contract type.

## `workingTime` (type: `array`):

Filter by working time arrangement.

## `educationLevel` (type: `array`):

Required education level(s).

## `experienceLevel` (type: `array`):

Required years of experience.

## Actor input object example

```json
{
  "maxItems": 10,
  "keyword": "software engineer"
}
```

# 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,
    "keyword": "software engineer"
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/eu-eures-jobs-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,
    "keyword": "software engineer",
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/eu-eures-jobs-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,
  "keyword": "software engineer"
}' |
apify call parseforge/eu-eures-jobs-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "EU EURES Jobs Scraper",
        "description": "Export European job vacancies from the EURES European Job Mobility Portal. Search by keyword, country, occupation, contract type, and education level across 30+ European countries. Pull title, employer, location, salary, requirements, and posting date.",
        "version": "1.0",
        "x-build-id": "dpVJaW9kKuTzSjtfA"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~eu-eures-jobs-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-eu-eures-jobs-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~eu-eures-jobs-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-eu-eures-jobs-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~eu-eures-jobs-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-eu-eures-jobs-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 items (preview). Paid users: Optional, max 1,000,000"
                    },
                    "keyword": {
                        "title": "Keyword",
                        "type": "string",
                        "description": "Free-text job keyword. Example: 'software engineer', 'nurse', 'chef'."
                    },
                    "countries": {
                        "title": "Countries",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Filter to specific EU/EEA countries. Leave empty for all.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "AT",
                                "BE",
                                "BG",
                                "HR",
                                "CY",
                                "CZ",
                                "DK",
                                "EE",
                                "FI",
                                "FR",
                                "DE",
                                "GR",
                                "HU",
                                "IS",
                                "IE",
                                "IT",
                                "LV",
                                "LI",
                                "LT",
                                "LU",
                                "MT",
                                "NL",
                                "NO",
                                "PL",
                                "PT",
                                "RO",
                                "SK",
                                "SI",
                                "ES",
                                "SE",
                                "CH",
                                "UK"
                            ]
                        }
                    },
                    "contractType": {
                        "title": "Contract Type",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Filter by contract type.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "permanent",
                                "temporary",
                                "apprenticeship",
                                "internship",
                                "seasonal",
                                "no-info"
                            ]
                        }
                    },
                    "workingTime": {
                        "title": "Working Time",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Filter by working time arrangement.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "full-time",
                                "part-time"
                            ]
                        }
                    },
                    "educationLevel": {
                        "title": "Education Level",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Required education level(s).",
                        "items": {
                            "type": "string",
                            "enum": [
                                "none",
                                "primary",
                                "lower-secondary",
                                "upper-secondary",
                                "post-secondary",
                                "short-cycle-tertiary",
                                "bachelor",
                                "master",
                                "doctorate"
                            ]
                        }
                    },
                    "experienceLevel": {
                        "title": "Experience Level",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Required years of experience.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "less-than-1-year",
                                "1-2-years",
                                "2-5-years",
                                "5+-years"
                            ]
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
