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

\[💰 $0.95 / 1K] Extract job listings from Jobat.be, one of Belgium's largest job boards. Search by keyword, location, and province in Dutch (Flanders) or French (Wallonia) to get titles, companies, salaries, contract types, descriptions, contacts, and apply links.

- **URL**: https://apify.com/solidcode/jobat-be-scraper.md
- **Developed by:** [SolidCode](https://apify.com/solidcode) (community)
- **Categories:** Jobs, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.95 / 1,000 results

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

## Jobat.be Scraper

Pull job listings from Jobat.be — one of Belgium's largest job boards — across all 11 Belgian provinces, in both Dutch (Flanders) and French (Wallonia). Get clean, structured records for every posting: title, company, location, contract type, full description, benefits, apply link, and recruiter contact details pulled straight from the ad. Built for Belgian recruiters, labor-market analysts, and relocation and staffing teams who need fresh, structured Jobat.be data without copying postings one tab at a time.

### Why This Scraper?

- **All 11 Belgian provinces** — filter to Antwerp, East/West Flanders, Flemish Brabant, Limburg, Walloon Brabant, Hainaut, Liège, Luxembourg, Namur, or the Brussels-Capital Region with a clean dropdown — no need to guess URL parameters.
- **Both languages, both regions** — switch between Dutch (Flanders) and French (Wallonia) listings; the scraper follows Jobat.be's localized site path so you capture region-specific jobs that only appear in one language.
- **Five contract-type filters** — permanent, temporary, freelance, internship, and student jobs, each as a single-click option instead of a wire value you have to look up.
- **Recruiter emails and phone numbers per listing** — emails, phone numbers, and apply URLs are extracted from each job ad, turning a posting into a ready-to-use contact.
- **Full job descriptions plus benefits lists** — the complete ad text, the snippet, and the listed perks and benefits — not just the title and a teaser.
- **Structured salary fields where Jobat exposes them** — parsed minimum, maximum, currency, and period (Jobat hides salary on most Belgian ads, so this fills in whenever it's available).
- **"Posted within" freshness filter** — last 24 hours, 3 days, 7 days, or 30 days, so daily monitoring runs only pick up new postings.
- **Paste any Jobat.be search or job URL** — drop in a search you've already dialed in on the site (with its facets) or individual job pages, and they're collected exactly as-is.
- **Automatic de-duplication** — the same job is never returned twice, even when multiple keyword searches overlap.

### Use Cases

**Recruitment & Sourcing**
- Build live feeds of new openings in a target city, province, or contract type
- Monitor competitor and agency postings across Flanders and Wallonia
- Track which roles a specific company is hiring for over time
- Pull student and internship listings for early-career pipelines

**Labor-Market Research**
- Map hiring demand by province, sector, and contract type across Belgium
- Measure how many roles appear in Dutch vs. French markets
- Track posting volume week over week with the "posted within" filter
- Analyze which job categories are growing in each region

**Lead Generation**
- Extract recruiter and company contact emails and phone numbers from ads
- Build outreach lists of companies actively hiring in your sector
- Identify employers posting freelance or contractor roles to pitch services
- Capture company profile and website links alongside each opening

**Relocation & Staffing**
- Surface roles in a candidate's target Belgian city or province
- Filter to the language region (Flanders/Wallonia) a candidate can work in
- Match candidates to permanent vs. temporary vs. freelance openings
- Feed structured listings into placement and ATS workflows

**Competitive & Salary Benchmarking**
- Collect openings for a job title across regions to compare demand
- Pull salary figures wherever Jobat exposes them for benchmarking
- Compare benefits and perks offered across competing employers
- Track contract-type mix (permanent vs. temporary) by sector

### Getting Started

#### Search by Keyword

The simplest way to start — one keyword, default settings:

```json
{
    "searchQueries": ["Software Developer"],
    "maxResults": 50
}
````

#### Filter by Region and Contract Type

Permanent jobs in Antwerp, posted in the last week:

```json
{
    "searchQueries": ["Verpleegkundige"],
    "province": "antwerpen",
    "contractType": "permanent",
    "datePosted": "7",
    "maxResults": 200
}
```

#### French (Wallonia) Search

Switch the language to capture Wallonia-only listings:

```json
{
    "searchQueries": ["Comptable"],
    "language": "fr",
    "location": "Liège",
    "maxResults": 150
}
```

#### Paste Jobat.be URLs

Reuse a search you've already filtered on the site, or target specific job pages:

```json
{
    "startUrls": [
        { "url": "https://www.jobat.be/nl/jobs/results/developer" },
        { "url": "https://www.jobat.be/nl/jobs/it-consultant/job_12345678" }
    ],
    "maxResults": 100
}
```

#### Full-Featured Example

```json
{
    "searchQueries": ["Data Engineer", "Software Developer"],
    "location": "Brussels",
    "province": "brussel",
    "contractType": "freelance",
    "datePosted": "30",
    "language": "nl",
    "maxResults": 500,
    "includeJobDetails": true
}
```

### Input Reference

#### Search

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `searchQueries` | array | `["Software Developer"]` | Job titles or keywords to search for (e.g. "Software Developer", "Verpleegkundige", "Comptable"). Each keyword runs a separate search; results are merged and de-duplicated. Up to 50 keywords per run. |
| `location` | string | `""` | A city or municipality in Belgium (e.g. "Brussels", "Antwerpen", "Gent", "Liège"). Leave empty to search all of Belgium. |
| `startUrls` | array | `[]` | Full Jobat.be search-result URLs and/or individual job-page URLs. Any filters baked into a search URL are collected exactly as-is. Up to 100 URLs per run. |

#### Filters & Limits

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `maxResults` | integer | `100` | Maximum number of jobs to collect per search keyword, up to 2,000. Use 50 for a quick scan or a higher number for deep research. |
| `province` | select | `Any` | Restrict results to one Belgian province (or the Brussels-Capital Region): Antwerp, East Flanders, West Flanders, Flemish Brabant, Limburg, Brussels-Capital Region, Walloon Brabant, Hainaut, Liège, Luxembourg, or Namur. |
| `contractType` | select | `Any` | Filter by contract type: Permanent, Temporary, Freelance, Internship, or Student job. |
| `datePosted` | select | `Any time` | Only show jobs published recently: Last 24 hours, Last 3 days, Last 7 days, or Last 30 days. |

#### Localization

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `language` | select | `Dutch (Flanders)` | Result language and regional version of Jobat.be: Dutch (Flanders) or French (Wallonia). |

#### Advanced

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `includeJobDetails` | boolean | `true` | Fetch the full description, contact details, and company profile from each job's detail page. Turn off for faster, lighter scans — the description, contact, and company-profile fields will then be empty. |

### Output

Each job is a single flat record. Here's a representative result with full details enabled:

```json
{
    "jobId": "12345678",
    "title": "Senior Software Developer",
    "company": "Tech Solutions NV",
    "location": "Antwerpen",
    "province": "Antwerp",
    "region": "Flanders",
    "contractType": "permanent",
    "employmentType": "Full-time",
    "category": "IT & Telecom",
    "salaryText": "€3,500 - €4,500 per month",
    "salaryMin": 3500,
    "salaryMax": 4500,
    "salaryCurrency": "EUR",
    "salaryPeriod": "month",
    "postedAt": "2026-06-08",
    "descriptionSnippet": "We are looking for an experienced developer to join our growing team...",
    "description": "We are looking for an experienced developer to join our growing team in Antwerp. You will design and build...",
    "benefits": ["Company car", "Meal vouchers", "Hospitalization insurance", "13th month"],
    "applyUrl": "https://www.jobat.be/nl/jobs/senior-software-developer/job_12345678",
    "applyEmail": "jobs@techsolutions.be",
    "contactPhone": "+32 3 123 45 67",
    "extractedEmails": ["jobs@techsolutions.be"],
    "extractedPhones": ["+32 3 123 45 67"],
    "extractedUrls": ["https://www.techsolutions.be/careers"],
    "companyUrl": "https://www.jobat.be/nl/bedrijven/tech-solutions-nv",
    "companyWebsite": "https://www.techsolutions.be",
    "jobUrl": "https://www.jobat.be/nl/jobs/senior-software-developer/job_12345678",
    "language": "nl",
    "searchQuery": "Software Developer",
    "scrapedAt": "2026-06-11T14:30:00Z"
}
```

#### Core Fields

| Field | Type | Description |
|-------|------|-------------|
| `jobId` | string | Jobat.be internal job identifier |
| `title` | string | Job title |
| `company` | string | Hiring company / employer name |
| `location` | string | Job location (city or municipality) |
| `province` | string | Belgian province label (e.g. "Antwerp") |
| `region` | string | Flanders, Wallonia, or Brussels |
| `contractType` | string | Permanent, temporary, freelance, internship, or student |
| `employmentType` | string | Full-time or part-time |
| `category` | string | Job function category / sector |
| `postedAt` | string | Publication date |
| `jobUrl` | string | Canonical Jobat.be job-posting URL |

#### Description & Benefits

| Field | Type | Description |
|-------|------|-------------|
| `descriptionSnippet` | string | Short description teaser from the list |
| `description` | string | Full job description text (when details are on) |
| `benefits` | array | Listed benefits and perks (when shown) |

#### Salary

Jobat hides salary on most Belgian ads — these fields populate whenever it's exposed.

| Field | Type | Description |
|-------|------|-------------|
| `salaryText` | string | Raw salary text as shown on the ad |
| `salaryMin` | number | Parsed minimum salary |
| `salaryMax` | number | Parsed maximum salary |
| `salaryCurrency` | string | Salary currency (EUR) |
| `salaryPeriod` | string | Salary period (month, year, or hour) |

#### Contact & Company

| Field | Type | Description |
|-------|------|-------------|
| `applyUrl` | string | Public job-posting URL to apply through |
| `applyEmail` | string | Apply / contact email |
| `contactPhone` | string | Contact phone number (when shown) |
| `extractedEmails` | array | Emails parsed from the job ad |
| `extractedPhones` | array | Phone numbers parsed from the job ad |
| `extractedUrls` | array | URLs parsed from the job ad |
| `companyUrl` | string | Jobat.be company profile URL |
| `companyWebsite` | string | Employer's own website (when shown) |

#### Metadata

| Field | Type | Description |
|-------|------|-------------|
| `language` | string | Result language (`nl` or `fr`) |
| `searchQuery` | string | The search keyword that produced this row |
| `scrapedAt` | string | ISO timestamp when the row was collected |

### Tips for Best Results

- **Start small** — set `maxResults` to 50 on your first run to confirm the data matches your needs, then scale up for deep research.
- **Switch language to French to capture Wallonia-only listings** — many French-language jobs in Wallonia never appear on the Dutch site, so run both `nl` and `fr` to cover all of Belgium.
- **Paste a filtered Jobat.be search URL to reuse facets we don't expose as inputs** — dial in any advanced filter on the website, copy the URL into `startUrls`, and it's collected exactly as you set it.
- **Turn off `includeJobDetails` for fast counting** — when you only need titles, companies, and locations, leave details off for quicker, lighter runs; turn it on for full descriptions, benefits, and contacts.
- **Use the "posted within" filter for daily monitoring** — set `datePosted` to Last 24 hours on a scheduled run to capture only brand-new openings.
- **Combine multiple keywords in one run** — list several job titles in `searchQueries`; each is searched separately and overlapping results are de-duplicated automatically.
- **Don't rely on salary being present** — most Belgian employers omit it on Jobat, so treat `salaryMin`/`salaryMax` as a bonus rather than a guarantee.

### Pricing

**From $0.95 per 1,000 results** — among the lowest-priced Belgian job-board scrapers on the platform. Bronze, Silver, and Gold subscribers pay progressively less; the table below shows total cost at each discount tier.

| Results | No discount | Bronze | Silver | Gold |
|---------|-------------|--------|--------|------|
| 100 | $0.11 | $0.105 | $0.10 | $0.095 |
| 1,000 | $1.10 | $1.05 | $1.00 | $0.95 |
| 10,000 | $11.00 | $10.50 | $10.00 | $9.50 |
| 100,000 | $110.00 | $105.00 | $100.00 | $95.00 |

A "result" is any job row in the output dataset. No compute or time-based charges — you pay per result, plus a small fixed per-run start fee.

### Integrations

Export data in JSON, CSV, Excel, XML, or RSS. Connect to 1,500+ apps via:

- **Zapier** / **Make** / **n8n** — Workflow automation
- **Google Sheets** — Direct spreadsheet export
- **Slack** / **Email** — Notifications on new results
- **Webhooks** — Trigger custom APIs on run completion
- **Apify API** — Full programmatic access

### Legal & Ethical Use

This actor is designed for legitimate recruitment research, labor-market analysis, and lead generation. You are responsible for complying with applicable laws — including GDPR and Belgian data-protection rules — and with Jobat.be's Terms of Service. Do not use extracted data for spam, harassment, or any unlawful purpose, and handle any personal data (such as contact details) lawfully and responsibly.

# Actor input Schema

## `searchQueries` (type: `array`):

Job titles or keywords to search for, such as 'Software Developer', 'Verpleegkundige', or 'Comptable'. Each keyword runs a separate search and results are merged and de-duplicated. Up to 50 keywords per run. Leave empty if you only want to use direct Jobat.be URLs below.

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

A city or municipality in Belgium, such as 'Brussels', 'Antwerpen', 'Gent', or 'Liège'. Leave empty to search all of Belgium.

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

Paste full Jobat.be search-result URLs (for example https://www.jobat.be/nl/jobs/results/developer) and/or individual job-page URLs. Any filters baked into a search URL are scraped exactly as-is. Useful when you have already dialed in a search on the Jobat.be website. Up to 100 URLs per run.

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

Maximum number of jobs to collect per search keyword (up to 2,000). Use 50 for a quick scan or a higher number for deep research. The last page is always kept in full, so the final count can slightly overshoot this number.

## `province` (type: `string`):

Restrict results to a single Belgian province (or the Brussels-Capital Region). Leave on 'Any' to include all provinces.

## `contractType` (type: `string`):

Filter by contract type. Leave on 'Any' for all types.

## `datePosted` (type: `string`):

Only show jobs published within this time period.

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

Result language and site region. Jobat.be serves Dutch listings for Flanders and French listings for Wallonia.

## `includeJobDetails` (type: `boolean`):

Fetch the full description, contact details, and company profile from each job's detail page. Leave on for the richest data. Turn off for faster, lighter scans — the description, contact, and company-profile fields will then be empty.

## Actor input object example

```json
{
  "searchQueries": [
    "Software Developer"
  ],
  "startUrls": [],
  "maxResults": 100,
  "province": "",
  "contractType": "",
  "datePosted": "",
  "language": "nl",
  "includeJobDetails": true
}
```

# Actor output Schema

## `overview` (type: `string`):

Table of scraped job listings with key fields.

## `detail` (type: `string`):

Complete job records including descriptions, salary, contact details, and company profile.

# 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 = {
    "searchQueries": [
        "Software Developer"
    ],
    "location": "",
    "startUrls": [],
    "maxResults": 100,
    "province": "",
    "contractType": "",
    "datePosted": "",
    "language": "nl",
    "includeJobDetails": false
};

// Run the Actor and wait for it to finish
const run = await client.actor("solidcode/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 = {
    "searchQueries": ["Software Developer"],
    "location": "",
    "startUrls": [],
    "maxResults": 100,
    "province": "",
    "contractType": "",
    "datePosted": "",
    "language": "nl",
    "includeJobDetails": False,
}

# Run the Actor and wait for it to finish
run = client.actor("solidcode/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 '{
  "searchQueries": [
    "Software Developer"
  ],
  "location": "",
  "startUrls": [],
  "maxResults": 100,
  "province": "",
  "contractType": "",
  "datePosted": "",
  "language": "nl",
  "includeJobDetails": false
}' |
apify call solidcode/jobat-be-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Jobat.be Scraper",
        "description": "[💰 $0.95 / 1K] Extract job listings from Jobat.be, one of Belgium's largest job boards. Search by keyword, location, and province in Dutch (Flanders) or French (Wallonia) to get titles, companies, salaries, contract types, descriptions, contacts, and apply links.",
        "version": "1.0",
        "x-build-id": "Srg2CbTaaoObCKXdo"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/solidcode~jobat-be-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-solidcode-jobat-be-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/solidcode~jobat-be-scraper/runs": {
            "post": {
                "operationId": "runs-sync-solidcode-jobat-be-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/solidcode~jobat-be-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-solidcode-jobat-be-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": {
                    "searchQueries": {
                        "title": "Search Keywords",
                        "maxItems": 50,
                        "type": "array",
                        "description": "Job titles or keywords to search for, such as 'Software Developer', 'Verpleegkundige', or 'Comptable'. Each keyword runs a separate search and results are merged and de-duplicated. Up to 50 keywords per run. Leave empty if you only want to use direct Jobat.be URLs below.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "A city or municipality in Belgium, such as 'Brussels', 'Antwerpen', 'Gent', or 'Liège'. Leave empty to search all of Belgium."
                    },
                    "startUrls": {
                        "title": "Direct Jobat.be URLs",
                        "maxItems": 100,
                        "type": "array",
                        "description": "Paste full Jobat.be search-result URLs (for example https://www.jobat.be/nl/jobs/results/developer) and/or individual job-page URLs. Any filters baked into a search URL are scraped exactly as-is. Useful when you have already dialed in a search on the Jobat.be website. Up to 100 URLs per run.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxResults": {
                        "title": "Max Results per Search",
                        "minimum": 1,
                        "maximum": 2000,
                        "type": "integer",
                        "description": "Maximum number of jobs to collect per search keyword (up to 2,000). Use 50 for a quick scan or a higher number for deep research. The last page is always kept in full, so the final count can slightly overshoot this number.",
                        "default": 100
                    },
                    "province": {
                        "title": "Province",
                        "enum": [
                            "",
                            "antwerpen",
                            "oost-vlaanderen",
                            "west-vlaanderen",
                            "vlaams-brabant",
                            "limburg",
                            "brussel",
                            "waals-brabant",
                            "henegouwen",
                            "luik",
                            "luxemburg",
                            "namen"
                        ],
                        "type": "string",
                        "description": "Restrict results to a single Belgian province (or the Brussels-Capital Region). Leave on 'Any' to include all provinces.",
                        "default": ""
                    },
                    "contractType": {
                        "title": "Contract Type",
                        "enum": [
                            "",
                            "permanent",
                            "temporary",
                            "freelance",
                            "internship",
                            "student"
                        ],
                        "type": "string",
                        "description": "Filter by contract type. Leave on 'Any' for all types.",
                        "default": ""
                    },
                    "datePosted": {
                        "title": "Posted Within",
                        "enum": [
                            "",
                            "1",
                            "3",
                            "7",
                            "30"
                        ],
                        "type": "string",
                        "description": "Only show jobs published within this time period.",
                        "default": ""
                    },
                    "language": {
                        "title": "Language",
                        "enum": [
                            "nl",
                            "fr"
                        ],
                        "type": "string",
                        "description": "Result language and site region. Jobat.be serves Dutch listings for Flanders and French listings for Wallonia.",
                        "default": "nl"
                    },
                    "includeJobDetails": {
                        "title": "Fetch Full Job Details",
                        "type": "boolean",
                        "description": "Fetch the full description, contact details, and company profile from each job's detail page. Leave on for the richest data. Turn off for faster, lighter scans — the description, contact, and company-profile fields will then be empty.",
                        "default": true
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
