# Adecco Scraper — Multi-Country Staffing Agency Jobs (`studio-amba/adecco-scraper`) Actor

Scrape job listings from Adecco across Belgium, the Netherlands, France, Spain, Italy and Poland — one of the world's largest staffing agencies. No login or cookies required.

- **URL**: https://apify.com/studio-amba/adecco-scraper.md
- **Developed by:** [Studio Amba](https://apify.com/studio-amba) (community)
- **Categories:** Jobs
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.20 / 1,000 result scrapeds

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 web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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

## Adecco Scraper — Multi-Country

Extract job listings from [Adecco](https://www.adecco.com), one of the world's largest staffing agencies, as clean structured JSON — across six European markets from a single actor. Pick a country, search by keyword, and get job titles, locations, salary, employment type, posting dates and full description excerpts.

No login. No cookies. No browser automation. The actor talks to the same global JSON API adecco.com uses for every market it runs on.

### What this actor does

Adecco runs one shared platform at `adecco.com` with a locale path per market (`nl-be`, `fr-be`, `nl-nl`, `fr-fr`, `es-es`, `it-it`, `pl-pl`, ...) and a single job-search API behind all of them. This actor calls that API directly for your chosen country and returns one row per job with:

- Job title (Adecco often embeds the end client directly in the title)
- Hiring company (Adecco), plus a best-effort extracted client company name
- Location (city, region, country)
- Language of the posting
- Employment type and contract type
- Salary, when disclosed
- Posting date
- A 300–400 character description excerpt (fetched from Adecco's job-detail endpoint)
- Adecco's own apply link for the job

### Supported countries

| Input value | Market |
|---|---|
| `BE-nl` | Belgium (Dutch) — default |
| `BE-fr` | Belgium (French) |
| `NL` | Netherlands |
| `FR` | France |
| `ES` | Spain |
| `IT` | Italy |
| `PL` | Poland |

Germany was tested and excluded: `adecco.de` runs a separate legacy platform (a client-side React app) with no equivalent JSON API, so it can't be covered by this actor without a full separate build. All seven markets above were verified live against real, current listings before shipping.

### Why use it

- **Pan-European staffing market research** — track what roles Adecco is placing across six markets from one tool instead of six.
- **Recruitment and sourcing** — build a live feed of temp and permanent positions for a role, client industry or region.
- **Client intelligence** — Adecco frequently names its end client directly in the job title; this actor surfaces that as a separate field.
- **Salary benchmarking** — a meaningful share of listings disclose pay rate and time scale.

### How to scrape Adecco data

1. Open the actor and pick a **Country** (e.g. `FR` for France).
2. Set a **Search Query** in the local language (e.g. `comptable` for France, `magazijnier` for Belgium/Netherlands, `almacen` for Spain). Leave it empty to get the most recent listings for the whole country.
3. Optionally set a **Location filter** to narrow results to a city or region.
4. Set **Max Results** — each result costs one extra request to fetch its full description, so keep this proportional to how much detail you need.
5. Leave the proxy on the default residential setting (the API rate-limits aggressively from a single IP) and click **Start**.

The actor pages through Adecco's search API (10 results per page) until it reaches your Max Results or runs out of listings, fetches the full description for each selected job, applies your location filter, and writes everything to the dataset.

### Input

| Field | Type | Description |
|-------|------|-------------|
| `country` | string | Market to search. One of `BE-nl`, `BE-fr`, `NL`, `FR`, `ES`, `IT`, `PL`. Default: `BE-nl`. |
| `searchQuery` | string | Keyword in the local language. Empty = all current listings, most recent first. |
| `location` | string | Optional city/region filter, applied client-side. |
| `maxResults` | integer | Maximum number of listings to return (max 500). Default: `50`. |
| `proxyConfiguration` | object | Apify proxy settings. Default: residential. |

#### Example input

```json
{
    "country": "FR",
    "searchQuery": "comptable",
    "location": "",
    "maxResults": 50,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": ["RESIDENTIAL"]
    }
}
```

### Output

Each dataset item looks like this:

```json
{
    "title": "Magazijnier",
    "company": "Adecco",
    "clientCompany": "Soudal",
    "locationRaw": "TURNHOUT, Antwerpen",
    "locationParsed": { "city": "TURNHOUT", "region": "Antwerpen", "country": "Belgium" },
    "language": "nl",
    "postedAt": "2026-08-03T15:13:13.101Z",
    "descriptionSnippet": "Wil jij deel uitmaken van het magazijnteam bij SOUDAL? Dan is dit jouw kans! Bij Adecco Turnhout zoeken we enthousiaste magazijniers die graag in een vast ploegensysteem willen werken...",
    "url": "https://coaching.adecco.be/associate/apply?vacancyId=180-32423-&jobTitle=Magazijnier&CampaignID=1&LanguageID=NL",
    "employmentType": "Tijdelijk contract - optie vast",
    "source": "adecco.com/nl-be",
    "scrapedAt": "2026-08-04T17:20:58.580Z",
    "jobId": "180-32423-2",
    "externalReference": "180-32423"
}
```

#### Output fields

| Field | Type | Description |
|-------|------|-------------|
| `title` | string | Job title, as posted |
| `company` | string | Always `Adecco` |
| `clientCompany` | string | Best-effort extracted end client (from the job title's pipe-delimited convention) |
| `locationRaw` | string | Location as shown on the listing |
| `locationParsed` | object | `{ city, region, country }` |
| `language` | string | ISO 639-1 language code of the posting |
| `postedAt` | string | ISO 8601 posting timestamp |
| `descriptionSnippet` | string | 300–400 character plain-text excerpt |
| `url` | string | Adecco's own apply/job link |
| `employmentType` | string | Contract type + employment type |
| `salaryRaw` | string | Raw salary information, when disclosed |
| `source` | string | Source identifier, e.g. `adecco.com/nl-be` |
| `scrapedAt` | string | ISO 8601 timestamp of collection |
| `jobId` | string | Unique Adecco job identifier |
| `externalReference` | string | Adecco's internal reference code |

### Cost estimate

Each run makes one listing-page request per 10 results plus one detail request per result (to fetch the full description). Both are lightweight JSON API calls, no browser — a 50-result run is around 55 requests total plus proxy traffic. Usage is only charged after a run finishes with status SUCCEEDED — a failed or aborted run doesn't bill for partial results.

### Limitations

- **Germany is not covered.** `adecco.de` runs on a different platform with no equivalent JSON API (verified live — the shared endpoint returns HTTP 500 for `countryCode: DE`).
- **`url` is Adecco's apply link, not a guessed canonical detail page.** Adecco's public job-detail URL slugs are inconsistent across markets (checked via sitemap: Italy/Spain use a UUID suffix, France uses a plain numeric ID, Poland uses the internal reference code) and can't be reliably reconstructed from the search API. Using the apply link guarantees every `url` actually works.
- **`clientCompany` is best-effort.** It's extracted from Adecco's own pipe-delimited title convention when present; roughly half of listings don't name the client and the field is left empty.
- **Location filtering is client-side.** Adecco's API doesn't expose a reliable structured location parameter.
- **Fixed page size of 10.** Verified live — `pageSize`, `top`, `rows` and `take` parameters have no effect on the API.

### Related scrapers

Building a European staffing dataset? These sibling actors follow the same clean-JSON approach:

- **Randstad Belgium Scraper** — the world's largest staffing agency, Belgian market
- **VDAB Scraper** — Flemish public employment service
- **Le Forem Scraper** — Walloon public employment service
- **Actiris Scraper** — Brussels public employment service
- **StepStone Scraper** — Belgian commercial job board

### Disclaimer

This actor collects publicly available data from Adecco for legitimate research and aggregation use. Respect Adecco's terms of service and applicable data protection law when using the output.

# Actor input Schema

## `country` (type: `string`):

Adecco market to search. Belgium has separate Dutch and French listings.

## `searchQuery` (type: `string`):

Keyword to search for, in the local language (e.g. 'magazijnier' for Belgium/NL, 'comptable' for France, 'almacen' for Spain, 'magazzino' for Italy, 'magazyn' for Poland). Leave empty to return all current listings for the selected country, sorted by most recently posted.

## `location` (type: `string`):

Optional city or region to filter results by. Applied client-side against the listing's location text — Adecco's API does not expose a reliable structured location filter.

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

Maximum number of job listings to return. Each result triggers one extra request to fetch the full description, so very large values take proportionally longer.

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

Proxy settings. A residential proxy is recommended — the job-search API rate-limits aggressively from a single IP.

## Actor input object example

```json
{
  "country": "BE-nl",
  "searchQuery": "warehouse",
  "maxResults": 10,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# 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 = {
    "searchQuery": "warehouse",
    "maxResults": 10,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("studio-amba/adecco-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 = {
    "searchQuery": "warehouse",
    "maxResults": 10,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("studio-amba/adecco-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 '{
  "searchQuery": "warehouse",
  "maxResults": 10,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call studio-amba/adecco-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/8logBJoU5XDovnia2/builds/ClyZgqDQfbeqAt6IY/openapi.json