# 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
- **Features:** Limited permissions
- **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/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

## Adecco Scraper (Belgium, Netherlands, France, Spain, Italy, Poland)

Get current [Adecco](https://www.adecco.com) job listings for Belgium (Dutch and French), the Netherlands, France, Spain, Italy and Poland as structured JSON. Pick a country and a keyword, and every row has the title, location, employment type, posting date and a 300 to 400 character description excerpt. In a France run for "comptable", 28 of 50 rows also carried a salary.

A 50-row run takes about 80 seconds and costs about $0.105 ($0.005 start plus $0.002 per row). No login, no cookies, no browser. The actor calls the same JSON API adecco.com uses for every market.

### 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, plus the title split into its '|' parts
- Hiring company (always Adecco), plus the client company when Adecco publishes it
- Location (city, region, country)
- Language of the posting
- Employment type and contract type
- Salary, when the listing has one (28 of 50 in France, 3 of 30 in Poland, none in the Belgian runs we tested)
- 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 is not available (see Limitations).

### Why use it

- **Staffing market research.** Track which roles Adecco is placing across six markets from one actor.
- **Recruitment and sourcing.** Build a feed of temp and permanent positions for a role or region.
- **Title details.** Belgian titles often add a town, shift, hours or sector after a '|'. `titleParts` gives these parts as a list.
- **Salary benchmarking.** French listings disclose salary most often.

### 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 and the 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** (up to 500). Each result needs one extra request for its description, so larger runs take longer.
5. Leave the proxy on the default residential setting and click **Start**.

The actor pages through Adecco's search API (10 results per page), skips listings that do not match your location filter, and stops at Max Results or when the listings run out. It then fetches the description for each selected job and writes the rows 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, best in the local language. Empty returns all current listings of the country. The prefilled `warehouse` only matches English-language listings. |
| `location` | string | Optional city or region, matched as text against the listing location. |
| `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",
    "titleParts": ["Magazijnier"],
    "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 | End client, only when Adecco's job record names it. Usually empty. |
| `titleParts` | array | The title split on the pipe character |
| `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 | Salary text from the listing. Empty when the listing has none. |
| `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

Pay per event: $0.005 per run start plus $0.002 per row on the Free and Bronze plans ($0.0015 Silver, $0.0012 Gold and above).

| Rows | Cost on Free or Bronze | Run time we measured |
|---|---|---|
| 20 | $0.045 | about 55 seconds |
| 30 | $0.065 | about 90 seconds |
| 50 | $0.105 | about 80 seconds |
| 500 | $1.005 | not measured |

### Limitations

- **Germany is not covered.** `adecco.de` runs on a different platform and the shared endpoint returns HTTP 500 for `countryCode: DE`.
- **`url` is Adecco's apply link.** The public job-detail URL formats differ per market and cannot be built from the search API, so the apply link is used.
- **`clientCompany` is usually empty.** Adecco keeps the end client anonymous. Its job record had no client name on 120 of 120 jobs we checked in Belgium, the Netherlands, France and Italy. The parts of a title are mostly towns, shifts and sectors, so the actor does not guess a client from them.
- **Location filtering is a text match.** A location of `Antwerpen` with the query `warehouse` in Belgium (Dutch) returned 7 rows, because only 7 matching listings exist. Adecco's API has no location parameter.
- **Page size is fixed at 10.** Larger runs need proportionally more requests.

### 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"
    ]
  }
}
```

# Actor output Schema

## `results` (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 = {
    "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(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 '{
  "searchQuery": "warehouse",
  "maxResults": 10,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call studio-amba/adecco-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,studio-amba/adecco-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/8logBJoU5XDovnia2/builds/sGV6tzB7rorcAsCT2/openapi.json