# Randstad Jobs Scraper (`solidcode/randstad-scraper`) Actor

\[💰 $0.95 / 1K] Extract job listings from Randstad worldwide. Search by keyword, country, specialism, and job type, or paste Randstad URLs directly. Get structured data: titles, salaries, locations, employment type, hiring company, descriptions, and apply links.

- **URL**: https://apify.com/solidcode/randstad-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

## Randstad Jobs Scraper

Pull job listings from Randstad.com worldwide — titles, salaries, locations, employment types, posting dates, vacancy numbers, hiring-company details, and full job descriptions with skills, qualifications, and education requirements. One clean row per vacancy across 27 countries and 24 specialisms. Built for recruiters, job-market analysts, and staffing competitors who need structured Randstad data without hand-crafting search links or wrestling with one job page at a time.

### Why This Scraper?

- **27-country coverage in one run** — Argentina to the UK, the Netherlands to Japan; pick a country or leave it open to collect Randstad's global inventory worldwide.
- **No URL crafting required** — search by plain keyword plus dropdowns for country, specialism, job type, and language. Type "developer" and go, or paste any Randstad search or job URL when you already have a search dialed in.
- **24 job specialisms to filter by** — Accounting, Banking, Engineering, Information Technology, Health & Social Care, Legal, Sales, Warehousing & Distribution, and 16 more.
- **4 employment types** — permanent, contract, temporary, or freelance, filterable on their own or combined with any specialism.
- **Salary fields parsed and currency-normalized** — separate minimum, maximum, and pay-period values, each tagged with a real ISO currency code (GBP, EUR, AUD, CAD, NZD, INR, CHF, SGD, and more) resolved correctly across all 27 markets — never a raw internal number.
- **14 listing languages** — restrict results to English, French, German, Dutch, Japanese, Chinese, Polish, and 7 more for clean, language-targeted datasets.
- **Full job descriptions included by default** — every run adds the complete posting text plus skills, qualifications, education, experience requirements, the hiring company's website, and the exact street address. Switch them off for faster, leaner list-only runs when you don't need the extra detail.
- **Reference number on every row** — each job carries its Randstad vacancy number plus a direct apply URL, so postings stay traceable and deduplicate cleanly across overlapping searches.

### Use Cases

**Recruitment Intelligence**
- Track which roles a staffing leader is actively hiring for across regions
- Monitor new vacancy volume by specialism week over week
- Spot hiring surges in a target country before competitors react
- Build a live feed of open roles matching your candidate pool

**Competitive & Market Research**
- Benchmark Randstad's open-role mix against your own job board
- Map demand for a skill (e.g. "data engineer") across 27 countries
- Compare permanent vs. contract vs. temporary posting ratios by market
- Track posting dates to measure how fast roles are filled or refreshed

**Salary Benchmarking**
- Pull minimum/maximum salary bands by role, city, and currency
- Compare pay periods (hourly, monthly, yearly) across markets
- Build region-by-region compensation tables in normalized ISO currencies
- Validate offer ranges against live market postings

**Talent Sourcing & Lead Generation**
- Collect apply URLs and reference numbers for outreach workflows
- Identify hiring companies, their websites, and office locations
- Filter to one specialism and language for targeted candidate campaigns
- Feed fresh vacancies into an ATS or CRM automatically

### Getting Started

#### Simple Keyword Search

The quickest way to start — one keyword, worldwide, with full descriptions on by default:

```json
{
    "searchQueries": ["developer"],
    "maxItems": 100
}
````

#### Keyword with Country and Job Type

Narrow to permanent IT-adjacent roles in the United Kingdom:

```json
{
    "searchQueries": ["nurse"],
    "country": "united-kingdom",
    "jobType": "permanent",
    "maxItems": 200
}
```

#### Paste a Randstad Search URL

Mirror exactly what you see in the browser — any filters baked into the URL are respected:

```json
{
    "startUrls": ["https://www.randstad.com/jobs/united-kingdom/q-developer/"],
    "maxItems": 150
}
```

#### Faster List-Only Run

Turn full descriptions off for a quicker, lighter sweep — you still get every result-list field including a short description preview:

```json
{
    "searchQueries": ["engineer"],
    "country": "canada",
    "maxItems": 500,
    "includeDescription": false
}
```

#### Full Options

Every filter set, descriptions on, deduplication on:

```json
{
    "searchQueries": ["engineer", "project manager"],
    "country": "canada",
    "category": "engineering",
    "jobType": "contract",
    "language": "english",
    "maxItems": 500,
    "onlyUniqueJobs": true,
    "includeDescription": true
}
```

### Input Reference

#### What to Search

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `searchQueries` | array | `["developer"]` | Job titles, roles, or keywords. Each keyword runs its own search. Leave empty for the broadest result set. Up to 50 keywords per run. |
| `startUrls` | array | `[]` | Paste full Randstad search-result or individual job URLs to scrape directly. Filters baked into the URL are respected. Up to 50 URLs per run. |

#### Filters

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `country` | string | `""` (Any) | Which country's jobs to search — one of 27 supported countries. Leave on "Any country" to search worldwide. |
| `category` | string | `""` (Any) | Limit results to one of 24 job specialisms (the field of work). Leave on "Any" for all categories. |
| `jobType` | string | `""` (Any) | Limit to one employment type: Permanent, Contract, Temporary, or Freelance. Leave on "Any" for all. |
| `language` | string | `""` (Any) | Only return listings in one of 14 supported languages. Leave on "Any" for all languages. |

#### Output Control

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `maxItems` | integer | `100` | Maximum job listings to collect across all searches and URLs. Set to 0 for all available results. Results come in pages — the full final page is always kept, so a small cap can return a few extra. |
| `onlyUniqueJobs` | boolean | `true` | Return each job once even if it appears across several searches or pages. Deduplicates by vacancy number / URL. Turn off to keep every copy. |
| `includeDescription` | boolean | `true` | When on, opens each job page to add the full description plus skills, qualifications, education, experience, company website, and street address. Off is faster and lighter — you still get every list field, including a short description preview. |

### Output

Every job is one flat row. With full descriptions on, each row also carries the enriched detail fields shown below.

```json
{
    "title": "PHP Developer",
    "vacancyNumber": "90M0512345",
    "companyName": "Randstad Technologies",
    "companyLogoUrl": "https://www.randstad.com/.../logo.png",
    "companyWebsite": "https://www.example-employer.com",
    "city": "Sydney",
    "region": "New South Wales",
    "country": "Australia",
    "postalCode": "2000",
    "streetAddress": "Sydney CBD",
    "salary": "700 - 850 DAY",
    "salaryMin": 700,
    "salaryMax": 850,
    "salaryCurrency": "AUD",
    "salaryPeriod": "DAY",
    "employmentType": "Contract",
    "workHours": "Full-time",
    "category": "Information Technology",
    "datePosted": "2026-05-28",
    "description": "We are seeking an experienced PHP Developer to join...",
    "skills": ["PHP Developer", "Laravel", "MySQL"],
    "qualifications": "Bachelor's degree in Computer Science or equivalent",
    "education": "Bachelor's degree",
    "experience": "5+ years",
    "jobUrl": "https://www.randstad.com/jobs/php-developer_sydney_90M0512345/",
    "searchQuery": "php developer",
    "scrapedAt": "2026-06-04T10:15:00Z"
}
```

#### Core Fields

| Field | Type | Description |
|-------|------|-------------|
| `title` | string | Job title. |
| `vacancyNumber` | string | Randstad vacancy / reference number (deduplication key). |
| `employmentType` | string | Permanent, Contract, Temporary, or Freelance. |
| `workHours` | string | Hours / schedule text (e.g. full-time, 38h). |
| `category` | string | Specialism / job category. |
| `datePosted` | string | Date the job was posted. |
| `jobUrl` | string | Canonical URL of the job detail page. |
| `searchQuery` | string | The keyword that produced this row. |
| `scrapedAt` | string | Timestamp when the row was collected. |

#### Location

| Field | Type | Description |
|-------|------|-------------|
| `city` | string | Job city. |
| `region` | string | Region / state / province. |
| `country` | string | Country. |
| `postalCode` | string | Postal / ZIP code. |
| `streetAddress` | string | Street address when disclosed (full descriptions only). |

#### Salary

| Field | Type | Description |
|-------|------|-------------|
| `salary` | string | Human-readable salary text as shown. |
| `salaryMin` | number | Parsed minimum salary. |
| `salaryMax` | number | Parsed maximum salary. |
| `salaryCurrency` | string | ISO currency code (GBP, EUR, AUD, CAD, …). |
| `salaryPeriod` | string | Pay period (hour, day, month, year). |

#### Company

| Field | Type | Description |
|-------|------|-------------|
| `companyName` | string | Hiring organization name. |
| `companyLogoUrl` | string | Hiring organization logo URL. |
| `companyWebsite` | string | Hiring organization website (full descriptions only). |

#### Full-Description Fields

These populate when **Fetch Full Job Descriptions** is on.

| Field | Type | Description |
|-------|------|-------------|
| `description` | string | Full job description text (a short preview is included even when off). |
| `descriptionHtml` | string | Job description in original HTML. |
| `skills` | array | Skills / requirement bullets. |
| `qualifications` | string | Qualifications section. |
| `education` | string | Education requirements. |
| `experience` | string | Experience requirements. |

### Tips for Best Results

- **Turn full descriptions off when a list-level dataset is enough.** They're on by default and give you the richest output, but skills, qualifications, education, company website, and street address all require opening each job page, which makes runs slower — switch them off for a faster, lighter sweep.
- **Paste a filtered Randstad search URL to mirror exactly what you see in the browser.** Any country, keyword, or specialism baked into the URL is respected, so you get the same result set you previewed on the site.
- **List one keyword per role you care about.** Each keyword in `searchQueries` runs its own search, so "developer", "nurse", "welder" pulls three distinct result sets in a single run — up to 50 keywords.
- **Set `maxItems` to 0 only for a full sweep.** A bounded cap keeps runs fast and predictable; unbounded runs exhaust every page for the chosen filters.
- **Keep `onlyUniqueJobs` on when combining keywords or URLs.** Overlapping searches surface the same vacancy more than once — deduplication by vacancy number keeps each job exactly once.
- **Pick a country to fill the country field reliably.** A worldwide list-only run may leave `country` blank on some rows; choosing a country (or turning on full descriptions) resolves it.
- **Filter by language for clean, single-language datasets.** Combine a language with a country to avoid mixed-locale results in cross-border markets.

### Pricing

**From $0.95 per 1,000 results** — undercuts the leading Randstad scraper's $1.00 / 1,000. No compute or time-based charges — you pay per result, plus a small fixed per-run start fee. 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.11 | $0.10 | $0.10 |
| 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 one job listing pushed to your dataset. Platform usage fees are billed separately by Apify.

### 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 collects publicly available job-listing data for legitimate business purposes such as recruitment research, market analysis, and salary benchmarking. Use it responsibly: respect Randstad's terms of service, comply with applicable data-protection laws (including GDPR and CCPA) when handling any personal data, and do not use collected data for spam or other unlawful activity. You are responsible for how you use the data you collect.

# Actor input Schema

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

Job titles, roles, or keywords to search for, such as 'developer', 'nurse', or 'warehouse'. Each keyword runs its own search. Leave empty to collect the broadest result set for the chosen country and filters. Up to 50 keywords per run.

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

Paste full Randstad search-result or individual job URLs (e.g. https://www.randstad.com/jobs/united-kingdom/q-developer/) to scrape them directly. Useful when you already have a search dialed in on the website — any filters baked into the URL are respected. Up to 50 URLs per run.

## `country` (type: `string`):

Which country's jobs to search. Leave on 'Any country' to search worldwide.

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

Limit results to one job specialism (the field of work). Leave on 'Any' to include all categories.

## `jobType` (type: `string`):

Limit results to one employment type. Leave on 'Any' to include all types.

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

Only return listings in this language. Leave on 'Any' to include all languages.

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

Maximum number of job listings to collect across all searches and URLs. Set to 0 to collect all available results. Results are fetched in pages: the actor stops once your cap is reached but always keeps the whole final page, so a small cap can return a few more than you asked for.

## `onlyUniqueJobs` (type: `boolean`):

When on, each job is returned once even if it appears across several searches or pages. Deduplicates by the job's vacancy number / URL. Turn off to keep every copy.

## `includeDescription` (type: `boolean`):

When on, each job page is opened to add the full job description plus requirement details (skills, qualifications, education, experience), the company website, the exact street address, and the ISO currency code. When off, runs are faster and lighter: you still get every result-list field — including a short description preview — but not the full description or the extra requirement details. Leave on for the most complete data.

## Actor input object example

```json
{
  "searchQueries": [
    "developer"
  ],
  "startUrls": [],
  "country": "",
  "category": "",
  "jobType": "",
  "language": "",
  "maxItems": 100,
  "onlyUniqueJobs": true,
  "includeDescription": true
}
```

# Actor output Schema

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

Table of scraped job listings with key fields.

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

Complete job data including descriptions, requirement sections, and parsed salary fields.

# 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": [
        "developer"
    ],
    "startUrls": [],
    "country": "",
    "category": "",
    "jobType": "",
    "language": "",
    "maxItems": 100,
    "onlyUniqueJobs": true,
    "includeDescription": true
};

// Run the Actor and wait for it to finish
const run = await client.actor("solidcode/randstad-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": ["developer"],
    "startUrls": [],
    "country": "",
    "category": "",
    "jobType": "",
    "language": "",
    "maxItems": 100,
    "onlyUniqueJobs": True,
    "includeDescription": True,
}

# Run the Actor and wait for it to finish
run = client.actor("solidcode/randstad-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": [
    "developer"
  ],
  "startUrls": [],
  "country": "",
  "category": "",
  "jobType": "",
  "language": "",
  "maxItems": 100,
  "onlyUniqueJobs": true,
  "includeDescription": true
}' |
apify call solidcode/randstad-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Randstad Jobs Scraper",
        "description": "[💰 $0.95 / 1K] Extract job listings from Randstad worldwide. Search by keyword, country, specialism, and job type, or paste Randstad URLs directly. Get structured data: titles, salaries, locations, employment type, hiring company, descriptions, and apply links.",
        "version": "1.0",
        "x-build-id": "uWpQcepzmfrg3Bkhj"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/solidcode~randstad-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-solidcode-randstad-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~randstad-scraper/runs": {
            "post": {
                "operationId": "runs-sync-solidcode-randstad-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~randstad-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-solidcode-randstad-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, roles, or keywords to search for, such as 'developer', 'nurse', or 'warehouse'. Each keyword runs its own search. Leave empty to collect the broadest result set for the chosen country and filters. Up to 50 keywords per run.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "startUrls": {
                        "title": "Direct Randstad URLs",
                        "maxItems": 50,
                        "type": "array",
                        "description": "Paste full Randstad search-result or individual job URLs (e.g. https://www.randstad.com/jobs/united-kingdom/q-developer/) to scrape them directly. Useful when you already have a search dialed in on the website — any filters baked into the URL are respected. Up to 50 URLs per run.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "country": {
                        "title": "Country",
                        "enum": [
                            "",
                            "argentina",
                            "australia",
                            "austria",
                            "belgium",
                            "canada",
                            "china",
                            "denmark",
                            "france",
                            "germany",
                            "greece",
                            "hong-kong-sar",
                            "hungary",
                            "india",
                            "italy",
                            "japan",
                            "malaysia",
                            "the-netherlands",
                            "new-zealand",
                            "poland",
                            "portugal",
                            "romania",
                            "singapore",
                            "spain",
                            "sweden",
                            "switzerland",
                            "turkey",
                            "united-kingdom"
                        ],
                        "type": "string",
                        "description": "Which country's jobs to search. Leave on 'Any country' to search worldwide.",
                        "default": ""
                    },
                    "category": {
                        "title": "Specialism / Category",
                        "enum": [
                            "",
                            "accounting-auditing",
                            "administrative-support-services",
                            "advertising-marketing-public-relations",
                            "banking",
                            "biotechnology-pharmaceutical",
                            "construction-trades-mining",
                            "consulting-services",
                            "design",
                            "employment-recruitment-agency",
                            "engineering",
                            "finance-economics",
                            "financial-services",
                            "health-social-care-practitioner-technician",
                            "human-resources",
                            "information-technology",
                            "installation-maintenance-repair",
                            "insurance",
                            "legal",
                            "property",
                            "retail-wholesale",
                            "sales",
                            "science-research",
                            "warehousing-distribution",
                            "other"
                        ],
                        "type": "string",
                        "description": "Limit results to one job specialism (the field of work). Leave on 'Any' to include all categories.",
                        "default": ""
                    },
                    "jobType": {
                        "title": "Job Type",
                        "enum": [
                            "",
                            "permanent",
                            "contract",
                            "temporary",
                            "freelancer"
                        ],
                        "type": "string",
                        "description": "Limit results to one employment type. Leave on 'Any' to include all types.",
                        "default": ""
                    },
                    "language": {
                        "title": "Listing Language",
                        "enum": [
                            "",
                            "english",
                            "chinese",
                            "danish",
                            "dutch",
                            "french",
                            "german",
                            "hungarian",
                            "italian",
                            "japanese",
                            "polish",
                            "portuguese",
                            "romanian",
                            "spanish",
                            "turkish"
                        ],
                        "type": "string",
                        "description": "Only return listings in this language. Leave on 'Any' to include all languages.",
                        "default": ""
                    },
                    "maxItems": {
                        "title": "Max Results",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of job listings to collect across all searches and URLs. Set to 0 to collect all available results. Results are fetched in pages: the actor stops once your cap is reached but always keeps the whole final page, so a small cap can return a few more than you asked for.",
                        "default": 100
                    },
                    "onlyUniqueJobs": {
                        "title": "Only Unique Jobs",
                        "type": "boolean",
                        "description": "When on, each job is returned once even if it appears across several searches or pages. Deduplicates by the job's vacancy number / URL. Turn off to keep every copy.",
                        "default": true
                    },
                    "includeDescription": {
                        "title": "Fetch Full Job Descriptions",
                        "type": "boolean",
                        "description": "When on, each job page is opened to add the full job description plus requirement details (skills, qualifications, education, experience), the company website, the exact street address, and the ISO currency code. When off, runs are faster and lighter: you still get every result-list field — including a short description preview — but not the full description or the extra requirement details. Leave on for the most complete data.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
