# Recruitee Job Scraper — Netherlands Companies | $1.50/1K (`bovi/recruitee-job-scraper-nl`) Actor

Scrape job postings from Recruitee-powered career pages at Dutch companies (bunq, Bynder, Mollie, Coolblue, TomTom, and more). Get title, location, department, seniority, remote-type, salary, descriptions and parse\_confidence. Multi-company batch, keyword filters, zero auth, zero proxy.

- **URL**: https://apify.com/bovi/recruitee-job-scraper-nl.md
- **Developed by:** [Vitalii Bondarev](https://apify.com/bovi) (community)
- **Categories:** Jobs, Lead generation, MCP servers
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.36 / 1,000 recruitee job scraper — netherlands companies | $1.50/1ks

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?

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

## Recruitee Job Scraper NL — Careers API

For Dutch talent teams, job aggregators, and HR analytics platforms that need clean job data from Recruitee-powered Netherlands companies — with salary ranges when published.

**Pay per result — $1.50 / 1,000 jobs.** No API key. No login. No proxy required. Runs in Apify cloud.

Scrape job postings from **any Recruitee-powered company careers page** via the official public API. Give it a list of company slugs — get back clean, enriched job data in seconds. **No login, no API key, no browser, no proxy required.**

Get started instantly: use the pre-filled example (bunq, bynder, mollie) or swap in any Recruitee company slug. **Try it free** — Apify's $5/month free tier covers thousands of jobs.

### What this Recruitee scraper does

- Fetches every open job from any company that uses **Recruitee ATS**, using the official `<slug>.recruitee.com/api/offers/` endpoint.
- Returns a **clean flat schema** — identical fields every run, no parsing surprises.
- Enriches each job with **seniority** (intern / entry / mid / senior / lead / staff / principal / manager / director / vp / executive) — using Recruitee's native `experience_code` first, falling back to title-regex inference.
- Detects **remote type** (remote / hybrid / onsite) from Recruitee's explicit boolean flags — far more reliable than text parsing.
- Returns **salary** when the company publishes it (formatted as a range string).
- Returns full **job descriptions** as both plain text and HTML (togglable).
- Includes a **parse\_confidence score** (0–1.0) and `warnings` list in every record — you see exactly how clean the data is.
- Supports **multi-company batch runs** (scrape many companies in one run).
- Filters by **title keyword, location keyword, or remote-only**.
- **maxJobsPerCompany** cap (default 50) prevents surprise bills on first runs.

### How to find a Recruitee slug

The slug is the subdomain of the company's Recruitee careers page:

- `bunq.recruitee.com` → slug is `bunq`
- `bynder.recruitee.com` → slug is `bynder`
- `mollie.recruitee.com` → slug is `mollie`

Many Netherlands-based tech companies use Recruitee: bunq, Bynder, Mollie, Coolblue, TomTom, and hundreds more.

### What data you get

One flat row per job — 18 structured fields:

```json
{
  "title": "AML Branch Manager, Netherlands",
  "company": "bunq",
  "location": "Amsterdam, North Holland, Netherlands",
  "remote_type": "hybrid",
  "seniority": "senior",
  "salary": null,
  "department": "Support & Operations",
  "employment_type": "fulltime_permanent",
  "posted_at": "2026-05-29T09:45:21+00:00",
  "url": "https://careers.bunq.com/o/aml-branch-manager-netherlands",
  "apply_url": "https://careers.bunq.com/o/aml-branch-manager-netherlands/c/new",
  "job_id": "2620732",
  "global_id": "recruitee:bunq:2620732",
  "description_text": "At bunq, we are more than just a bank...",
  "description_html": "<p>At bunq, we are more than just a bank...</p>",
  "parse_confidence": 1.0,
  "warnings": [],
  "scraped_at": "2026-05-31T12:00:00+00:00"
}
```

**Field notes:**

- `remote_type` uses Recruitee's explicit `remote`, `hybrid`, `on_site` boolean flags — not fragile text parsing. Values: `remote`, `hybrid`, `onsite`, or `null`.
- `seniority` uses Recruitee's `experience_code` field when available (more accurate than title inference). Falls back to regex on the title.
- `salary` is `null` if the company doesn't publish it. When published, it is formatted as a human-readable string (e.g. `"80000–100000 EUR /year"`).
- `parse_confidence` is `1.0` for a fully-populated job; small deductions for missing optional fields. Check `warnings` for the reason codes.
- `global_id` format: `recruitee:{slug}:{job_id}` — stable identifier for deduplication across runs.

### Input schema

| Field | Type | Default | Description |
|---|---|---|---|
| `companies` | string array | \[bunq, bynder, mollie] | Recruitee company slugs to scrape |
| `titleKeyword` | string | — | Case-insensitive title filter |
| `locationKeyword` | string | — | Case-insensitive location filter |
| `remoteOnly` | boolean | false | Return only remote jobs |
| `maxJobsPerCompany` | integer | 50 | Cap per company (0 = unlimited) |
| `includeDescriptions` | boolean | true | Include description\_text + description\_html |

### Pricing

Pay-per-result: **$1.50 / 1,000 jobs** ($0.0015 each). You pay only for jobs returned.

**Worked example:** 3 companies × 50 jobs = 150 results = **$0.23**. 10 companies × 100 jobs = 1,000 results = **$1.50**.

### FAQ

**Do I need an API key or proxy?**
No. Recruitee's careers API (`<slug>.recruitee.com/api/offers/`) is publicly accessible — no auth, no proxy required.

**What output formats are available?**
JSON, JSONL, CSV, and Excel via the Apify dataset export, plus the Apify REST API.

**Can I schedule daily runs?**
Yes — use Apify Scheduler. Use `global_id` (`recruitee:<slug>:<job_id>`) as a stable dedup key across runs.

**What if salary is null for most jobs?**
Most Recruitee companies don't publish compensation publicly. The `salary` field is `null` when absent — honest and machine-readable. When published, you get a full range string (e.g. `"80000–100000 EUR /year"`).

### Reliability

The Recruitee careers API is a stable, publicly accessible endpoint with no authentication, no rate limiting, and no HTML parsing. This actor uses zero browser, zero proxy — just direct HTTP to an official JSON API. Parse confidence is consistently 1.0 on well-populated boards.

Typical run: 30–100 jobs for one company in under 3 seconds.

### Use cases

- **Job aggregation** — build a searchable careers board for Dutch tech companies.
- **Hiring intelligence** — track headcount growth, new departments, role types.
- **AI agent input** — feed job data to an LLM agent for matching, summarizing or alerting.
- **Lead generation** — identify companies actively hiring in specific functions.
- **Competitive analysis** — monitor competitor hiring signals in real time.

### Alternatives and comparison

The most comprehensive scraper for Recruitee-powered job boards — heavily used by Netherlands tech companies: bunq, Bynder, Mollie, Coolblue, TomTom, and hundreds more.

| Feature | This scraper | Typical ATS scrapers |
|---|---|---|
| Salary field (when published) | Yes | Rarely |
| Native remote/hybrid/onsite flags | Yes | No (text parsing only) |
| `parse_confidence` score | Yes | No |
| Seniority (native `experience_code` + title fallback) | Yes | No |
| NL-focused company support | Yes | Partial |
| Multi-company batch | Yes | Some |
| `global_id` for dedup | Yes | No |
| Price | $1.50/1k | varies |

**Salary honesty:** `salary` is `null` when the company doesn't publish it. When it IS published, you get the full range string (e.g. `"80000–100000 EUR /year"`) — machine-readable and ready for filtering.

`parse_confidence` (0.0–1.0) and `warnings` in every record — deductions for missing job\_id (0.15), title (0.15), url (0.10), posted\_at (0.05), description (0.05).

If your target companies use bunq instead of Recruitee, see our [bunq Job Scraper](https://apify.com/bovi/bunq-job-scraper).

### Use with AI agents (MCP)

This actor is MCP-compatible. Use it as a data source in n8n, Make, or any LLM agent pipeline.

```
https://mcp.apify.com/?tools=bovi/recruitee-job-scraper-nl
```

The flat schema with `global_id` (`recruitee:<slug>:<job_id>`) and native salary ranges is drop-in-ready for vector databases, Dutch job-matching LLMs, and automated sourcing workflows. Need Greenhouse, Lever, Ashby, SmartRecruiters and bunq in the same pipeline? Use the flagship [Multi-ATS Job Scraper](https://apify.com/bovi/greenhouse-lever-ashby-job-scraper) — 6 ATS, one unified schema.

### Integrations

Built for Dutch talent teams and job aggregators tracking open roles at Recruitee-powered companies — the JSON/dataset output drops into the tools you already run, no glue code:

- **n8n / Make / Zapier** — trigger a run or pipe every new dataset item into 500+ apps (Google Sheets, Airtable, Slack, HubSpot, your database) with no code: [n8n](https://docs.apify.com/platform/integrations/n8n), [Make](https://docs.apify.com/platform/integrations/make), [Zapier](https://docs.apify.com/platform/integrations/zapier).
- **Webhooks** — fire your own endpoint the moment a run finishes, to push results straight into your pipeline ([docs](https://docs.apify.com/platform/integrations/webhooks)).
- **MCP server** — expose this actor as a tool to Claude, Cursor, or any [MCP client](https://mcp.apify.com) so an AI agent can pull this data mid-conversation ([guide](https://blog.apify.com/how-to-use-mcp/)).
- **API & SDKs** — fetch the dataset as JSON, CSV, or Excel through the Apify REST API or the Python / JS SDKs.

See all [Apify integrations](https://apify.com/integrations).

### Not affiliated with Recruitee

This actor uses the public Recruitee careers API, which is freely accessible to anyone. It is not affiliated with, endorsed by, or partnered with Recruitee or its parent company Recruit Holdings.

# Actor input Schema

## `companies` (type: `array`):

Recruitee company slugs to scrape. The slug is the subdomain on the careers page: bunq.recruitee.com → slug is "bunq". Each item can be a plain string ("bunq") or an object ({"slug": "bunq"}).

## `titleKeyword` (type: `string`):

Keep only jobs whose title contains this text (case-insensitive). Example: "engineer". Leave blank to return all jobs.

## `locationKeyword` (type: `string`):

Keep only jobs whose location contains this text (case-insensitive). Example: "Amsterdam". Leave blank for all locations.

## `remoteOnly` (type: `boolean`):

When enabled, only jobs detected as fully remote are returned. Uses Recruitee's explicit remote flag — more reliable than text parsing.

## `maxJobsPerCompany` (type: `integer`):

Cap on jobs pushed per company slug after filtering. Default 50 keeps trial runs cheap. Set to 0 for unlimited.

## `includeDescriptions` (type: `boolean`):

Return full job description as plain text and HTML. Recruitee includes descriptions in the list response — no extra API calls, only controls output fields.

## Actor input object example

```json
{
  "companies": [
    "bunq",
    "bynder",
    "mollie",
    "coolblue",
    "tomtom"
  ],
  "remoteOnly": false,
  "maxJobsPerCompany": 50,
  "includeDescriptions": true
}
```

# Actor output Schema

## `results` (type: `string`):

Dataset containing Recruitee Job Scraper records (title, company, location, remote\_type, seniority, salary, department, posted\_at, url, parse\_confidence, global\_id).

# 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 = {
    "companies": [
        "bunq",
        "bynder",
        "mollie",
        "coolblue",
        "tomtom"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("bovi/recruitee-job-scraper-nl").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 = { "companies": [
        "bunq",
        "bynder",
        "mollie",
        "coolblue",
        "tomtom",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("bovi/recruitee-job-scraper-nl").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 '{
  "companies": [
    "bunq",
    "bynder",
    "mollie",
    "coolblue",
    "tomtom"
  ]
}' |
apify call bovi/recruitee-job-scraper-nl --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,bovi/recruitee-job-scraper-nl"
        }
    }
}

```

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/IXLcpnprFBFMEVoqF/builds/gBCx1jJ6ev8D4WqQd/openapi.json