# VDAB Scraper — Belgian/Flemish Job Listings & Vacancies (`studio-amba/vdab-scraper`) Actor

Scrape job vacancies from VDAB.be, the Flemish public employment service. Get job titles, companies, locations, contract types, and descriptions.

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

## Pricing

from $8.00 / 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.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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

## VDAB Scraper -- Extract Job Vacancies from Belgium's Flemish Employment Service

Scrape job listings, company information, contract types, and work regimes from [VDAB.be](https://www.vdab.be) -- the official Flemish government employment service that publishes hundreds of thousands of active vacancies across Belgium.

### What is VDAB Scraper?

VDAB (Vlaamse Dienst voor Arbeidsbemiddeling en Beroepsopleiding) is the Flemish public employment agency. It is the single largest source of job postings in Flanders, covering everything from public sector nursing positions to private sector software engineering roles. Unlike commercial job boards that charge for premium listings, VDAB captures the full breadth of the Flemish labour market -- including blue-collar jobs, government positions, and niche roles that never appear on LinkedIn or Indeed.

This actor taps into VDAB's internal Angular API to extract structured vacancy data at scale. Here is what people build with it:

- **Recruitment intelligence** -- staffing agencies monitor new postings by sector and city to spot hiring surges before competitors react.
- **Labour market research** -- economists and policy analysts track vacancy volumes by region, contract type, and industry to study employment trends in Flanders and Brussels.
- **HR benchmarking** -- companies compare their job descriptions, locations, and work regimes against what the broader market offers for the same roles.
- **Job aggregation** -- career platforms and email newsletters pull VDAB data into their own databases to serve Belgian job seekers with a wider reach.
- **Academic studies** -- universities analysing the Belgian labour market use structured VDAB exports for quantitative research that the website's UI simply cannot support.

### What data does VDAB Scraper extract?

Every job listing is returned as a clean JSON object containing:

- :briefcase: **Job title** -- the vacancy function as listed by the employer
- :office: **Company name** -- the hiring organisation
- :round_pushpin: **Location** -- city, region, or municipality
- :page_facing_up: **Contract type** -- onbepaalde duur, bepaalde duur, interim, studentenjob, etc.
- :clock3: **Work regime** -- voltijds, deeltijds, ploegenstelsel, or flexible
- :calendar: **Publication date** -- when the vacancy first appeared on VDAB
- :memo: **Description** -- the job summary text
- :link: **Direct URL** -- deep link to the full vacancy page on vdab.be
- :stopwatch: **Scraped timestamp** -- ISO datetime of data capture

### How to scrape VDAB.be

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `searchQuery` | String | No | Keyword search. Examples: `"developer"`, `"verpleegkundige"`, `"chauffeur"` |
| `location` | String | No | Filter by city or region: `"Antwerpen"`, `"Gent"`, `"Brussel"` |
| `maxResults` | Integer | No | Maximum jobs to return (default: 100, max: 10,000) |
| `proxyConfiguration` | Object | No | Proxy settings for reliability |

**Tips for better results:**

- Use **Dutch keywords** for best coverage. VDAB is a Flemish platform, so `"verpleegkundige"` returns far more nursing results than `"nurse"`.
- Combine `searchQuery` with `location` for targeted extractions. `"data analyst"` + `"Leuven"` narrows results precisely.
- For a full market snapshot, set `searchQuery` to something broad and `maxResults` to `5000` or higher.
- The actor intercepts VDAB's Angular API responses directly, capturing the same structured data the internal search engine uses.

### Output

```json
{
    "title": "Verpleegkundige - Spoedgevallen",
    "company": "UZ Gent",
    "location": "Gent",
    "contractType": "Onbepaalde duur",
    "workRegime": "Voltijds, Deeltijds",
    "publishDate": "2026-03-28",
    "description": "Het UZ Gent is op zoek naar een gedreven verpleegkundige voor de dienst spoedgevallen. Je werkt in een dynamisch team en bent verantwoordelijk voor...",
    "url": "https://www.vdab.be/vindeenjob/vacatures/12345678",
    "scrapedAt": "2026-04-03T10:15:00.000Z"
}
````

### How much does it cost?

VDAB Scraper uses Playwright (browser-based crawling) to handle the Angular application. Approximate costs:

| Volume | Estimated CUs | Estimated Cost |
|--------|--------------|----------------|
| 100 jobs | ~0.05 | ~$0.02 |
| 500 jobs | ~0.20 | ~$0.10 |
| 1,000 jobs | ~0.40 | ~$0.20 |
| 5,000 jobs | ~2.00 | ~$1.00 |

Costs vary based on proxy usage, pagination depth, and data density per page.

### Can I integrate?

Apify integrations let you push VDAB job data directly into:

- **Google Sheets** -- automatic spreadsheet updates for HR dashboards
- **Slack / Microsoft Teams** -- alerts when new jobs match your criteria
- **Zapier / Make (Integromat)** -- connect to 5,000+ apps without writing code
- **Webhooks** -- receive data via HTTP POST to your own server or pipeline
- **Amazon S3 / Google Cloud Storage** -- archive raw data in cloud buckets
- **PostgreSQL / MySQL** -- load structured data directly into your analytics database

Schedule the actor to run daily or weekly and build a historical dataset of the Flemish job market.

### Can I use it as an API?

Yes. Call the actor programmatically using the Apify API or official client libraries.

**Python:**

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_API_TOKEN")

run = client.actor("studio-amba/vdab-scraper").call(run_input={
    "searchQuery": "software engineer",
    "location": "Antwerpen",
    "maxResults": 200,
})

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(f"{item['title']} at {item['company']} in {item['location']}")
```

**JavaScript:**

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

const client = new ApifyClient({ token: "YOUR_API_TOKEN" });

const run = await client.actor("studio-amba/vdab-scraper").call({
    searchQuery: "software engineer",
    location: "Antwerpen",
    maxResults: 200,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.log(`${item.title} at ${item.company} in ${item.location}`);
});
```

### FAQ

**Is VDAB Scraper free to use?**
The actor itself is free. You only pay for Apify platform compute units based on run duration and memory usage.

**Does it capture salary information?**
VDAB employers rarely include salary in the public listing. When present, it appears in the description field. Most Belgian job posts omit explicit salary ranges.

**Can I filter by industry or sector?**
Use Dutch sector keywords in the search query: `"bouw"` (construction), `"IT"`, `"horeca"`, `"onderwijs"` (education), `"logistiek"` (logistics).

**Why are some fields empty?**
VDAB's API returns varying detail levels depending on how the employer structured the posting. The actor captures everything available, but minimal postings exist.

**How often is VDAB data updated?**
Vacancies appear and expire in real time. Schedule the actor daily for complete market coverage.

**Does it work for Wallonia or French-speaking jobs?**
No. VDAB is specifically for Flanders. For Wallonia, the equivalent is Le Forem (forem.be).

**Can I track new postings over time?**
Yes. Schedule the actor to run daily and compare datasets. New job URLs that did not appear in yesterday's run are new postings. URLs that disappeared represent filled or expired vacancies.

**What is the difference between VDAB and Actiris?**
VDAB serves Flanders (Dutch-speaking Belgium). Actiris is the equivalent for the Brussels-Capital Region. Le Forem covers Wallonia. Each has its own website and job database.

**How many jobs are typically available on VDAB?**
VDAB typically lists between 150,000 and 250,000 active vacancies at any given time, making it one of the largest public employment databases in Europe for its population size.

### Limitations

- Uses Playwright browser crawling (higher compute cost than simple HTTP scrapers) because VDAB is an Angular SPA.
- Does not visit individual vacancy detail pages -- extracts data from search result API responses for efficiency.
- Relies on VDAB's internal API structure; changes to their Angular app may require actor updates.
- Anti-bot measures may reduce throughput during peak hours; enable proxy configuration for large runs.
- Only Dutch-language Flemish vacancies. Brussels bilingual postings appear when they are published on VDAB.

### Other Belgian job and data scrapers

- [UiTinVlaanderen Scraper](https://apify.com/studio-amba/uitinvlaanderen-scraper) -- cultural events across Flanders
- [Resto.be Scraper](https://apify.com/studio-amba/resto-scraper) -- Belgian restaurants, Michelin stars, Gault Millau scores
- [NMBS Scraper](https://apify.com/studio-amba/nmbs-scraper) -- Belgian railway connections and schedules
- [AutoVlan Scraper](https://apify.com/studio-amba/autovlan-scraper) -- used car listings from Belgium's largest marketplace

### Your feedback

We improve our scrapers based on user feedback. If you need additional fields extracted, encounter issues, or want to suggest improvements, open an issue on the actor's GitHub page or contact us through the Apify platform. Your input shapes what we build next.

# Actor input Schema

## `startUrls` (type: `array`):

VDAB job search pages. Example: https://www.vdab.be/vindeenjob/vacatures

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

Search for jobs by keyword (e.g., 'developer', 'verpleegkundige', 'chauffeur').

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

Filter by city or region (e.g., 'Antwerpen', 'Gent', 'Brussel').

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

Maximum number of job listings to return.

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

Proxy settings for reliability.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.vdab.be/vindeenjob/vacatures"
    }
  ],
  "searchQuery": "developer",
  "maxResults": 100,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "BE"
  }
}
```

# 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 = {
    "startUrls": [
        {
            "url": "https://www.vdab.be/vindeenjob/vacatures"
        }
    ],
    "searchQuery": "developer",
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "BE"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("studio-amba/vdab-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 = {
    "startUrls": [{ "url": "https://www.vdab.be/vindeenjob/vacatures" }],
    "searchQuery": "developer",
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "BE",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("studio-amba/vdab-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 '{
  "startUrls": [
    {
      "url": "https://www.vdab.be/vindeenjob/vacatures"
    }
  ],
  "searchQuery": "developer",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "BE"
  }
}' |
apify call studio-amba/vdab-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "VDAB Scraper — Belgian/Flemish Job Listings & Vacancies",
        "description": "Scrape job vacancies from VDAB.be, the Flemish public employment service. Get job titles, companies, locations, contract types, and descriptions.",
        "version": "0.1",
        "x-build-id": "gCi7stmeKyHaiAfPq"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/studio-amba~vdab-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-studio-amba-vdab-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/studio-amba~vdab-scraper/runs": {
            "post": {
                "operationId": "runs-sync-studio-amba-vdab-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/studio-amba~vdab-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-studio-amba-vdab-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "VDAB job search pages. Example: https://www.vdab.be/vindeenjob/vacatures",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "searchQuery": {
                        "title": "Search Query",
                        "type": "string",
                        "description": "Search for jobs by keyword (e.g., 'developer', 'verpleegkundige', 'chauffeur')."
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "Filter by city or region (e.g., 'Antwerpen', 'Gent', 'Brussel')."
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of job listings to return.",
                        "default": 100
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Proxy settings for reliability."
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
