# Werk.nl Scraper $1💰 Dutch Job Vacancies, Salaries & Contacts (`abotapi/werk-nl-scraper`) Actor

From $1/1K. Scrape job vacancies from werk.nl, the official Dutch government job board by UWV. Uses werk.nl’s vacancy data service for fast, low-cost runs. Returns 40+ fields per job, including title, salary, full description, recruiter contact, application link, and employer profile.

- **URL**: https://apify.com/abotapi/werk-nl-scraper.md
- **Developed by:** [AbotAPI](https://apify.com/abotapi) (community)
- **Categories:** Jobs, Automation, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

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

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

## werk.nl Scraper - Dutch Jobs, Salaries, Recruiters & Employers

Scrape job vacancies from **werk.nl**, the official Dutch government job board run by UWV (250,000+ live vacancies). This actor talks directly to werk.nl's own vacancy data service - no browser - so it is fast, cheap, and returns **40+ structured fields per vacancy**, including data the website only shows on the detail page: the full description, salary, **recruiter contact (name, phone, e-mail)**, the application link, and the complete employer profile.

### Why this scraper

| | This actor | Typical werk.nl scrapers |
|---|---|---|
| Approach | Direct data API (no browser) | Browser / HTML scraping |
| Fields per vacancy | 40+ | ~15-25 |
| Recruiter contact (name/phone/e-mail) | ✅ | partial / ✅ |
| Salary, contract, hours, full address | ✅ | partial |
| Apprenticeship / internship / EURES flags | ✅ | ❌ |
| Proxy cost | **Datacenter-friendly (lowest)** | Residential-only |
| Handles the site's daily maintenance window | ✅ (won't emit junk) | ❌ |

### What you get (per vacancy)

- **Identity:** `referenceNumber`, `url`, `externalReferenceId`, `source`
- **Core:** `title`, `profession`, `relevanceScore`
- **Dates:** `createdDate`, `modifiedDate`, `expirationDate`
- **Location:** `city`, `postcode`, `workLocationType`, `countryCode`, `foreignCountry`, `distanceKm`
- **Employment:** `contractType`, `contractStartDate`/`EndDate`, `minHours`, `maxHours`, `studyLevel`
- **Salary:** `salaryIndication`, `termsOfEmployment`
- **Description:** `description` (plain text) + `descriptionHtml`
- **Flags:** `isApprenticeship`, `isInternship`, `isEuresPriority`, `isByEmployerDirectly`
- **Employer:** `organisation` + `employer` object (name, website, sector, full address)
- **Recruiter contact:** `contact` object (name, department, phone, e-mail)
- **Apply:** `applicationMethods` + `applyUrl`

Enable **Include raw detail payload** to also attach the untouched source record under `raw`.

### Input

#### Search mode (default)

```json
{
  "mode": "search",
  "keywords": ["developer"],
  "location": "Amsterdam",
  "contractType": ["1"],
  "educationLevels": ["5", "6"],
  "sortBy": "date",
  "fetchDetails": true,
  "maxItems": 50,
  "proxy": { "useApifyProxy": true }
}
````

Filters available: **profession** (e.g. `"Frontend developer"`), **educationLevels** (1-7), **hoursPerWeek** (1-6), **workingHours** (1-2), **drivingLicense** (A/B/C/CE/AM), **language**, **contractType** (1=permanent, 2=possibly permanent, 3=temporary) and **country**. One search is run per keyword; leave `keywords` empty to list everything (optionally narrowed by the filters).

#### URL mode

Fetch specific vacancies by detail-page URL or bare reference number:

```json
{
  "mode": "url",
  "urls": [
    "https://www.werk.nl/nl/vacatures/67353746",
    "69750687"
  ]
}
```

#### Key options

| Option | Default | Description |
|---|---|---|
| `fetchDetails` | `true` | Include each vacancy's full detail: complete description, salary, contact and employer profile. Turn off for a faster listing-only run. |
| `maxItems` | `20` | Max vacancies across all searches — the run's hard cap (0 = no limit). |
| `maxPagesPerSearch` | - | Optional secondary cap on result pages (20 each) per keyword; empty by default so `maxItems` is the binding cap. |
| `includeRawDetail` | `false` | Attach the raw source payload under `raw`. |
| `residentialCap` | `0` | Cost guard: max residential sessions used if the run auto-escalates from datacenter (0 = unlimited). |

### Send results into your apps (MCP connectors)

Optionally pipe the scraped results into the apps you already use, via Model Context Protocol (MCP) connectors. This is an extra delivery step **after** the scrape — the Apify dataset is never changed.

**What gets written to the connector:** a condensed, human-readable **summary** of each record — not the full JSON. Each item becomes one entry with a **title** and its key fields flattened to plain text. The **complete record always stays in the Apify dataset**.

1. Authorize a connector once under **Apify → Settings → Integrations** (Notion, Linear, Airtable, or Apify).
2. Select it in the **"Pipe results into your apps"** input field. (If the picker is empty, you haven't authorized a connector yet.)
3. For **Notion**, also set `notionParentPageUrl` to the page where items should be created.

The connection is mediated by Apify's MCP proxy, so this actor never sees your third-party credentials. Leave the field empty to skip.

### Proxy & cost

For reliability the actor keeps each worker on a consistent IP and automatically retries on a different one if a request is refused.

- **Datacenter (default)** - the cheapest option and the verified happy path. Recommended for most runs.
- **Residential (Netherlands)** - pick this for maximum reliability. The actor also **auto-escalates** to residential (with country rotation: NL → BE → DE) only when datacenter is being refused, then **downgrades back** to datacenter when it recovers - so you pay residential rates only when you have to.
- A last-resort failover route is used if both are unavailable.

> Free-tier accounts: enable **Apify Proxy** (the included datacenter allowance works). Without a proxy, requests to werk.nl are refused.

### Reliability

werk.nl has a short daily maintenance window during which every page returns a placeholder. The actor **detects this** and backs off / retries instead of silently reporting zero results.

### Notes

This actor collects only publicly available vacancy information. Vacancy contact details are published by employers on the public vacancy pages for the purpose of applications. Use the data in line with werk.nl's terms and applicable privacy law.

# Actor input Schema

## `mode` (type: `string`):

search = find vacancies by keyword/location/filters. url = fetch specific vacancy detail pages by URL or reference number.

## `keywords` (type: `array`):

Search term(s) - job title, profession, keyword(s) or a reference number. One search is run per keyword. Leave empty to list all vacancies (optionally narrowed by the filters below).

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

City or postcode to search in (e.g. 'Amsterdam' or '1011AB'). Leave empty for the whole of the Netherlands.

## `profession` (type: `array`):

Profession category filter, e.g. 'Developer', 'Software engineer', 'Verpleegkundige'. Values must match werk.nl's profession names.

## `educationLevels` (type: `array`):

Required education level.

## `hoursPerWeek` (type: `array`):

Working hours per week.

## `workingHours` (type: `array`):

Office hours or otherwise.

## `drivingLicense` (type: `array`):

Required driving licence category.

## `language` (type: `array`):

Required language skill.

## `contractType` (type: `array`):

Type of employment contract.

## `country` (type: `array`):

Country of the work location (for EURES / cross-border vacancies).

## `sortBy` (type: `string`):

Result ordering.

## `expandResults` (type: `boolean`):

Broaden the search to include related vacancies when there are few exact matches (werk.nl's 'verruim zoekopdracht').

## `urls` (type: `array`):

URL mode only: vacancy detail-page URLs (e.g. https://www.werk.nl/nl/vacatures/67353746) or bare reference numbers.

## `fetchDetails` (type: `boolean`):

Include each vacancy's full detail: complete description, salary, recruiter contact (name/phone/e-mail), application method and complete employer profile. Turn off for a faster, listing-only run.

## `includeRawDetail` (type: `boolean`):

Attach the untouched detail JSON under a 'raw' field on each record (for advanced users who want every backend field).

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

Maximum number of vacancies to return across all searches. This is the run's hard cap (default 20). Set to 0 for no limit.

## `maxPagesPerSearch` (type: `integer`):

Optional secondary cap on result pages (20 vacancies each) per keyword. Leave empty (the default) to page freely until Max vacancies is reached — Max vacancies is the binding cap.

## `residentialCap` (type: `integer`):

Cost guard: maximum number of residential-proxy sessions the run may use when it auto-escalates from datacenter. 0 = unlimited. Has no effect when you don't use residential proxy.

## `proxy` (type: `object`):

Datacenter (the default) is the cheapest and is the verified happy path; the actor auto-escalates to residential only if datacenter is refused. For maximum reliability pick Residential with country Netherlands.

## `mcpConnectors` (type: `array`):

Optionally send the scraped results into the apps you already use, via Model Context Protocol (MCP) connectors. Authorize a connector once under Apify → Settings → Integrations, then select it here. The connector receives a condensed, human-readable summary per item (title + key fields), not the full JSON — the complete record stays in the dataset. Leave empty to skip. Supported: Notion (https://mcp.notion.com/mcp), Linear (https://mcp.linear.app/sse), Airtable (https://mcp.airtable.com/mcp), Apify (https://mcp.apify.com).

## `notionParentPageUrl` (type: `string`):

URL (or id) of the Notion page under which item pages are created. Required to enable the Notion export; ignored by other connectors.

## `maxNotifyListings` (type: `integer`):

Cap on items written to each connector per run. Does not affect the dataset.

## Actor input object example

```json
{
  "mode": "search",
  "keywords": [
    "developer"
  ],
  "sortBy": "relevance",
  "expandResults": false,
  "fetchDetails": true,
  "includeRawDetail": false,
  "maxItems": 20,
  "residentialCap": 0,
  "proxy": {
    "useApifyProxy": true
  },
  "maxNotifyListings": 50
}
```

# 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 = {
    "mode": "search",
    "keywords": [
        "developer"
    ],
    "maxItems": 20,
    "proxy": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("abotapi/werk-nl-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 = {
    "mode": "search",
    "keywords": ["developer"],
    "maxItems": 20,
    "proxy": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("abotapi/werk-nl-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 '{
  "mode": "search",
  "keywords": [
    "developer"
  ],
  "maxItems": 20,
  "proxy": {
    "useApifyProxy": true
  }
}' |
apify call abotapi/werk-nl-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Werk.nl Scraper $1💰 Dutch Job Vacancies, Salaries & Contacts",
        "description": "From $1/1K. Scrape job vacancies from werk.nl, the official Dutch government job board by UWV. Uses werk.nl’s vacancy data service for fast, low-cost runs. Returns 40+ fields per job, including title, salary, full description, recruiter contact, application link, and employer profile.",
        "version": "1.0",
        "x-build-id": "L73oTSgsQextKohgs"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/abotapi~werk-nl-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-abotapi-werk-nl-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/abotapi~werk-nl-scraper/runs": {
            "post": {
                "operationId": "runs-sync-abotapi-werk-nl-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/abotapi~werk-nl-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-abotapi-werk-nl-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": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "search",
                            "url"
                        ],
                        "type": "string",
                        "description": "search = find vacancies by keyword/location/filters. url = fetch specific vacancy detail pages by URL or reference number.",
                        "default": "search"
                    },
                    "keywords": {
                        "title": "Keywords",
                        "type": "array",
                        "description": "Search term(s) - job title, profession, keyword(s) or a reference number. One search is run per keyword. Leave empty to list all vacancies (optionally narrowed by the filters below).",
                        "items": {
                            "type": "string"
                        }
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "City or postcode to search in (e.g. 'Amsterdam' or '1011AB'). Leave empty for the whole of the Netherlands."
                    },
                    "profession": {
                        "title": "Profession (Beroep)",
                        "type": "array",
                        "description": "Profession category filter, e.g. 'Developer', 'Software engineer', 'Verpleegkundige'. Values must match werk.nl's profession names.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "educationLevels": {
                        "title": "Education level",
                        "type": "array",
                        "description": "Required education level.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "1",
                                "2",
                                "3",
                                "4",
                                "5",
                                "6",
                                "7"
                            ],
                            "enumTitles": [
                                "Basisonderwijs",
                                "VMBO",
                                "Havo/VWO",
                                "MBO",
                                "HBO/bachelor",
                                "WO/master",
                                "WO/doctor"
                            ]
                        }
                    },
                    "hoursPerWeek": {
                        "title": "Hours per week",
                        "type": "array",
                        "description": "Working hours per week.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "1",
                                "2",
                                "3",
                                "4",
                                "5",
                                "6"
                            ],
                            "enumTitles": [
                                "0 - 8 hours",
                                "9 - 16 hours",
                                "17 - 24 hours",
                                "25 - 32 hours",
                                "33 - 40 hours",
                                "40+ hours"
                            ]
                        }
                    },
                    "workingHours": {
                        "title": "Working hours type",
                        "type": "array",
                        "description": "Office hours or otherwise.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "1",
                                "2"
                            ],
                            "enumTitles": [
                                "Kantoortijden (office hours)",
                                "Anders (other)"
                            ]
                        }
                    },
                    "drivingLicense": {
                        "title": "Driving licence",
                        "type": "array",
                        "description": "Required driving licence category.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "A",
                                "B",
                                "C",
                                "CE",
                                "AM"
                            ],
                            "enumTitles": [
                                "A",
                                "B",
                                "C",
                                "CE",
                                "AM"
                            ]
                        }
                    },
                    "language": {
                        "title": "Language",
                        "type": "array",
                        "description": "Required language skill.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "Nederlands",
                                "Duits",
                                "Engels",
                                "Frans",
                                "Spaans",
                                "Turks",
                                "Japans",
                                "Fries",
                                "Nedersaksisch"
                            ],
                            "enumTitles": [
                                "Dutch",
                                "German",
                                "English",
                                "French",
                                "Spanish",
                                "Turkish",
                                "Japanese",
                                "Frisian",
                                "Low Saxon"
                            ]
                        }
                    },
                    "contractType": {
                        "title": "Contract type",
                        "type": "array",
                        "description": "Type of employment contract.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "1",
                                "2",
                                "3"
                            ],
                            "enumTitles": [
                                "Vast (permanent)",
                                "Mogelijk vast (possibly permanent)",
                                "Tijdelijk (temporary)"
                            ]
                        }
                    },
                    "country": {
                        "title": "Country",
                        "type": "array",
                        "description": "Country of the work location (for EURES / cross-border vacancies).",
                        "items": {
                            "type": "string",
                            "enum": [
                                "NL",
                                "BE",
                                "DE",
                                "FR",
                                "ES",
                                "IT",
                                "GB",
                                "NO"
                            ],
                            "enumTitles": [
                                "Netherlands",
                                "Belgium",
                                "Germany",
                                "France",
                                "Spain",
                                "Italy",
                                "United Kingdom",
                                "Norway"
                            ]
                        }
                    },
                    "sortBy": {
                        "title": "Sort by",
                        "enum": [
                            "relevance",
                            "date"
                        ],
                        "type": "string",
                        "description": "Result ordering.",
                        "default": "relevance"
                    },
                    "expandResults": {
                        "title": "Expand results",
                        "type": "boolean",
                        "description": "Broaden the search to include related vacancies when there are few exact matches (werk.nl's 'verruim zoekopdracht').",
                        "default": false
                    },
                    "urls": {
                        "title": "Vacancy URLs / reference numbers",
                        "type": "array",
                        "description": "URL mode only: vacancy detail-page URLs (e.g. https://www.werk.nl/nl/vacatures/67353746) or bare reference numbers.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "fetchDetails": {
                        "title": "Fetch full vacancy details",
                        "type": "boolean",
                        "description": "Include each vacancy's full detail: complete description, salary, recruiter contact (name/phone/e-mail), application method and complete employer profile. Turn off for a faster, listing-only run.",
                        "default": true
                    },
                    "includeRawDetail": {
                        "title": "Include raw detail payload",
                        "type": "boolean",
                        "description": "Attach the untouched detail JSON under a 'raw' field on each record (for advanced users who want every backend field).",
                        "default": false
                    },
                    "maxItems": {
                        "title": "Max vacancies",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of vacancies to return across all searches. This is the run's hard cap (default 20). Set to 0 for no limit.",
                        "default": 20
                    },
                    "maxPagesPerSearch": {
                        "title": "Max pages per search",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Optional secondary cap on result pages (20 vacancies each) per keyword. Leave empty (the default) to page freely until Max vacancies is reached — Max vacancies is the binding cap."
                    },
                    "residentialCap": {
                        "title": "Residential session budget",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Cost guard: maximum number of residential-proxy sessions the run may use when it auto-escalates from datacenter. 0 = unlimited. Has no effect when you don't use residential proxy.",
                        "default": 0
                    },
                    "proxy": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Datacenter (the default) is the cheapest and is the verified happy path; the actor auto-escalates to residential only if datacenter is refused. For maximum reliability pick Residential with country Netherlands.",
                        "default": {
                            "useApifyProxy": true
                        }
                    },
                    "mcpConnectors": {
                        "title": "Pipe results into your apps (optional)",
                        "type": "array",
                        "description": "Optionally send the scraped results into the apps you already use, via Model Context Protocol (MCP) connectors. Authorize a connector once under Apify → Settings → Integrations, then select it here. The connector receives a condensed, human-readable summary per item (title + key fields), not the full JSON — the complete record stays in the dataset. Leave empty to skip. Supported: Notion (https://mcp.notion.com/mcp), Linear (https://mcp.linear.app/sse), Airtable (https://mcp.airtable.com/mcp), Apify (https://mcp.apify.com)."
                    },
                    "notionParentPageUrl": {
                        "title": "Notion parent page (Notion connector only)",
                        "type": "string",
                        "description": "URL (or id) of the Notion page under which item pages are created. Required to enable the Notion export; ignored by other connectors."
                    },
                    "maxNotifyListings": {
                        "title": "Max items to export per connector",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Cap on items written to each connector per run. Does not affect the dataset.",
                        "default": 50
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
