# EURES Jobs Scraper \[$0.60/1k] - EU Job Vacancies, 31 Countries (`kadi_bence/eures-jobs-scraper`) Actor

$0.60 per 1,000 jobs. Search EU job vacancies on the official EURES portal (1.9M+ jobs, 31 countries). Input: keywords, countries, NUTS regions, ESCO occupations, contract type, working time, posted-within days. Returns per job: title, employer, country, city, occupation, salary, posted date, URL.

- **URL**: https://apify.com/kadi_bence/eures-jobs-scraper.md
- **Developed by:** [Bence Kadi](https://apify.com/kadi_bence) (community)
- **Categories:** Jobs, Lead generation, Automation
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.48 / 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: export EU job vacancies from 31 European countries

### What is EURES Jobs Scraper?

EURES Jobs Scraper exports job vacancies from **EURES, the European Job Mobility Portal** of the European Commission, through the portal's own open API (no login, no key, no browser). That is **1.9 million+ live vacancies** from the public employment services of the 27 EU countries plus Iceland, Liechtenstein, Norway and Switzerland.

**Sample output** (real rows from a test run, shortened)

| Title | Employer | Country | Region | Occupation |
|---|---|---|---|---|
| Software Developer Autopilot (m/w... | Rheinmetall AG | DE | Weilheim-Schongau | software architect |
| Software Developer Autopilot (m/w... | Rheinmetall AG | DE | Weilheim-Schongau | software architect |
| Software Developer\* Cloud-Technol... | inovex GmbH | DE | Nordrhein-Westfalen | software developer |
| Senior Software Developer (gn) (S... | Getriebebau Nord GmbH & Co. KG | DE | Stormarn | software developer |

France Travail (ex Pôle emploi), the Bundesagentur für Arbeit, VDAB/Forem/Actiris, UWV, Arbetsförmedlingen, NAV and other national boards feed into EURES. You get all of them in one de-duplicated schema, as JSON, CSV or Excel.

**What makes it different**

- **Readable codes.** ESCO occupation label, ISCO-08 code and group, NUTS region name, contract type and working time in plain English.
- **Relevant results first.** EURES matches keyword words loosely, so with keywords the Actor sorts by best match.
- **No 10,000 cap.** Bigger searches are split by country and then by NUTS 2 region automatically.
- **Fair spread across countries.** Max results 1,000 with 5 countries gives about 200 per country.
- **Optional full details:** city, structured salary, deadline, start date, education, experience, language levels and apply link.
- **Only new jobs.** Monitoring mode outputs, and charges for, only jobs you haven't seen before.
- **Licensed and private.** Open data under CC BY 4.0 with attribution on every row; contact persons, e-mails and phone numbers are always removed.

**Use cases:** Generate leads (build B2B prospect lists, lead enrichment & validation) · Research markets & competitors (track competitors, build market datasets, track trends, profile companies & due diligence) · Developer tools (monitor & alert on website changes).

#### Use cases

- **Recruiters and staffing agencies:** source vacancies by occupation and region, e.g. nurses in Ireland or truck drivers in Poland.
- **Job boards and aggregators:** a licensed feed of EU public-employment-service jobs, including France Travail jobs.
- **Labour-market research:** compare demand by ESCO occupation, country or NUTS region over time.
- **Relocation and mobility services:** employers that recruit from other EU countries, English-language ads, or a given language level.
- **AI agents and RAG apps:** fresh, structured EU job data through the API or the Apify MCP server.

#### Data fields you get

Fields marked *(details)* are filled only with **Fetch full details** on, and only when the national feed sends them.

| Field | Description | Example |
|---|---|---|
| `title` | Job title | `Data Engineer* / Machine Learning Engineer*…` |
| `jobId` / `url` | EURES vacancy ID and portal link | `MTY3NTItcjU0NDYtUyAx` |
| `applyUrl` | Employer's apply link *(details)* | `https://www.arbeitsagentur.de/jobsuche/…` |
| `employer` / `employerWebsite` | Employer name and website | `inovex GmbH` |
| `employerSize` | Size code from EURES | `medium-sizedenterprise` |
| `country` / `countryName` | ISO code (`GR` for Greece) and name | `DE` / `Germany` |
| `region` / `regionCode` | NUTS region name and code | `Nordrhein-Westfalen` / `DEA` |
| `city` / `postalCode` | City and postal code *(details)* | `Köln` |
| `locations` | All locations of the job | `[{"country": "DE", "region": "Bayern", …}]` |
| `occupation` | First ESCO occupation label | `data analyst` |
| `iscoCode` / `iscoGroup` | ISCO-08 unit group code and name | `2511` / `Systems analysts` |
| `occupations` | All occupations with URI, ESCO and ISCO codes | `[{"label": "data analyst", …}]` |
| `employmentType` / `employmentTypeCode` | Contract type label and code | `Temporary` / `temporary` |
| `workingTime` / `workingTimeCodes` | Working time label and codes | `full-time` / `["fulltime"]` |
| `openPositions` | Number of open positions | `1` |
| `salaryMin` / `salaryMax` | Salary range (numbers) | `65000` / `75000` |
| `salaryCurrency` / `salaryPeriod` | Currency and `HOUR`, `DAY`, `WEEK`, `MONTH` or `YEAR` | `EUR` / `YEAR` |
| `salaryText` | Salary text found in the description | `€ 60.000 - € 80.000` |
| `salaryType` / `salarySource` | Pay type *(details)*; `structured` or `description` | `basepay` / `structured` |
| `postedDate` / `publishedAt` | Creation date and time (UTC) | `2026-01-16` |
| `updatedAt` | Last update (UTC) | `2026-08-10T20:19:18Z` |
| `deadline` | Application deadline *(details)* | `null` |
| `startDate` / `endDate` / `immediateStart` | Employment period *(details)* | `2026-08-10` / `null` / `true` |
| `educationLevel` / `experienceYears` | Required education (ISCED label) and years *(details)* | `null` |
| `languages` | Languages asked for, CEFR level, required *(details)* | `[{"language": "de", "level": "C1", …}]` |
| `workingLanguages` / `drivingLicenses` | Working languages, driving licences *(details)* | `[]` |
| `remoteAllowed` | Remote work value from EURES *(details)* | `null` |
| `euresFlag` | Employer recruits from other EU countries | `false` |
| `adLanguages` / `language` | Ad's languages and the language you get | `["de"]` / `de` |
| `description` / `descriptionHtml` | Description as text and/or HTML, contact data removed | `Was du bei uns bewegen kannst…` |
| `detailsFetched` / `originalSource` | Details loaded; national feed code *(details)* | `true` / `DE001` |
| `source` / `attribution` | Data source and licence credit | `EURES (European Commission)` |
| `isNew` | Set in monitoring mode | `true` |
| `scrapedAt` | Scrape time (UTC) | `2026-10-05T10:41:12Z` |

### How to use EURES Jobs Scraper

1. Enter **keywords** (or none for all jobs) and pick **countries**. The prefill ("software developer", Germany and Netherlands, 30 jobs) took 16 seconds in our test and costs about $0.02.
2. Optional: narrow by region, occupation, contract type, working time, education, experience, sector, languages or **Published within (days)**.
3. Set **Max results** and click **Start**.
4. Download the data from the **Output** tab as JSON, CSV, Excel or HTML, or connect it to Google Sheets, Zapier, Make or n8n.
5. For daily new jobs, turn on **Only new jobs** and create a **Schedule** (see [Integrations and scheduling](#integrations-and-scheduling)).

**Speed.** europa.eu asks bots to wait 10 seconds between requests (`Crawl-delay: 10` in robots.txt), and this Actor respects that:

| Mode | Speed | 1,000 jobs take |
|---|---|---|
| Search results (default) | about 250-300 jobs/min (50 jobs per request) | about 4 minutes |
| Full details | about 6 jobs/min (one request per job) | about 3 hours |

#### Input guide

**Keywords (`keywords`) and Match keywords in (`searchIn`)**

Job titles or skills. Each keyword is a separate search; results are merged and de-duplicated. Leave empty for all jobs. `searchIn` is `everywhere` (default) or `title`.

- Good: `software developer`, `nurse`, `Python`
- Bad: `nurse Ireland` (pick Ireland in **Countries**)
- Tip: EURES matches each word loosely, in every language version of an ad. Use `title` or an **occupation** for tighter results.

**Sort by (`sortBy`)**: `relevance` (default with keywords) or `newest`. Without keywords the order is always newest first.

**Countries (`countries`)**: ISO codes; Greece is `EL` (`GR` and English names also work via the API). Empty means all 31 countries. UK jobs are not in EURES.

**Regions (`regions`)**

NUTS codes or names, e.g. `FR10`, `Île-de-France`, `Bayern`. EURES filters by NUTS 2: a NUTS 1 area (like `Bayern`) is expanded to its NUTS 2 regions, a NUTS 3 code is widened to NUTS 2. A region narrows its own country only: countries `IE` + `DE` with region `Bayern` gives all of Ireland and only Bayern in Germany.

**Occupations (`occupations`)**

ESCO occupation URIs, ISCO-08 codes or English names.

- Good: `2512` (software developers), `5120` (cooks), `2221` (nursing professionals), `chef`, `truck driver`
- Tip: a name that is not an exact ESCO label matches up to 25 close occupations; the log lists them.

**Published within (days) (`publishedWithinDays`)**

Jobs **published or updated** in the last N days (the EURES "published" filter), e.g. `1` for daily alerts. `0` means any date. Feeds often refresh old ads, so `postedDate` can be older than N days.

**Other filters**

- `contractTypes` (e.g. `directhire`, `temporary`, `apprenticeship`, `internship`, `seasonal`), `workingTime` (`fulltime`, `parttime`, `flextime`), `educationLevels` (`basic` to `doctoral`), `experience` (`none_required` to `more_than_5_years`), `sectors` (NACE sections `a` to `u`).
- `languages`: two-letter codes with your optional CEFR level, e.g. `en`, `de:B2`. EURES returns jobs that need the language at that level or lower.
- `adLanguages`: only ads written in these languages, e.g. `en`. It runs after the search, so a narrow choice can scan many pages.
- `euresFlagOnly`: only employers that explicitly recruit from other EU countries.

Jobs removed by the date or ad-language filter are not saved and **not charged**. The other filters run on the EURES server.

**Max results (`maxResults`)**: stop after N jobs; `0` = no limit. The Console prefill and the default via API, MCP or an AI agent are both 20. The limit is shared fairly across keywords and countries or regions.

**Output options**

- `includeDetails` (default off): adds city, salary, deadline, start date, education, experience, languages and apply link. Slow; use it for a few hundred jobs or daily alerts.
- `preferredLanguage`: which language version to output for multilingual ads (e.g. Belgium).
- `descriptionFormat`: `text` (default), `html`, `both` or `none`.

**Monitoring and proxy:** for `onlyNewJobs` and `monitorName` see [Monitoring mode](#monitoring-mode-only-new-jobs). `proxyConfiguration` is off by default and not needed.

Example input:

```json
{
  "countries": ["IE", "DE"],
  "regions": ["Bayern"],
  "occupations": ["2221"],
  "contractTypes": ["directhire"],
  "adLanguages": ["en"],
  "publishedWithinDays": 7,
  "maxResults": 500,
  "onlyNewJobs": true
}
```

### Output

Each job is one item in the run's dataset. Here is one real item from a test run with **Fetch full details** on (2026-10-05). It is shortened: `locations` had 7 entries and `occupations` 2, and the description and attribution are cut.

```json
{
  "title": "Data Engineer* / Machine Learning Engineer* (Data Engineer)",
  "jobId": "MTY3NTItcjU0NDYtUyAx",
  "url": "https://europa.eu/eures/portal/jv-se/jv-details/MTY3NTItcjU0NDYtUyAx?lang=de",
  "applyUrl": "https://www.arbeitsagentur.de/jobsuche/jobdetail/16752-r5446-S",
  "employer": "inovex GmbH",
  "employerWebsite": "http://www.inovex.de",
  "employerSize": "medium-sizedenterprise",
  "country": "DE",
  "countryName": "Germany",
  "region": "Nordrhein-Westfalen",
  "regionCode": "DEA",
  "city": "Köln",
  "postalCode": null,
  "locations": [
    { "country": "DE", "regionCode": "DEA", "region": "Nordrhein-Westfalen", "city": "Köln", "postalCode": null },
    { "country": "DE", "regionCode": "DE2", "region": "Bayern", "city": "Erlangen", "postalCode": null }
  ],
  "occupation": "data analyst",
  "iscoCode": "2511",
  "iscoGroup": "Systems analysts",
  "occupations": [
    {
      "uri": "http://data.europa.eu/esco/occupation/d3edb8f8-3a06-47a0-8fb9-9b212c006aa2",
      "label": "data analyst",
      "escoCode": "2511.2",
      "iscoCode": "2511",
      "iscoGroup": "Systems analysts"
    }
  ],
  "employmentType": null,
  "employmentTypeCode": null,
  "workingTime": "full-time",
  "workingTimeCodes": ["fulltime"],
  "openPositions": 1,
  "salaryMin": 65000,
  "salaryMax": 75000,
  "salaryCurrency": "EUR",
  "salaryPeriod": "YEAR",
  "salaryText": null,
  "salaryType": "basepay",
  "salarySource": "structured",
  "postedDate": "2026-01-16",
  "publishedAt": "2026-01-16T22:29:24Z",
  "updatedAt": "2026-08-10T20:19:18Z",
  "deadline": null,
  "startDate": "2026-08-10",
  "endDate": null,
  "immediateStart": true,
  "educationLevel": null,
  "experienceYears": null,
  "languages": [
    { "language": "de", "level": "C1", "required": true },
    { "language": "en", "level": "C1", "required": true }
  ],
  "workingLanguages": [],
  "drivingLicenses": [],
  "remoteAllowed": null,
  "euresFlag": false,
  "adLanguages": ["de"],
  "language": "de",
  "description": "Was du bei uns bewegen kannst\nGemeinsam mit deinem agilen, cross-funktionalen Projektteam hilfst du unseren Kunden aus unterschiedlichen Branchen, ihre Daten nu…",
  "descriptionHtml": null,
  "detailsFetched": true,
  "originalSource": "DE001",
  "source": "EURES (European Commission)",
  "attribution": "Source: EURES - The European Job Mobility Portal (https://eures.europa.eu), (c) European Union, reused under CC BY 4.0 …",
  "scrapedAt": "2026-10-05T10:41:12Z"
}
```

Notes:

- In search mode (no details) `city`, `postalCode`, `deadline`, `startDate`, `languages`, `applyUrl` and the structured salary are empty.
- Without a structured salary, the Actor parses one from the description if it states a currency (`salarySource: "description"`).
- `postedDate` is the creation date; `updatedAt` is the last change. They can differ by months.
- Empty values are `null` (or `[]`), so every item has the same columns in CSV and Excel.

Fill rates in our tests (2026-10-05): **1,000 jobs in search mode, 6 countries:** title, country, posted date and description 100%, occupation 99.5%, contract type 99%, region 97%, employer 67% (some feeds, e.g. Spain, send none), working time 51%. **30 jobs with full details:** apply link and start date 83%, city 60%, salary 33%, deadline 33%, required languages 10%.

#### Dataset views

| View | What it shows |
|---|---|
| **Jobs** | Compact table: title, employer, country, region, city, occupation, published date, contract, working time, salary range and link. |
| **Full details** | Adds ISCO code and group, postal code, open positions, salary period, deadline, start date, education, experience, languages, EURES flag, apply link and description. |

Every export contains all fields, whichever view you look at. The run also writes a `RUN_SUMMARY` record to the key-value store: matches and listed jobs per keyword and country or region, splits past the 10,000 cap, jobs saved, run time, and jobs skipped as older, already seen or in another ad language.

#### How to export the data

- **Console:** Output tab > **Export** > JSON, CSV, Excel, HTML, XML or RSS.
- **Google Sheets:** the Google Sheets integration, or `=IMPORTDATA("https://api.apify.com/v2/datasets/<DATASET_ID>/items?format=csv&token=<TOKEN>")`.
- **API:** `https://api.apify.com/v2/datasets/<DATASET_ID>/items?format=json` (or `csv`, `xlsx`); add `&view=overview` for the compact table.

### Pricing

**Pay per event: $0.60 per 1,000 jobs** ($0.0006 per job saved), plus Apify's standard Actor start fee of **$0.00005 per run**. Platform compute is included. **Fetch full details** costs the same per job; it is only slower.

| Example run | Jobs saved | Cost |
|---|---|---|
| Prefill test ("software developer", DE + NL) | 30 | about $0.02 |
| One export | 1,000 | about $0.60 |
| Large export | 10,000 | about $6.00 |
| Daily alert, ~50 new jobs per day for 30 days | 1,500 | about $0.90 per month |

Free: jobs removed by the date or ad-language filter, jobs already seen in monitoring mode, and the `RUN_SUMMARY` record. If full details fail for a job, it is still saved with the search data and charged as a normal job.

To cap spending, set **Max results** or **Max charge per run**; the Actor stops cleanly and keeps what it saved. Apify's free plan includes monthly platform credit you can use here.

### Use it via API

Get your API token in the Apify Console under **Settings > API & Integrations**. The examples below run the Actor, wait for it to finish and read the jobs.

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

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: 'YOUR_APIFY_TOKEN' });

const run = await client.actor('kadi_bence/eures-jobs-scraper').call({
    keywords: ['software developer'],
    countries: ['DE', 'NL'],
    publishedWithinDays: 7,
    maxResults: 200,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(`${items.length} jobs`, items[0]);
```

**Python** (`pip install apify-client`)

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")

run = client.actor("kadi_bence/eures-jobs-scraper").call(run_input={
    "occupations": ["2221"],
    "countries": ["IE", "NL"],
    "adLanguages": ["en"],
    "maxResults": 200,
})

for job in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(job["title"], job["countryName"], job["occupation"], job["url"])
```

**cURL** (runs the Actor and returns the jobs in one request; best for runs under 5 minutes)

```bash
curl -X POST "https://api.apify.com/v2/acts/kadi_bence~eures-jobs-scraper/run-sync-get-dataset-items?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"keywords": ["software developer"], "countries": ["DE", "NL"], "maxResults": 30}'
```

**Apify CLI**

```bash
apify call kadi_bence/eures-jobs-scraper --input '{"keywords": ["software developer"], "countries": ["DE", "NL"], "maxResults": 30}' --output-dataset
```

**MCP server for AI agents** (Claude, Cursor, VS Code and other MCP clients)

Add the Apify MCP server with this Actor as a tool. Your client will ask you to sign in to Apify (OAuth), or you can send your token as an `Authorization: Bearer YOUR_APIFY_TOKEN` header.

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com/?actors=kadi_bence/eures-jobs-scraper"
    }
  }
}
```

Then ask your agent, for example: "Find nursing jobs in Ireland and the Netherlands published in the last 7 days, with English-language ads, and group them by region."

### Integrations and scheduling

- **Schedules:** **Schedules > Create new**, pick this Actor (or a saved task) and a time, e.g. daily at 07:00. Each run gets its own dataset.
- **Webhooks:** on the **Integrations** tab, add a "Run succeeded" webhook to send the run and dataset ID to your server.
- **Zapier, Make and n8n:** trigger "Actor run finished", then "Get dataset items", then send jobs to Slack, e-mail, a CRM or Airtable.
- **Google Sheets, Slack and e-mail:** built-in integrations append each run's jobs to a sheet or notify you when a run finishes.

#### Monitoring mode (only new jobs)

Turn on **Only new jobs** (`onlyNewJobs: true`), set **Published within (days)** to `1` or `3`, and schedule the Actor daily:

1. The first run outputs all matching jobs (up to Max results) and saves their IDs.
2. Every later run outputs only jobs that weren't returned before.
3. You pay only for those new jobs. In monitoring mode every output item has `isNew: true`.

The "already seen" list is stored in a named key-value store (`eures-jobs-monitor`) in your own Apify account, one list per search: keywords, countries, regions, filters, text language and **Monitor name**. Changing Max results, Fetch full details or Description format keeps the list; changing anything else starts a new one. If a run stops early (Max results or Max charge), only delivered jobs are remembered, so the rest stay new. Use different **Monitor names** for two schedules with the same search, or a new name to start over.

### Other job scrapers by the same developer

All of them use the same output fields where possible, so you can merge datasets.

- [Workday Jobs Scraper](https://apify.com/kadi_bence/workday-jobs-scraper): every job from company career sites on Workday (myworkdayjobs.com), by company name, with no 2,000-job cap.
- [Greenhouse, Lever & Ashby Jobs Scraper](https://apify.com/kadi_bence/ats-jobs-scraper): jobs from Greenhouse, Lever, Ashby, Workable, Recruitee and Personio boards, by company name.
- [Oracle, Taleo, BambooHR & Rippling Jobs Scraper](https://apify.com/kadi_bence/ats-plus-jobs-scraper): nine more applicant tracking systems, including Oracle Recruiting Cloud, Taleo, Teamtailor and Jobvite.
- [Germany Jobs Scraper - Arbeitsagentur](https://apify.com/kadi_bence/arbeitsagentur-jobs-scraper): 1M+ German job offers from the federal employment agency's Jobbörse.
- [Sweden Jobs Scraper - Platsbanken](https://apify.com/kadi_bence/sweden-jobs-scraper): all Swedish job ads from Arbetsförmedlingen, with an archive since 2016.
- [Remote Jobs Scraper](https://apify.com/kadi_bence/remote-jobs-scraper): remote jobs from RemoteOK, Himalayas, Jobicy and Arbeitnow in one de-duplicated feed.

Related company data for B2B leads: [SEC Form D Scraper](https://apify.com/kadi_bence/sec-form-d-funding) (startup funding rounds), [New Business Filings USA](https://apify.com/kadi_bence/us-new-business-filings) (newly registered companies), [Website Tech Stack Detector](https://apify.com/kadi_bence/tech-stack-detector) (technologies a company uses) and [EU Public Tenders Scraper (TED)](https://apify.com/kadi_bence/ted-tenders-scraper).

### FAQ

**How does EURES Jobs Scraper work?**
It sends your search to the open JSON API the EURES portal itself uses, 50 jobs per request, and with full details on opens each vacancy. It adds occupation and region labels, removes personal data and saves the jobs.

**Is there an official EURES API?**
The portal's job-search API is open and needs no key. This Actor uses it and adds splitting past the 10,000 cap, fair limits, readable labels, monitoring and exports.

**Which countries are covered?**
The 27 EU countries plus Iceland, Liechtenstein, Norway and Switzerland. Germany, France, the Netherlands and Belgium have the most jobs.

**Does it include France Travail (Pôle emploi) jobs?**
Yes, about 440,000 French jobs on 2026-10-05. France Travail's own website forbids keyword-search crawling in its robots.txt, so EURES is the legal route.

**How many jobs can I get?**
As many as match, up to **Max results** (`0` = no limit). Searches over the 10,000-per-search cap are split by country and NUTS 2 region. Only a single NUTS 2 region with more than 10,000 matches (e.g. Île-de-France, all jobs) stays capped per keyword; the log warns you.

**How fast is it?**
About 250-300 jobs per minute in search mode, about 6 per minute with full details (europa.eu asks for 10 seconds between requests).

**Why do some jobs have no salary, city or deadline?**
Many national feeds don't send them. City, structured salary and deadline come only from full details, and only when the employer provided them.

**Why do I get fewer jobs than the EURES website shows?**
Usually because of **Max results**, the ad-language filter or monitoring mode. `RUN_SUMMARY` shows matches and skipped jobs per search.

**Do I need proxies?**
No. The EURES API is open; the default is no proxy.

**Is it legal? What about GDPR?**
EURES content may be reused under the Commission's reuse policy (Decision 2011/833/EU, CC BY 4.0): "reuse is allowed, provided appropriate credit is given and changes are indicated". Every row has `source`, `attribution` and the vacancy `url`; keep them when you republish. The Actor needs no login and respects robots.txt and its crawl delay. Contact persons and street addresses are never output; e-mails, phone numbers and contact names are removed from descriptions. Employer names stay.

**Can I use it from Python, or get only new jobs?**
Yes. See [Use it via API](#use-it-via-api) and [Monitoring mode](#monitoring-mode-only-new-jobs).

**The run failed or a field is missing. What should I do?**
Open an issue on the **Issues** tab with the run link or your input. Recent changes are in the changelog below.

### Related Actors

More low-cost Actors by the same developer, built on official APIs and public data:

- [Arbeitsagentur Jobs Scraper](https://apify.com/kadi_bence/arbeitsagentur-jobs-scraper) — 1M+ German job offers by keyword, city and radius
- [Platsbanken Jobs Scraper](https://apify.com/kadi_bence/sweden-jobs-scraper) — Swedish job ads, live or archived since 2016
- [Greenhouse, Lever & Ashby Jobs Scraper](https://apify.com/kadi_bence/ats-jobs-scraper) — all open jobs of a company from 6 applicant systems, plus Workday
- [Workday Jobs Scraper](https://apify.com/kadi_bence/workday-jobs-scraper) — open jobs of any company by name (NVIDIA, Salesforce), plus Greenhouse/Lever fallback
- [Remote Jobs Scraper](https://apify.com/kadi_bence/remote-jobs-scraper) — remote jobs from We Work Remotely, RemoteOK, Himalayas and more
- [ATS Jobs Feed](https://apify.com/kadi_bence/ats-jobs-feed) — search a daily database of jobs from 1,000+ companies, no crawling wait
- [TED Tenders Scraper](https://apify.com/kadi_bence/ted-tenders-scraper) — EU public tenders and contract award winners

All my Actors: [apify.com/kadi_bence](https://apify.com/kadi_bence)

### Changelog

- **1.0 (2026-10-05):** first release. Search by keyword, country, NUTS region, ESCO/ISCO occupation, contract type, working time, education, experience, sector, languages and publication date. Relevance sorting, automatic splitting past the 10,000 cap, limits shared across countries, optional full details, monitoring mode, attribution and personal-data removal.

# Actor input Schema

## `keywords` (type: `array`):

Job titles or skills, e.g. "software developer", "nurse", "Python". Each keyword is a separate search (results are merged and de-duplicated). Leave empty for all jobs. Put places in Countries or Regions, not here.

## `searchIn` (type: `string`):

Where EURES looks for the keywords.

## `sortBy` (type: `string`):

EURES matches keyword words loosely (any word, any language version), so "Best match" (default with keywords) puts the real matches first. Without keywords the order is always newest first.

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

EU/EEA countries plus Switzerland. Leave empty for all 31 EURES countries. Via the API, "GR" and English country names also work for Greece. UK jobs are not in EURES.

## `regions` (type: `array`):

Optional NUTS region codes or names, e.g. "FR10", "Île-de-France", "Bayern", "DE21". EURES filters by NUTS 2: a NUTS 1 area is expanded to its NUTS 2 regions, a NUTS 3 code is widened to its NUTS 2 region. A region narrows its own country only (countries IE + DE with region Bayern = all of Ireland, only Bayern in Germany).

## `occupations` (type: `array`):

ESCO occupation URIs, ISCO-08 codes (e.g. "2512" software developers, "5120" cooks, "2221" nursing professionals) or English occupation names (e.g. "chef", "truck driver"). A name that is not an exact ESCO label matches up to 25 close ESCO occupations; the log lists them.

## `publishedWithinDays` (type: `integer`):

Only jobs published or updated in the last N days (the EURES "published" filter; e.g. 1 for daily alerts). 0 = any date. Many feeds refresh old ads, so the posted date can be older than N days.

## `contractTypes` (type: `array`):

Type of position offered.

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

Full-time, part-time or flexible hours.

## `educationLevels` (type: `array`):

Required education (ISCED / EQF levels).

## `experience` (type: `array`):

Required work experience.

## `sectors` (type: `array`):

Employer sector (NACE section).

## `languages` (type: `array`):

Languages the job asks for, as two-letter codes with your optional CEFR level: "en", "de:B2". EURES returns jobs that need the language at that level or lower; without a level any level matches.

## `adLanguages` (type: `array`):

Only ads written in these languages (e.g. English-language ads in Germany). Filtered after the search, so a narrow choice can scan many pages.

## `euresFlagOnly` (type: `boolean`):

Only jobs whose employer explicitly wants to recruit from other EU countries.

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

Stop after this many jobs. 0 = no limit. The default without input (API, MCP and AI-agent calls) is 20. The limit is shared fairly across keywords and countries/regions. Big searches are split by country / NUTS 2 region to get past the EURES 10,000-per-search cap.

## `includeDetails` (type: `boolean`):

Opens every vacancy for city, postal code, salary, deadline, start date, education, experience, required languages and the apply link. europa.eu asks for 10 s between requests, so this gives about 6 jobs per minute (vs about 300 without). Same price per job. Best for targeted runs of a few hundred jobs or daily alerts.

## `preferredLanguage` (type: `string`):

If an ad has several language versions (e.g. Belgium), use this one.

## `descriptionFormat` (type: `string`):

Job description as plain text, HTML, both, or none (smaller dataset). E-mails, phone numbers and contact persons are always removed.

## `onlyNewJobs` (type: `boolean`):

Remember returned jobs and output only NEW ones on later runs with the same search. Ideal for daily schedules with "Published within (days)" = 1 or 3: you only pay for new jobs.

## `monitorName` (type: `string`):

Separate 'already seen' lists for different schedules with the same search. Use a new name to start over.

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

Not needed: the EURES API is open. Off by default.

## Actor input object example

```json
{
  "keywords": [
    "software developer"
  ],
  "searchIn": "everywhere",
  "countries": [
    "DE",
    "NL"
  ],
  "euresFlagOnly": false,
  "maxResults": 20,
  "includeDetails": false,
  "descriptionFormat": "text",
  "onlyNewJobs": false,
  "monitorName": "default",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `jobs` (type: `string`):

All scraped jobs (table view).

## `jobsFull` (type: `string`):

All scraped jobs with every field.

## `summary` (type: `string`):

Matches per search, splits past the 10,000 cap, speed and any problems.

# 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 = {
    "keywords": [
        "software developer"
    ],
    "countries": [
        "DE",
        "NL"
    ],
    "maxResults": 20,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("kadi_bence/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 = {
    "keywords": ["software developer"],
    "countries": [
        "DE",
        "NL",
    ],
    "maxResults": 20,
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("kadi_bence/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 '{
  "keywords": [
    "software developer"
  ],
  "countries": [
    "DE",
    "NL"
  ],
  "maxResults": 20,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call kadi_bence/eures-jobs-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,kadi_bence/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/u2fHjwma4uHsqwyN7/builds/Y4jy9ejciSHAVlZpd/openapi.json
