# JobScout24.ch Scraper (`solidcode/jobscout24-ch-scraper`) Actor

\[💰 $2.5 / 1K] Extract job listings from JobScout24.ch, a major Swiss job board — titles, companies, locations, workload %, contract type, publication dates, full descriptions and direct job links. Filter by keyword, region, category, contract type and workload.

- **URL**: https://apify.com/solidcode/jobscout24-ch-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 $2.50 / 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

## JobScout24.ch Scraper

Pull job listings from JobScout24.ch, one of Switzerland's largest job boards, at scale — titles, employers, canton-level locations, exact Pensum workload percentages, contract types, and full descriptions across the whole Swiss market. Search multiple keywords in one run, narrow by region, category, and workload, and get one clean row per posting. Built for Swiss recruiters, labour-market researchers, and relocation and talent-mapping teams who need structured Swiss job data without copy-pasting listings one page at a time.

### Why This Scraper?

- **Trilingual output — English, German, and French** — pull the same Swiss market in `en`, `de`, or `fr`, matching how each posting was written and how your team reads it.
- **13 named Swiss regions** — filter by canton groups like North West Switzerland (AG / BL / BS / SO), Zurich region, Lake Geneva region, Ticino, or Home Office / Remote Work — the most reliable way to sweep an area.
- **23 professional categories (Berufsgruppen)** — from IT and Banking / Financial Services to Watch / Optical Industries and Trustee / Law / Tax / Consulting, so you collect only the field you care about.
- **Exact Pensum workload percentages** — every job carries `workloadMin` and `workloadMax` (e.g. 80–100%), plus a min–max range filter to isolate part-time or full-time roles precisely.
- **6 contract types** — permanent, temporary, internship, freelance, part-time, and apprenticeship (Lehrstelle) openings, selectable individually.
- **Canton-level geography** — every row resolves to a Swiss canton (`canton`), not just a city string, for clean regional roll-ups.
- **Full job descriptions on every posting** — the complete description text is pulled from each job's own detail page, not just the search-result snippet.
- **Multi-keyword batch searches** — queue up to 50 keywords in a single run; results are merged and de-duplicated automatically across overlapping searches.
- **Fresh-listing windows** — restrict to jobs published in the last 24 hours, 3 days, week, or 30 days to monitor only what is genuinely new.

### Use Cases

**Recruitment & Sourcing**
- Build live candidate-target lists of open roles by region and category
- Track competitor hiring by employer across cantons
- Monitor apprenticeship (Lehrstelle) openings for early-talent pipelines
- Surface fresh postings every morning with the 24-hour window

**Labour-Market Research**
- Map job supply by canton, category, and workload across Switzerland
- Measure part-time versus full-time demand using Pensum percentages
- Compare hiring volume between the German- and French-speaking regions
- Track category-level trends (IT, health, finance) over time

**Relocation & Talent Mapping**
- Identify where a given profession concentrates geographically by canton
- Find remote-friendly roles via the Home Office / Remote Work region
- Assess opportunity depth in a target region before advising a move
- Map employer presence across the Lake Geneva and Zurich regions

**Competitive Hiring Intelligence**
- Watch a named company's open roles and contract mix
- Benchmark workload expectations across an industry
- Feed structured Swiss job data into dashboards and ATS pipelines
- Detect new market entrants by monitoring fresh postings per category

### Getting Started

#### Simple Keyword Search

Just a keyword — collects the newest matching jobs across Switzerland:

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

#### Region and Category Filter

Sweep a whole region for one professional field, newest first:

```json
{
    "searchQueries": ["Projektleiter"],
    "region": "2",
    "category": "8",
    "publishedSince": "7",
    "language": "de"
}
```

#### Advanced — Part-Time Roles, Full Detail

Part-time permanent roles up to 60% workload, with full descriptions:

```json
{
    "searchQueries": ["Sachbearbeiter", "Kundenberater"],
    "region": "1",
    "employmentType": ["permanent", "part-time"],
    "workloadMin": 40,
    "workloadMax": 60,
    "publishedSince": "30",
    "language": "de",
    "maxResults": 500,
    "includeJobDetails": true
}
```

### Input Reference

#### Search

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `searchQueries` | array | `["Software Engineer"]` | Job titles or keywords. Each keyword runs a separate search; results are merged and de-duplicated. Up to 50 keywords. |
| `location` | string | `""` | A Swiss city or town (e.g. Zürich, Bern, Geneva, Basel). Leave empty to search all of Switzerland. |
| `region` | string | `Any region` | Named Swiss region (canton group). Options include North West Switzerland, Zurich region, Berne region, Swiss Mittelland, Eastern Switzerland, Central Switzerland, Graubünden, Valais / Wallis, Lake Geneva region, North Romandie, Ticino, Outside Switzerland, Home Office / Remote Work. |
| `startUrls` | array | `[]` | Paste JobScout24.ch search-result or individual job URLs directly. Overrides the keyword, location, and region fields. |

#### Filters

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `category` | string | `Any category` | One professional category (Berufsgruppe): Management; Banking / Financial Services; Accounting / Finance / Controlling; Trustee / Law / Tax / Consulting; Insurance / Health Insurance; Sales / Client Consulting / Customer Support; Commercial jobs / Administration; IT; Human Resources / Personnel Administration; Marketing / Advertising / PR / Media; Design; Medicine / Health / Psychology / Social Affairs; Education / Training; Technical Jobs / Engineers / Architects; Chemical / Pharma / Biotechnology / Medical Technology; Watch / Optical Industries; Craftsmanship / Construction / Production / Trades / Automobile; Logistics / Transport / Traffic; Service jobs / Gastronomy / Hotel / Tourism; Science / Research / Development; Real Estate; Agriculture; Others. |
| `employmentType` | array | `[]` | Contract types to keep: Permanent position, Temporary / fixed-term, Internship / trainee, Freelance, Part-time, Apprenticeship (Lehrstelle). Leave empty for all. |
| `workloadMin` | integer | — | Keep jobs offering at least this workload percentage (Pensum), 0–100. |
| `workloadMax` | integer | — | Keep jobs offering at most this workload percentage (Pensum), 0–100. |
| `publishedSince` | string | `Any time` | Published-within window: Any time, Last 24 hours, Last 3 days, Last week, Last 30 days. |

#### Output Options

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `language` | string | `English` | Site language for titles and descriptions: English, German (Deutsch), French (Français). |
| `maxResults` | integer | `100` | Maximum jobs per search keyword. Set to 0 to collect every match. The last page is kept in full, so the count can slightly overshoot. |
| `includeJobDetails` | boolean | `true` | Fetch the full description and detail-page fields for each job. Turn off for a faster, lighter scan of summary fields only. |

### Output

Each job posting returns one flat row:

```json
{
    "title": "Software Engineer (m/w/d)",
    "company": "Beispiel AG",
    "location": "Zürich",
    "canton": "ZH",
    "workload": "80% – 100%",
    "workloadMin": 80,
    "workloadMax": 100,
    "employmentType": "Permanent position",
    "descriptionSnippet": "We are looking for an experienced software engineer to join our platform team.",
    "description": "We are looking for an experienced software engineer to join our platform team. You will design and build services, collaborate across teams, and own features end to end...",
    "publicationDate": "2026-06-28",
    "companyLogo": "https://www.jobscout24.ch/media/logos/beispiel-ag.png",
    "companyUrl": "https://www.jobscout24.ch/en/companies/beispiel-ag/",
    "jobId": "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
    "jobUrl": "https://www.jobscout24.ch/en/job/a1b2c3d4-e5f6-7890-abcd-ef1234567890/",
    "language": "en",
    "searchQuery": "Software Engineer",
    "scrapedAt": "2026-07-04T09:15:00Z"
}
```

#### Field Reference

| Field | Type | Description |
|-------|------|-------------|
| `title` | string | Job title as posted. |
| `company` | string | Employer name. |
| `location` | string | City or town of the role. |
| `canton` | string | Swiss canton code (e.g. ZH, GE, TI). |
| `workload` | string | Workload display string (e.g. "80% – 100%"). |
| `workloadMin` | number | Minimum workload percentage (Pensum). |
| `workloadMax` | number | Maximum workload percentage (Pensum). |
| `employmentType` | string | Contract type (Permanent position, Part-time, etc.). |
| `descriptionSnippet` | string | Short summary drawn from the full description. |
| `description` | string | Full job description text from the detail page. |
| `publicationDate` | string | Date the job was published. |
| `companyLogo` | string | URL of the employer's logo. |
| `companyUrl` | string | URL of the employer's company profile. |
| `jobId` | string | Unique JobScout24.ch job identifier. |
| `jobUrl` | string | Direct link to the job posting. |
| `language` | string | Language of the returned content (en / de / fr). |
| `searchQuery` | string | The keyword that produced this row. |
| `scrapedAt` | string | Timestamp the row was collected. |

### Tips for Best Results

- **Leave the keyword empty and set a region** to sweep every fresh job across a canton group — the region filter is the most reliable geographic net on JobScout24.ch.
- **Use the Last 24 hours window** for daily new-listing monitoring; run the same input on a schedule to catch only what changed overnight.
- **Match `language` to the region you target** — German (`de`) for Zurich and Central Switzerland, French (`fr`) for the Lake Geneva region and Romandie — so titles and descriptions come back in the local language.
- **Set `workloadMin` and `workloadMax` together** to isolate true part-time roles (e.g. 40–60%) or full-time only (80–100%) rather than filtering after export.
- **Keep Fetch Full Job Details on** for complete description text and canton resolution; turn it off only when you need a fast headcount of matching titles.
- **Apprenticeship (Lehrstelle) is a distinct search mode** — select it alone to collect early-talent openings; it cannot be combined with the other contract types.
- **Queue several related keywords** in one run (e.g. "Sachbearbeiter", "Kundenberater") — overlapping results are de-duplicated automatically, so you never pay twice for the same posting.

### Pricing

**From $2.50 per 1,000 results** — a flat pay-per-result rate that undercuts building and maintaining your own Swiss job feed. 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.30 | $0.28 | $0.27 | $0.25 |
| 1,000 | $3.00 | $2.80 | $2.65 | $2.50 |
| 10,000 | $30.00 | $28.00 | $26.50 | $25.00 |
| 100,000 | $300.00 | $280.00 | $265.00 | $250.00 |

A "result" is one job posting returned to your dataset. Apify platform fees are additional.

### 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 scraper collects publicly available job listings for legitimate business purposes such as recruitment, market research, and analysis. You are responsible for using the collected data in compliance with JobScout24.ch's terms of service, applicable Swiss and EU data-protection law (including the revised FADP and GDPR), and any other relevant regulations. Do not use the data to send unsolicited communications or in any way that infringes on the rights of individuals or employers. Always review the target site's terms before running large-scale extractions.

# Actor input Schema

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

Job titles or keywords to search for, such as 'Software Engineer', 'Sachbearbeiter' or 'Chauffeur'. Each keyword runs a separate search and the results are merged and de-duplicated. Leave empty if you only want to use the direct URLs below.

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

A Swiss city or town to search in, such as 'Zürich', 'Bern', 'Geneva' or 'Basel'. The city name is matched to a location page on JobScout24.ch, so use a plain city name (postal codes and full addresses are not supported). Leave empty to search all of Switzerland. For broader area filtering, use the Region filter below instead — it is the most reliable geographic filter. Ignored when Direct URLs are provided.

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

Limit results to a named Swiss region (a group of cantons). Leave on 'Any region' to include the whole country. Use 'Home Office / Remote' to find remote-friendly roles. This is the most reliable way to filter by area.

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

Paste one or more JobScout24.ch URLs directly — search-result pages (…/jobs/…) or individual job postings (…/job/<id>/). When provided, these override the Search Keywords, Location and Region fields above.

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

Only collect jobs in this professional category (Berufsgruppe). Leave on 'Any category' to include every field.

## `employmentType` (type: `array`):

Only collect jobs with these contract types. Leave empty to include every contract type. Selecting 'Apprenticeship' switches the search to apprenticeship openings (Lehrstellen) and cannot be combined with the other contract types.

## `workloadMin` (type: `integer`):

Only collect jobs offering at least this workload percentage (Pensum). For example, 80 keeps roles of 80% and up. Leave empty for no minimum.

## `workloadMax` (type: `integer`):

Only collect jobs offering at most this workload percentage (Pensum). For example, 60 keeps part-time roles up to 60%. Leave empty for no maximum.

## `publishedSince` (type: `string`):

Only collect jobs published within this time window. Helps you focus on fresh openings.

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

Language for job titles and descriptions where JobScout24.ch provides translations. Most postings stay in the language the employer wrote them.

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

Maximum number of jobs to collect per search keyword. Use 50 for a quick scan or a higher number for deep research. Set to 0 (or leave empty) to collect every matching job with no limit, which can return a very large number of results for broad keywords. The last page is always kept in full, so the final count can slightly overshoot this number.

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

Fetch the full description and additional detail-page fields for each job. Leave on for the richest data. Turn off for a faster, lighter scan that returns only the summary fields shown in search results.

## Actor input object example

```json
{
  "searchQueries": [
    "Software Engineer"
  ],
  "startUrls": [],
  "employmentType": [],
  "publishedSince": "any",
  "language": "en",
  "maxResults": 100,
  "includeJobDetails": true
}
```

# Actor output Schema

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

Table of jobs with key fields like title, company, location, workload and contract type.

## `details` (type: `string`):

Full per-job rows including description, workload, and company and job links.

# 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 Engineer"
    ],
    "location": "",
    "region": "",
    "startUrls": [],
    "category": "",
    "employmentType": [],
    "publishedSince": "any",
    "language": "en",
    "maxResults": 100,
    "includeJobDetails": true
};

// Run the Actor and wait for it to finish
const run = await client.actor("solidcode/jobscout24-ch-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 Engineer"],
    "location": "",
    "region": "",
    "startUrls": [],
    "category": "",
    "employmentType": [],
    "publishedSince": "any",
    "language": "en",
    "maxResults": 100,
    "includeJobDetails": True,
}

# Run the Actor and wait for it to finish
run = client.actor("solidcode/jobscout24-ch-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 Engineer"
  ],
  "location": "",
  "region": "",
  "startUrls": [],
  "category": "",
  "employmentType": [],
  "publishedSince": "any",
  "language": "en",
  "maxResults": 100,
  "includeJobDetails": true
}' |
apify call solidcode/jobscout24-ch-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "JobScout24.ch Scraper",
        "description": "[💰 $2.5 / 1K] Extract job listings from JobScout24.ch, a major Swiss job board — titles, companies, locations, workload %, contract type, publication dates, full descriptions and direct job links. Filter by keyword, region, category, contract type and workload.",
        "version": "1.0",
        "x-build-id": "iSR3k9OvEqHhT8gWl"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/solidcode~jobscout24-ch-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-solidcode-jobscout24-ch-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~jobscout24-ch-scraper/runs": {
            "post": {
                "operationId": "runs-sync-solidcode-jobscout24-ch-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~jobscout24-ch-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-solidcode-jobscout24-ch-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 Engineer', 'Sachbearbeiter' or 'Chauffeur'. Each keyword runs a separate search and the results are merged and de-duplicated. Leave empty if you only want to use the direct URLs below.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "location": {
                        "title": "Location (City)",
                        "type": "string",
                        "description": "A Swiss city or town to search in, such as 'Zürich', 'Bern', 'Geneva' or 'Basel'. The city name is matched to a location page on JobScout24.ch, so use a plain city name (postal codes and full addresses are not supported). Leave empty to search all of Switzerland. For broader area filtering, use the Region filter below instead — it is the most reliable geographic filter. Ignored when Direct URLs are provided."
                    },
                    "region": {
                        "title": "Region",
                        "enum": [
                            "",
                            "1",
                            "2",
                            "3",
                            "13",
                            "4",
                            "5",
                            "6",
                            "7",
                            "8",
                            "9",
                            "10",
                            "11",
                            "14"
                        ],
                        "type": "string",
                        "description": "Limit results to a named Swiss region (a group of cantons). Leave on 'Any region' to include the whole country. Use 'Home Office / Remote' to find remote-friendly roles. This is the most reliable way to filter by area."
                    },
                    "startUrls": {
                        "title": "Direct URLs",
                        "maxItems": 200,
                        "type": "array",
                        "description": "Paste one or more JobScout24.ch URLs directly — search-result pages (…/jobs/…) or individual job postings (…/job/<id>/). When provided, these override the Search Keywords, Location and Region fields above.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "category": {
                        "title": "Professional Category",
                        "enum": [
                            "",
                            "1",
                            "2",
                            "3",
                            "4",
                            "5",
                            "6",
                            "7",
                            "8",
                            "10",
                            "11",
                            "12",
                            "13",
                            "14",
                            "15",
                            "16",
                            "17",
                            "18",
                            "19",
                            "20",
                            "22",
                            "23",
                            "24",
                            "21"
                        ],
                        "type": "string",
                        "description": "Only collect jobs in this professional category (Berufsgruppe). Leave on 'Any category' to include every field."
                    },
                    "employmentType": {
                        "title": "Contract Type",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Only collect jobs with these contract types. Leave empty to include every contract type. Selecting 'Apprenticeship' switches the search to apprenticeship openings (Lehrstellen) and cannot be combined with the other contract types.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "permanent",
                                "temporary",
                                "internship",
                                "freelance",
                                "part-time",
                                "apprenticeship"
                            ],
                            "enumTitles": [
                                "Permanent position",
                                "Temporary / fixed-term",
                                "Internship / trainee",
                                "Freelance",
                                "Part-time",
                                "Apprenticeship (Lehrstelle)"
                            ]
                        }
                    },
                    "workloadMin": {
                        "title": "Minimum Workload (%)",
                        "minimum": 0,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Only collect jobs offering at least this workload percentage (Pensum). For example, 80 keeps roles of 80% and up. Leave empty for no minimum."
                    },
                    "workloadMax": {
                        "title": "Maximum Workload (%)",
                        "minimum": 0,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Only collect jobs offering at most this workload percentage (Pensum). For example, 60 keeps part-time roles up to 60%. Leave empty for no maximum."
                    },
                    "publishedSince": {
                        "title": "Published Within",
                        "enum": [
                            "any",
                            "0",
                            "3",
                            "7",
                            "30"
                        ],
                        "type": "string",
                        "description": "Only collect jobs published within this time window. Helps you focus on fresh openings."
                    },
                    "language": {
                        "title": "Site Language",
                        "enum": [
                            "en",
                            "de",
                            "fr"
                        ],
                        "type": "string",
                        "description": "Language for job titles and descriptions where JobScout24.ch provides translations. Most postings stay in the language the employer wrote them."
                    },
                    "maxResults": {
                        "title": "Max Results per Search",
                        "minimum": 0,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum number of jobs to collect per search keyword. Use 50 for a quick scan or a higher number for deep research. Set to 0 (or leave empty) to collect every matching job with no limit, which can return a very large number of results for broad keywords. The last page is always kept in full, so the final count can slightly overshoot this number.",
                        "default": 100
                    },
                    "includeJobDetails": {
                        "title": "Fetch Full Job Details",
                        "type": "boolean",
                        "description": "Fetch the full description and additional detail-page fields for each job. Leave on for the richest data. Turn off for a faster, lighter scan that returns only the summary fields shown in search results.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
