# EURES Jobs Scraper (`parsebird/eures-jobs-scraper`) Actor

Scrape job vacancies from EURES, the European Job Mobility Portal: titles, employers, countries, regions, ISCO codes, salaries, contacts, and full descriptions from any EURES search URL.

- **URL**: https://apify.com/parsebird/eures-jobs-scraper.md
- **Developed by:** [ParseBird](https://apify.com/parsebird) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.79 / 1,000 jobs

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

### EURES Jobs Scraper

**EURES Jobs Scraper** extracts job vacancies from [EURES](https://europa.eu/eures/portal/jv-se/search?lang=en), the European Job Mobility Portal. Give it any EURES search URL and get structured job data back: titles, employers, countries and regions, occupation codes, salaries, deadlines, how to apply, and full descriptions.

<table><tr>
<td style="border-left:4px solid #1C1917;padding:12px 16px;font-weight:600">
Paste any EURES search URL with its keyword, country, region, occupation, sector, contract, experience, education, and language filters, and get up to 10,000 vacancies per run from public employment services in 31 European countries, with salary, deadline, and application details for each one.
</td>
</tr></table>

##### Copy to your AI assistant

Copy this block into ChatGPT, Claude, Cursor, or any LLM to start using this actor.

```
Apify Actor: parsebird/eures-jobs-scraper. Scrapes job vacancies from EURES, the European Job Mobility Portal (europa.eu/eures), covering public employment services in EU/EEA countries and Switzerland. Call via ApifyClient: client.actor("parsebird/eures-jobs-scraper").call(run_input={"startUrl": "https://europa.eu/eures/portal/jv-se/search?keywordsEverywhere=nurse&locationCodes=de,at&orderBy=MOST_RECENT&lang=en", "results_wanted": 200, "max_pages": 10, "include_details": true}). Inputs: startUrl (string, a EURES search URL from https://europa.eu/eures/portal/jv-se/search with any filters, or a single jv-details vacancy URL; default is a sample "admin" search), results_wanted (integer 1-10000, default 20), max_pages (integer 1-200, default 10, up to 50 vacancies per page), include_details (boolean, default true, adds city, salary, deadline, application and contact data), proxyConfiguration (object, optional, not needed). Output fields per vacancy: identifier, title, url, company, publication_date, creation_date, last_modification_date, number_of_posts, location_country_codes, location_region_codes (NUTS), job_category_codes (ISCO), esco_occupation_uris, position_schedule_codes, position_offering_code, available_languages, translated_title, description_html, description_text, summary, eures_flag; with details: city, postal_code, application_deadline, salary_min, salary_max, salary_currency, salary_period, application_url, application_instructions_text, contact_emails, contact_phones, required_skills_esco_uris, required_languages, required_years_of_experience, employer_website, data_source. Pricing: pay per vacancy saved. Full API spec: https://apify.com/parsebird/eures-jobs-scraper/api. Get your token: https://console.apify.com/settings/integrations.
```

### What is EURES Jobs Scraper?

[EURES](https://europa.eu/eures/portal/jv-se/search?lang=en) (European Employment Services) is the European Commission's job mobility network. Its job search collects vacancies published by the **public employment services** of EU and EEA countries and Switzerland, like the Bundesagentur für Arbeit in Germany, Arbetsförmedlingen in Sweden, and Jobsplus in Malta. When we tested in October 2026, a blank EURES search returned about **2 million open vacancies**.

**EURES Jobs Scraper** turns any EURES search into a clean dataset. Build a search on the EURES portal, copy the URL, and paste it into the Actor. Every filter in that URL is applied. It's a simple **EURES API alternative**: you don't need to write any code, log in, or get an API key.

- 🔗 **Works from your EURES search URL.** Keywords, country and region, occupation (ESCO/ISCO), sector, working time, contract type, experience, education, required languages, EURES flag, and publication date are all supported.
- 📄 **Full vacancy details.** Optionally opens each vacancy to add city, postal code, salary range, application deadline, how to apply, contact person, required skills, languages, experience, and employer details.
- 🌍 **31 countries.** Covers every country that publishes to EURES, from Germany, France, and the Netherlands to Malta, Iceland, and Liechtenstein.
- 🗣️ **Language-aware.** The `lang` parameter in your URL picks the language version of each vacancy when the employer published one.
- 🎯 **Single vacancies too.** Paste one `jv-details` URL to get one vacancy with full details.
- ⚡ **Fast and lightweight.** It reads the same data the EURES website loads. There's no browser, so runs are quick and cheap.
- 📅 **Scheduling and monitoring.** Run the same search daily or weekly with [Apify Schedules](https://docs.apify.com/platform/schedules) to track new vacancies.
- 🔌 **API and integrations.** Use the results from the [Apify API](https://docs.apify.com/api/v2), or send them to Google Sheets, Zapier, Make, Slack, or webhooks via [Apify integrations](https://docs.apify.com/platform/integrations).

### What data can you extract from EURES?

| Field | Description |
|-------|-------------|
| `identifier` | EURES vacancy ID |
| `title` | Job title as published |
| `url` | Link to the vacancy page on EURES |
| `company` / `employer_name` | Hiring employer |
| `publication_date` | Publication date shown on EURES (last update, or creation date if never updated) |
| `creation_date` / `last_modification_date` | Source timestamps (ISO 8601, UTC) |
| `number_of_posts` | Number of open positions |
| `location_country_codes` / `location_region_codes` | Country codes and NUTS region codes |
| `job_category_codes` / `job_category_primary` | ISCO occupation codes |
| `esco_occupation_uris` | ESCO occupation URIs |
| `position_schedule_codes` / `position_offering_code` | Working time (full-time, part-time, flextime) and contract type (direct hire, temporary, contract, apprenticeship, and others) |
| `available_languages` / `translated_title` / `translated_description_text` | Language versions of the vacancy |
| `description_html` / `description_text` / `summary` | Full description as HTML and plain text, plus a short summary |
| `eures_flag` | Whether the employer flagged the vacancy as open to EURES (cross-border) applicants |
| `city` / `postal_code` / `street_address` | Workplace location *(details)* |
| `salary_min` / `salary_max` / `salary_currency` / `salary_period` | Salary range when published *(details)* |
| `application_deadline` / `application_url` / `application_instructions_text` | How and when to apply *(details)* |
| `contact_name` / `contact_emails` / `contact_phones` | Contact person, when published *(details)* |
| `required_skills_esco_uris` / `required_languages` / `required_years_of_experience` / `required_driving_licenses` | Requirements *(details)* |
| `employment_start_date` / `immediate_start` / `remote_work_allowed` | Start date and work arrangement *(details)* |
| `employer_website` / `employer_size` / `employer_sector_codes` | Employer profile *(details)* |
| `data_source` / `source_reference` | Employment service that published the vacancy and its own reference number *(details)* |

Fields marked *(details)* need **Include vacancy details** turned on (it's on by default). Countries and employers publish different amounts of information, so some fields are empty on some vacancies.

### How to scrape EURES job vacancies

1. Open the [EURES job search](https://europa.eu/eures/portal/jv-se/search?lang=en) and search with the keywords and filters you need (country, occupation, working time, publication date, and so on).
2. Copy the full URL from your browser's address bar.
3. Open [EURES Jobs Scraper](https://apify.com/parsebird/eures-jobs-scraper) on Apify and paste the URL into **EURES search URL**.
4. Set **Max vacancies** and **Max result pages** to control the size of the run.
5. Keep **Include vacancy details** on for salary, deadline, and contact data, or turn it off for a faster run with search-level fields only.
6. Click **Start** and watch vacancies appear in the dataset preview.
7. Download the results as **JSON, CSV, Excel, XML, or HTML**, or get them through the API.

### Input parameters

| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| `startUrl` | string | No | Sample "admin" search | A EURES search results URL (`https://europa.eu/eures/portal/jv-se/search?...`) or a single vacancy URL (`.../jv-details/...`) |
| `results_wanted` | integer | No | 20 | Maximum vacancies to save (1–10,000) |
| `max_pages` | integer | No | 10 | Maximum result pages to request (1–200). Each page holds up to 50 vacancies |
| `include_details` | boolean | No | `true` | Add city, salary, deadline, application, contact, requirement, and employer fields |
| `proxyConfiguration` | object | No | No proxy | Optional. EURES works without a proxy |

**Supported URL filters:** `keywordsEverywhere`, `keywordsTitle`, `keywordsDescription`, `keywordsEmployer`, `keywordsLegalID`, `keywordsJvId`, `locationCodes` (countries like `de` or regions like `fr1`), `escoOccupation`, `escoIsco`, `escoSkill`, `sector`, `positionScheduleCodes`, `positionOfferingCodes`, `experience`, `educationGroupCodes`, `educationAndQualificationLevel`, `requiredLanguages`, `euresFlagCodes`, `otherBenefitsCodes`, `minNumberPost`, `publicationPeriod` (`LAST_DAY`, `LAST_THREE_DAYS`, `LAST_WEEK`, `LAST_MONTH`), `orderBy` (`BEST_MATCH`, `MOST_RECENT`), and `lang`. The Actor always starts from the first result, whatever `page` and `resultsPerPage` say in the URL.

#### Example inputs

**Basic vacancy search**

```json
{
  "startUrl": "https://europa.eu/eures/portal/jv-se/search?page=1&resultsPerPage=10&orderBy=BEST_MATCH&keywordsEverywhere=admin&lang=en",
  "results_wanted": 20,
  "max_pages": 5
}
```

**Data analyst jobs in Germany and Austria, newest first**

```json
{
  "startUrl": "https://europa.eu/eures/portal/jv-se/search?keywordsTitle=data%20analyst&locationCodes=de,at&orderBy=MOST_RECENT&lang=en",
  "results_wanted": 100,
  "max_pages": 10
}
```

**Weekly monitoring of engineering jobs posted in the last 7 days**

```json
{
  "startUrl": "https://europa.eu/eures/portal/jv-se/search?keywordsEverywhere=engineer&publicationPeriod=LAST_WEEK&orderBy=MOST_RECENT&lang=en",
  "results_wanted": 500,
  "max_pages": 20,
  "include_details": false
}
```

### Output example

A real vacancy, shortened. Contact person fields are left out of this example.

```json
{
  "identifier": "NDU1MjMxIDEwMQ",
  "title": "NURSE",
  "url": "https://europa.eu/eures/portal/jv-se/jv-details/NDU1MjMxIDEwMQ?lang=en",
  "company": "ST. GEORGE'S CARE LTD",
  "employer_name": "ST. GEORGE'S CARE LTD",
  "publication_date": "2026-10-07",
  "creation_date": "2026-09-15T15:40:00.615Z",
  "last_modification_date": "2026-10-07T17:55:09.083Z",
  "number_of_posts": 3,
  "location_country_codes": "MT",
  "location_region_codes": "MT001",
  "job_category_codes": "2221",
  "job_category_primary": "2221",
  "position_schedule_codes": "fulltime",
  "position_offering_code": "contract",
  "available_languages": "en",
  "translation_type": "REQUESTED",
  "translation_language": "en",
  "translated_title": "NURSE",
  "description_text": "Assess patient health and wellbeing, deliver person-centred care, communicate sensitively, support colleagues’ development, and promote best practices in health, safety, security, and clinical care.",
  "summary": "Assess patient health and wellbeing, deliver person-centred care, communicate sensitively, support colleagues’ development, and promote best practices in health, safety, security, and clinical care.",
  "eures_flag": true,
  "source": "EURES",
  "source_url": "https://europa.eu/eures/api/jv-searchengine/public/jv-search/search",
  "city": "HAL BALZAN",
  "application_deadline": "2026-10-13",
  "salary_min": 8.98,
  "salary_max": 12.66,
  "salary_currency": "EUR",
  "salary_period": "hour",
  "salary_type": "basepay",
  "application_instructions_text": "Submit an APPLICATION LETTER and CV by EMAIL OR apply through the Jobsplus website via the URL: https://jobsplus.gov.mt/vacancy/vacancy-details?id=455231",
  "application_url": "https://jobsplus.gov.mt/vacancy/vacancy-details?id=455231",
  "required_languages": "en (B1)",
  "required_education_level_code": "6",
  "employer_legal_id": "1",
  "data_source": "Jobsplus, Public Employment Service, Malta",
  "source_reference": "455231"
}
```

### Use cases

- **Recruitment and sourcing.** Find employers hiring for a role across Europe and reach out with the published contact and application details.
- **Labour market research.** Measure demand by country, NUTS region, ISCO occupation, or sector, and follow how it changes over time.
- **Cross-border mobility.** Collect vacancies flagged for EURES applicants (`euresFlagCodes=WITH`) for relocation services, job boards, and career advisors.
- **Salary benchmarking.** Compare published salary ranges by occupation and country.
- **Job board aggregation.** Feed fresh European public-sector job data into your own job board or newsletter.
- **Skills analysis.** Use the ESCO skill and occupation URIs to map required skills to occupations.

### How it works

1. The Actor reads the filters from your EURES search URL. It uses the same rules the EURES portal uses, so you get the same results you see in your browser.
2. It requests result pages of up to 50 vacancies from the EURES job search. While one page is processed, the next few load.
3. If **Include vacancy details** is on, it opens each vacancy to add location, salary, application, contact, requirement, and employer fields.
4. It cleans and flattens each vacancy into one row: dates become ISO format, HTML descriptions also come as plain text, and multi-value fields become comma-separated strings that work in CSV and Excel.
5. It skips duplicate vacancies and stops when it reaches your vacancy limit or page limit, or runs out of results. EURES returns at most 10,000 results per search. When duplicates leave the run short of your target, it makes a second pass in the opposite sort order to find the missing vacancies.

### How much does it cost to scrape EURES?

EURES Jobs Scraper charges per vacancy saved to the dataset. The price is lower on higher Apify plans:

| Event | Plan | Price per vacancy | Price per 1,000 vacancies |
|-------|------|-------------------|---------------------------|
| `job-scraped` | Free | $0.00099 | **$0.99** |
| `job-scraped` | Bronze | $0.00089 | **$0.89** |
| `job-scraped` | Silver / Gold | $0.00079 | **$0.79** |

The price is the same whether vacancy details are on or off, and platform usage (compute and proxy) is included, so you pay only for the vacancies you get. For example, 5,000 vacancies cost $4.95 on the Free plan or $3.95 on Silver. Apify's Free plan comes with monthly platform credits that cover your first runs. Set a spending limit on any run and the Actor stops as soon as it's reached.

### Use the EURES scraper via API

**Python**

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")

run = client.actor("parsebird/eures-jobs-scraper").call(run_input={
    "startUrl": "https://europa.eu/eures/portal/jv-se/search?keywordsEverywhere=nurse&locationCodes=de,at&orderBy=MOST_RECENT&lang=en",
    "results_wanted": 200,
    "include_details": True,
})

for job in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(job["title"], "|", job["company"], "|", job["location_country_codes"], "|", job.get("city"))
```

**JavaScript**

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

const client = new ApifyClient({ token: '<YOUR_APIFY_TOKEN>' });

const run = await client.actor('parsebird/eures-jobs-scraper').call({
    startUrl: 'https://europa.eu/eures/portal/jv-se/search?keywordsTitle=software%20developer&locationCodes=nl&lang=en',
    results_wanted: 100,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((job) => console.log(job.title, job.company, job.salary_min, job.salary_currency));
```

Get your API token in [Apify Console → Settings → Integrations](https://console.apify.com/settings/integrations). See the [API tab](https://apify.com/parsebird/eures-jobs-scraper/api) for every endpoint, including running the Actor synchronously and getting results in one call.

### Export formats and integrations

Download EURES job data as **JSON, CSV, Excel, XML, HTML, or RSS** from the Storage tab or the [dataset API](https://docs.apify.com/api/v2#/reference/datasets). Connect runs to [Google Sheets, Slack, Zapier, Make, Airbyte, or webhooks](https://docs.apify.com/platform/integrations), or use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp) to let AI agents call the Actor directly.

### FAQ

**Do I need an EURES account or API key?**
No. The Actor only reads public vacancy data that anyone can see on the EURES portal without logging in.

**Which countries does EURES cover?**
EU member states, Iceland, Liechtenstein, Norway, and Switzerland. Use `locationCodes` in your URL (for example `locationCodes=fr,be`) to pick countries, or NUTS region codes such as `fr1` for regions.

**How many vacancies can I get per run?**
Up to 10,000, which is the most EURES returns for one search. For bigger exports, split your search into several runs, for example one per country or occupation.

**Why are salary, city, or contact fields empty on some vacancies?**
Each national employment service publishes different information, and many employers leave out salary or contact details. The Actor returns everything EURES publishes and leaves the rest empty. It never guesses.

**What do `job_category_codes` and `esco_occupation_uris` contain?**
`job_category_codes` are 4-digit [ISCO-08](https://www.ilo.org/public/english/bureau/stat/isco/isco08/) occupation codes, and `esco_occupation_uris` link to the [ESCO](https://esco.ec.europa.eu/) occupation classification. Many vacancies have only one of the two.

**Can I get vacancies in English?**
Add `lang=en` (or another language code) to your URL. When the employer published a vacancy in that language, `translated_title` and `translated_description_text` contain that version. Otherwise they contain the original language. The Actor doesn't machine-translate.

**My URL uses `orderBy=PUBLICATION_DATE` or `publicationPeriod=LAST_7_DAYS`. Does it work?**
Yes. EURES itself only accepts `MOST_RECENT` and `LAST_WEEK`, so the Actor switches to those values and notes the change in the log.

**Is a proxy needed?**
No. EURES is a public EU service, and the Actor runs without a proxy by default. The proxy setting is there only if you need requests to come from a specific network.

**Can I schedule the scraper to monitor new jobs?**
Yes. Use `orderBy=MOST_RECENT` with `publicationPeriod=LAST_DAY` or `LAST_WEEK` in your URL, and create an [Apify Schedule](https://docs.apify.com/platform/schedules) to run it daily or weekly.

**Something isn't working. Where do I report it?**
Open an issue on the [Issues tab](https://apify.com/parsebird/eures-jobs-scraper/issues). We read every report.

### Is it legal to scrape EURES?

EURES Jobs Scraper only collects public job vacancy data that EURES publishes for anyone to see without logging in. It doesn't access private accounts, CVs, or anything behind a login. Some vacancies include a contact person's name, email, or phone number, which is personal data under the GDPR. Process it only if you have a legitimate reason and follow data protection rules. Please also respect the [EURES legal notice](https://europa.eu/eures/portal/legal-notice). For more background, read Apify's guide [Is web scraping legal?](https://blog.apify.com/is-web-scraping-legal/)

### Other job scrapers by ParseBird

| Actor | What it does |
|-------|--------------|
| [Platsbanken Jobs Scraper](https://apify.com/parsebird/platsbanken-jobs-scraper) | Swedish job ads from Arbetsförmedlingen's Platsbanken |
| [Xing Jobs Scraper](https://apify.com/parsebird/xing-jobs-scraper) | Job listings from XING across Germany, Austria, and Switzerland |
| [Karriere.at Austrian Jobs Scraper](https://apify.com/parsebird/karriere-at-jobs-scraper) | Austrian job listings from karriere.at |
| [Jobs.ch Scraper](https://apify.com/parsebird/jobs-ch-scraper) | Swiss job listings from jobs.ch |
| [Arbeitnow Jobs Scraper](https://apify.com/parsebird/arbeitnow-jobs-scraper) | Job listings from Arbeitnow, with remote filter |
| [HelloWork Jobs Scraper](https://apify.com/parsebird/hellowork-jobs-scraper) | French job listings from HelloWork |
| [InfoJobs Jobs Scraper](https://apify.com/parsebird/infojobs-jobs-scraper) | Spanish job listings from InfoJobs |
| [Totaljobs Scraper](https://apify.com/parsebird/totaljobs-scraper) | UK job listings from Totaljobs |
| [LinkedIn Jobs Scraper](https://apify.com/parsebird/linkedin-jobs-scraper) | Public job postings from LinkedIn |
| [Indeed Jobs Scraper](https://apify.com/parsebird/indeed-jobs-scraper) | Job listings from Indeed |

# Changelog

This Actor's version history is a separate document: https://apify.com/parsebird/eures-jobs-scraper/changelog.md

# Actor input Schema

## `startUrl` (type: `string`):

Paste a EURES search results URL (https://europa.eu/eures/portal/jv-se/search?...). All filters in the URL are applied: keywords, country and region, occupation, sector, schedule, contract type, experience, education, languages, and publication date. A single vacancy URL (.../jv-details/...) also works. If empty, a sample search for "admin" is used.

## `results_wanted` (type: `integer`):

Stop after saving this many job vacancies. EURES returns at most 10,000 vacancies per search, so split very broad searches by country.

## `max_pages` (type: `integer`):

Stop after this many result pages. Each page holds up to 50 vacancies, so 200 pages covers the 10,000-vacancy maximum.

## `include_details` (type: `boolean`):

Open each vacancy to add city, postal code, salary, application deadline, how to apply, contact person, required skills, languages, experience, and employer details. Turn off for faster runs with search-level fields only. Price is the same either way.

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

EURES works without a proxy. Add one only if you need requests to come from a specific network.

## Actor input object example

```json
{
  "startUrl": "https://europa.eu/eures/portal/jv-se/search?page=1&resultsPerPage=10&orderBy=BEST_MATCH&keywordsEverywhere=admin&lang=en",
  "results_wanted": 20,
  "max_pages": 10,
  "include_details": true,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `dataset` (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 = {
    "startUrl": "https://europa.eu/eures/portal/jv-se/search?page=1&resultsPerPage=10&orderBy=BEST_MATCH&keywordsEverywhere=admin&lang=en",
    "results_wanted": 20,
    "max_pages": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("parsebird/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 = {
    "startUrl": "https://europa.eu/eures/portal/jv-se/search?page=1&resultsPerPage=10&orderBy=BEST_MATCH&keywordsEverywhere=admin&lang=en",
    "results_wanted": 20,
    "max_pages": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("parsebird/eures-jobs-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "startUrl": "https://europa.eu/eures/portal/jv-se/search?page=1&resultsPerPage=10&orderBy=BEST_MATCH&keywordsEverywhere=admin&lang=en",
  "results_wanted": 20,
  "max_pages": 10
}' |
apify call parsebird/eures-jobs-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,parsebird/eures-jobs-scraper"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/jA0I7XWKoVfNAO43m/builds/7Hw0RC7LXx72sewcf/openapi.json