# Jobat.be Scraper (`lexis-solutions/jobat-be-scraper`) Actor

Jobat.be scraper for Belgium job data: extract structured listings, company info, salary, benefits and full descriptions from 100k+ vacancies across Flanders, Brussels and Wallonia for market research, ATS enrichment and dashboards.

- **URL**: https://apify.com/lexis-solutions/jobat-be-scraper.md
- **Developed by:** [Lexis Solutions](https://apify.com/lexis-solutions) (community)
- **Categories:** Jobs, Automation, AI
- **Stats:** 6 total users, 1 monthly users, 100.0% runs succeeded, 2 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

$29.00/month + usage

To use this Actor, you pay a monthly rental fee to the developer. The rent is subtracted from your prepaid usage every month after the free trial period.You also pay for the Apify platform usage, which gets cheaper the higher Apify subscription plan you have.

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

## 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

## Jobat.be Scraper

![banner](https://i.imgur.com/ZunwBTE.png)

Welcome to the Jobat.be Scraper! Jobat.be is a leading Belgian job board with 100,000+ vacancies monthly across Wallonia, Brussels, and Flanders, serving Dutch, French, and English audiences with deep search and filtering, salary calculators, company reviews, and career resources. This actor collects listings from the platform—titles, company info, locations, addresses, benefits, and full descriptions—so you can tap its breadth of roles and metadata in your workflows.

### Introduction

The scraper starts from Jobat.be search results or individual job URLs, paginates through listings, and visits each detail page to extract structured data: company profile links, locations, salary/benefits, job requirements, and the full narrative description. It supports both query-built searches and explicit start URLs, letting you target broad searches or specific jobs.

### Use Cases

- **Job market research**: Analyze roles, locations, and sectors across Belgium.
- **ATS/CRM enrichment**: Feed fresh postings with structured metadata.
- **Competitor monitoring**: Track hiring activity by company or region.
- **Data aggregation**: Build dashboards by category, location, or posting date.

### Input

Supported fields:

- `startUrls` (array, optional): Jobat.be result URLs or detail URLs containing `job_<id>`. Off-domain/unknown patterns are skipped.
- `query` (string, optional): Search keyword. When set, the scraper builds the search URL automatically.
- `location` (string, optional): Free-text location (use the English city name, e.g. `Ghent`, `Brussels`); resolved to a slug via Jobat.be autocomplete.
- `region` (string, optional): Valid region slug (see enum in code). If set, `location` is ignored.
- `category` / `subCategory` (string, optional): Must exist in the category/subCategory lists; combinations must be valid.
- `kmfrom` (number, optional): Radius km only applied if location is resolved and `region` is empty; value must be in the distance enum (0, 5, 10, 20, 30, 40, 50).
- `contract`, `workSchedule`, `sector`, `onlineSince`, `language` (optional): Only enum values are applied. `language=en` removes the `joblanguage` filter (all languages).
- `maxItems` (integer, Required): Limit of items to fetch **per start URL**. If empty, the crawler paginates until results end.
- `proxyConfiguration` (object, optional): Apify proxy configuration. Example: `{ "useApifyProxy": false }`.

### Notes

- Off-domain URLs or unknown patterns in `startUrls` are skipped.
- Either `startUrls` or `query` must be provided to run the scraper.
- If `category` and `subCategory` are both set but the subCategory doesn’t belong to that category, the subCategory is ignored; if only subCategory is set, category is auto-filled from it.
- `region` takes priority over `location`; if a valid region is set, location is ignored. When `location` is used, the first autocomplete suggestion is applied—if no suggestion, location is skipped.
- `kmfrom` is processed only when `location` is provided and resolved (and no `region` is set).
- `language=en` disables language filtering; other language values use the site’s numeric language filter.
- `maxItems` caps the items collected per start URL across pagination; if omitted, pagination runs until the list ends.

### Input Example

- Example with `query`:

  ```json
  {
    "query": "developer",
    "location": "Brussels",
    "kmfrom": 20,
    "category": "ict",
    "subCategory": "development",
    "contract": "permanent",
    "maxItems": 25,
    "proxyConfiguration": {
      "useApifyProxy": false
    }
  }
  ```

- Example with `startUrls` (list + detail):
  ```json
  {
    "startUrls": [
      { "url": "https://www.jobat.be/en/jobs/results/ict/development" },
      { "url": "https://www.jobat.be/en/jobs/front-end-developer/job_123456" }
    ],
    "maxItems": 15,
    "proxyConfiguration": {
      "useApifyProxy": false
    }
  }
  ```

### Output

Each dataset item contains, for example:

```json
{
  "url": "https://www.jobat.be/en/jobs/results/developer/brussels/job_123456",
  "title": "Frontend Developer",
  "companyName": "Acme NV",
  "companyGroupName": "Acme Group",
  "companyUrl": "https://www.jobat.be/en/companies/acme-nv",
  "companyLogo": "https://.../logo.png",
  "location": "Brussels",
  "duration": "Published on Jobat.be 5 days ago",
  "categorys": ["Permanent", "Full-time"],
  "category": "ICT",
  "subCategory": "Development",
  "subSubCategory": "Front-end development",
  "contractType": "Permanent",
  "workSchedule": "Full-time",
  "jobId": "123456",
  "companyId": "89961",
  "jobCompanyType": "Direct",
  "productId": "7890",
  "region": "brussels",
  "regionZipCode": "1000",
  "applicationType": "external",
  "regime": "Full Time",
  "reqDegree": "Bachelor",
  "reqLanguage": ["NL", "EN"],
  "salary": "Competitive",
  "date": "2025-12-01",
  "updateTimestamp": "2025-12-03T10:00:00Z",
  "datePosted": "2025-12-01",
  "validThrough": "2026-01-05",
  "employmentType": "FULL_TIME",
  "addressLocality": "Brussels",
  "addressRegion": "Brussels",
  "addressCountry": "BE",
  "postalCode": "1000",
  "streetAddress": "Main Street 1",
  "responsibilities": "Build and maintain UI components...",
  "skillsQualifications": "React, TypeScript",
  "jobBenefits": ["Meal vouchers", "Hospitalization insurance"],
  "fullDescription": "Full job description text...",
  "functionType": ["Development"],
  "sector": ["ICT, Telecom and Internet"],
  "locations": ["Brussels"],
  "requirements": ["3+ years experience", "Fluent in English"]
}
```

The scraper paginates until `maxItems` is reached or listings end.

### Why use the Jobat.be Scraper?

- **Fast**: Automatic pagination with a clear `maxItems` cap.
- **Easy**: Start from result URLs or just provide `query` + filters.
- **Flexible**: Location via region or autocomplete, optional radius, validated category/subCategory.
- **Rich data**: Google JSON metadata, structured address, benefits, and full description.
- **Built on Apify/Crawlee**: Production-ready stability.

### FAQ

- **How many jobs can it fetch?**\
  Set `maxItems`; the crawler stops at the limit or when no more results remain.

- **Which URLs should I use?**\
  Use Jobat.be search/result URLs, or let `query` build the URL. Off-domain or unknown patterns are skipped.

- **Proxy support?**\
  Yes, via `proxyConfiguration`.

- **How does location filtering work?**\
  `region` wins; if empty, `location` is resolved via autocomplete. `kmfrom` applies only when location resolves and `region` is not set.

### Need to scrape other job platforms?

Check out our other job scrapers on Apify:

- [Jobs.ch Scraper](https://apify.com/lexis-solutions/jobs-ch-scraper)
- [Jobs.cz Scraper](https://apify.com/lexis-solutions/jobs-cz-scraper)
- [VDAB.be Scraper](https://apify.com/lexis-solutions/vdab-be-scraper)
- [Jobs Ireland Scraper](https://apify.com/lexis-solutions/jobs-ireland-ie-scraper)
- [Job Jobnet DK Scraper](https://apify.com/lexis-solutions/job-jobnet-dk-scraper)
- [Tyomarkkinatori.fi Scraper](https://apify.com/lexis-solutions/tyomarkkinatori-fi-scraper)
- [AMS Austria Jobs Scraper](https://apify.com/lexis-solutions/jobs-ams-at-scraper)

***

**Need help or want a custom solution?**

Lexis Solutions is a certified Apify Partner. Contact us for help or custom builds.

Email: <scraping@lexis.solutions>\
LinkedIn: [Lexis Solutions](https://www.linkedin.com/company/lexis-solutions)

### Support Our Work

If this scraper helps you, please leave a company review [here](https://apify.com/partners/find/lexis-solutions/review) and review the scrapers you use. Thank you!

Image Credit: https://www.jobat.be/

# Actor input Schema

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

URLs to start with.

## `maxItems` (type: `integer`):

Maximum number of items that will be extracted per start URL.

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

Your proxy configuration from Apify

## `query` (type: `string`):

Search query

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

Location

## `category` (type: `string`):

Category

## `subCategory` (type: `string`):

Sub Category

## `kmfrom` (type: `string`):

Km from

## `region` (type: `string`):

Region

## `contract` (type: `string`):

Contract type

## `workSchedule` (type: `string`):

Work Schedule

## `sector` (type: `string`):

Sector

## `onlineSince` (type: `string`):

Filter by how recently the job was posted

## `language` (type: `string`):

Language of the job postings

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.jobat.be/en/jobs/results/javascript"
    }
  ],
  "maxItems": 5,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `overview` (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 = {
    "startUrls": [
        {
            "url": "https://www.jobat.be/en/jobs/results/javascript"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("lexis-solutions/jobat-be-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.jobat.be/en/jobs/results/javascript" }] }

# Run the Actor and wait for it to finish
run = client.actor("lexis-solutions/jobat-be-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.jobat.be/en/jobs/results/javascript"
    }
  ]
}' |
apify call lexis-solutions/jobat-be-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/dGD7lLs6hqFBuiKvb/builds/qV3GFdQkbVrIZkQgP/openapi.json