# karriere.at Job Scraper (`solidcode/karriere-at-scraper`) Actor

\[💰 $2.5 / 1K] Scrape jobs from karriere.at, Austria's largest job board. Search by keyword, city, and federal state; filter by employment type, industry, and posting date. Returns title, company, location, salary, full description, and recruiter contact details.

- **URL**: https://apify.com/solidcode/karriere-at-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, NaN 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

## karriere.at Job Scraper

Pull job postings from karriere.at — Austria's largest job board — at scale, complete with structured EUR salary ranges, full descriptions, recruiter contacts, ISO 8601 posting dates, and the exact federal state each role sits in. Run many keywords at once and get a single deduplicated dataset back. Built for Austrian recruiters, labor-market analysts, and relocation services who need clean, structured karriere.at job data without copy-pasting listings one tab at a time.

### Why This Scraper?

- **All 9 Austrian federal states, by name** — filter to Wien, Niederösterreich, Oberösterreich, Steiermark, Tirol, Kärnten, Salzburg, Vorarlberg, or Burgenland, with German umlauts handled for you. Every result is also tagged with the state it belongs to.
- **5 employment types in plain English** — Full-time (Vollzeit), Part-time (Teilzeit), Marginal employment (Geringfügig), Apprenticeship (Lehrstelle), and Internship (Praktikum) — pick any combination instead of memorizing German tokens.
- **Structured EUR salary, not just raw text** — parsed `salaryMin`, `salaryMax`, and `salaryCurrency` fields alongside the original salary line, so you can sort, average, and benchmark compensation directly.
- **Recruiter contacts where published** — `contactName`, `contactEmail`, and `contactPhone` pulled straight from the posting, turning each search into a ready-to-use lead list.
- **Multi-keyword search, deduplicated** — pass a list like `["Pflege", "Software Engineer", "Buchhaltung"]`; each keyword is searched separately and the combined results are deduplicated by job ID, so no role appears twice.
- **~26 structured fields per job** — title, company, location, state, employment type, job level, full description, requirements, benefits, salary, apply URL, company logo, and ISO 8601 posting and capture timestamps.
- **Two-speed runs** — toggle `includeJobDetails` off for a fast listing sweep, or on to enrich every job with its full description, salary breakdown, benefits, and recruiter contact.
- **Up to 50,000 jobs per run** — set a precise total cap or open it wide; one clear `maxResults` number controls the whole run, no hidden per-query multipliers.

### Use Cases

**Recruitment & Talent Sourcing**
- Build live candidate-facing job feeds for specific roles across Austria
- Monitor competing employers' open roles by company and city
- Track apprenticeship (Lehrstelle) and internship openings for early-talent pipelines
- Surface newly posted roles daily with the Last 24 hours filter

**Labor-Market Research**
- Map job supply by federal state to spot regional hiring hotspots
- Quantify demand for a skill or title over time using posting dates
- Compare full-time vs. part-time vs. marginal employment mix by sector
- Feed structured job counts into workforce and economic dashboards

**Salary Benchmarking**
- Aggregate `salaryMin`/`salaryMax` ranges by role, city, and seniority
- Benchmark a single position across Vienna vs. the rest of Austria
- Track advertised pay trends across posting periods
- Build compensation reports from structured EUR figures, not free text

**Lead Generation**
- Extract recruiter and hiring-manager contacts from postings that publish them
- Target staffing prospects by industry and employment type
- Identify companies actively hiring in a given Bundesland

**Relocation & Job-Matching Services**
- Match incoming candidates to roles by state, city, and employment type
- Curate role shortlists with full descriptions and direct apply URLs
- Highlight home-office-friendly roles for remote-first job seekers

### Getting Started

#### Search a single keyword

The simplest run — one keyword across all of Austria:

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

#### Filter by state and employment type

Full-time and part-time tech roles in Vienna, posted recently:

```json
{
    "searchQueries": ["Software Engineer", "DevOps"],
    "bundesland": "Wien",
    "employmentTypes": ["Vollzeit", "Teilzeit"],
    "datePosted": "7",
    "sortBy": "date",
    "maxResults": 200
}
```

#### Full-featured run

Multiple keywords, an industry filter, newest-first sorting, and full detail enrichment:

```json
{
    "searchQueries": ["Pflege", "Buchhaltung", "Projektmanager"],
    "location": "Graz",
    "bundesland": "Steiermark",
    "employmentTypes": ["Vollzeit"],
    "industry": "Gesundheit",
    "datePosted": "30",
    "sortBy": "date",
    "includeJobDetails": true,
    "maxResults": 1000
}
```

### Input Reference

#### Search

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `searchQueries` | array | `["Software Engineer"]` | One or more job keywords (e.g. "Pflege", "Buchhaltung"). Each is searched separately and the results are combined with duplicates removed. Leave empty to browse without a keyword. |
| `location` | string | `""` | A city or region in Austria such as "Wien", "Graz", or "Linz". Takes precedence over the state filter when both are set. |

#### Filters

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `bundesland` | select | `Any state` | Limit results to one Austrian federal state: Vienna, Lower/Upper Austria, Styria, Tyrol, Carinthia, Salzburg, Vorarlberg, or Burgenland. |
| `employmentTypes` | multi-select | `[]` | Include only these employment types: Full-time, Part-time, Marginal employment, Apprenticeship, or Internship. Leave empty for all. |
| `industry` | string | `""` | Filter by industry or sector, e.g. "IT", "Gesundheit", or "Handel". |
| `datePosted` | select | `Any time` | Only include jobs posted within the last 24 hours, 7 days, or 30 days. |
| `sortBy` | select | `Most relevant` | Return the most relevant jobs first, or the most recently posted jobs first. |

#### Output

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `includeJobDetails` | boolean | `true` | Fetch each job's full description, requirements, benefits, structured salary, apply URL, and recruiter contact. Turn off for a faster, lighter run that returns listing summaries only. |
| `maxResults` | integer | `100` | Maximum number of jobs to return in total across all keywords. Set to 0 for unlimited (capped at 50,000 for safety). |

### Output

Each job is one row. Here's a representative result with full details enabled:

```json
{
    "id": "8765432",
    "title": "Senior Software Engineer (m/w/d)",
    "company": "Beispiel GmbH",
    "companyLogo": "https://kcdn.at/logos/beispiel.png",
    "location": "Wien",
    "bundesland": "Wien",
    "employmentType": "Vollzeit",
    "jobLevel": "Berufserfahren",
    "isHomeOffice": true,
    "salaryMin": 56000,
    "salaryMax": 78000,
    "salaryCurrency": "EUR",
    "salaryText": "ab € 56.000 brutto/Jahr",
    "descriptionSnippet": "Wir suchen eine erfahrene Entwicklerin für unser Plattform-Team...",
    "descriptionFull": "Als Senior Software Engineer verantwortest du den Ausbau unserer Cloud-Plattform...",
    "requirements": "Mehrjährige Erfahrung in der Backend-Entwicklung, fundierte Kenntnisse in verteilten Systemen...",
    "benefits": ["Home-Office", "Essenszuschuss", "Weiterbildungsbudget"],
    "contactName": "Maria Huber",
    "contactEmail": "jobs@beispiel.at",
    "contactPhone": "+43 1 234 5678",
    "postedAt": "2026-05-28",
    "applyUrl": "https://www.karriere.at/jobs/8765432/apply",
    "url": "https://www.karriere.at/jobs/8765432",
    "searchQuery": "Software Engineer",
    "scrapedAt": "2026-06-03T09:15:00Z"
}
```

#### Core Fields

| Field | Type | Description |
|-------|------|-------------|
| `id` | string | Unique karriere.at job identifier |
| `title` | string | Job title as posted |
| `company` | string | Hiring company name |
| `companyLogo` | string | Company logo image URL |
| `location` | string | City or region of the role |
| `bundesland` | string | Austrian federal state (where available) |
| `employmentType` | string | Vollzeit, Teilzeit, Geringfügig, Lehrstelle, or Praktikum |
| `jobLevel` | string | Seniority level as listed (where available) |
| `isHomeOffice` | boolean | Whether the listing flags home-office availability |

#### Salary

| Field | Type | Description |
|-------|------|-------------|
| `salaryMin` | number | Parsed minimum annual salary in EUR (where available) |
| `salaryMax` | number | Parsed maximum annual salary in EUR (where available) |
| `salaryCurrency` | string | Currency code, typically EUR |
| `salaryText` | string | Original salary line as displayed |

#### Description & Requirements

| Field | Type | Description |
|-------|------|-------------|
| `descriptionSnippet` | string | Short listing summary from the results page |
| `descriptionFull` | string | Full job description (with `includeJobDetails`) |
| `requirements` | string | Requirements section, where the employer provides one |
| `benefits` | array | Listed company benefits, where available |

#### Contact

| Field | Type | Description |
|-------|------|-------------|
| `contactName` | string | Recruiter or contact name, where published |
| `contactEmail` | string | Recruiter or contact email, where published |
| `contactPhone` | string | Recruiter or contact phone, where published |

#### Metadata

| Field | Type | Description |
|-------|------|-------------|
| `postedAt` | string | Posting date in ISO 8601 format |
| `applyUrl` | string | Direct application URL |
| `url` | string | Job posting URL on karriere.at |
| `searchQuery` | string | The keyword that surfaced this job |
| `scrapedAt` | string | ISO 8601 timestamp of when the row was collected |

Fields such as `requirements`, `benefits`, `contactName`, and salary figures are best-effort: they are filled when the employer publishes them and omitted otherwise, so your dataset stays clean.

### Tips for Best Results

- **Start small to validate** — set `maxResults` to 25–50 on your first run to confirm the data fits your needs, then scale up.
- **Use the state filter with confidence** — pick a Bundesland from the dropdown and the German umlauts (Niederösterreich, Kärnten) are restored automatically; you never type them yourself.
- **Location beats state when you need a city** — set `location` to "Graz" or "Linz" for city-level precision; it takes precedence over `bundesland` if you set both.
- **Batch related keywords in one run** — passing several titles in `searchQueries` is cheaper and tidier than separate runs, and duplicates are removed across the whole set by job ID.
- **Pair `datePosted` with `sortBy`** — combine "Last 24 hours" with "Newest first" to build a daily new-jobs feed; both work even when `includeJobDetails` is off, since they read the listing date directly.
- **Turn off details for fast counts** — leave `includeJobDetails` off when you only need titles, companies, and posting dates for market sizing; turn it on for salary, benefits, and recruiter contacts.
- **Salary and contacts are richest with details on** — structured `salaryMin`/`salaryMax` and recruiter email/phone come from the detailed view, so keep `includeJobDetails` enabled for benchmarking and lead generation.

### Pricing

**From $2.50 per 1,000 results** — undercutting the going rate for Austrian job data. 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 row in the output dataset. **No compute or time-based charges — you pay per result, plus a small fixed per-run start fee.**

### Integrations

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

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

### Legal & Ethical Use

This actor is designed for legitimate recruitment research, labor-market analysis, salary benchmarking, and lead generation. Users are responsible for complying with applicable laws and karriere.at's Terms of Service. Recruiter contact details may constitute personal data — handle them in line with GDPR and Austrian data-protection law, and do not use extracted data for spam, harassment, or any unlawful purpose.

# Actor input Schema

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

One or more job keywords to search for, such as 'Pflege', 'Software Engineer', or 'Buchhaltung'. Each keyword is searched separately and the results are combined with duplicates removed. Leave empty to browse jobs without a keyword.

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

A city or region in Austria to search within, for example 'Wien', 'Graz', or 'Linz'. Leave empty to search all of Austria.

## `bundesland` (type: `string`):

Limit results to one Austrian federal state (Bundesland). Leave on 'Any state' to include the whole country.

## `employmentTypes` (type: `array`):

Only include jobs offering one of these employment types. Leave empty to include every type.

## `industry` (type: `string`):

Filter jobs by industry or sector, for example 'IT', 'Gesundheit', or 'Handel'. Leave empty to include all industries.

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

Only include jobs posted within this time window.

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

Choose whether to return the most relevant jobs first or the most recently posted jobs first.

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

Fetch the full description, requirements, benefits, and contact details for each job. This produces richer results but takes longer. Turn off for a faster, lighter run that returns only the listing summary.

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

The maximum number of jobs to return in total across all keywords. Set to 0 for unlimited (capped at 50,000 for safety). Use 0 with care — large searches can return thousands of jobs.

## Actor input object example

```json
{
  "searchQueries": [
    "Software Engineer"
  ],
  "bundesland": "",
  "employmentTypes": [],
  "datePosted": "",
  "sortBy": "relevance",
  "includeJobDetails": true,
  "maxResults": 100
}
```

# Actor output Schema

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

Table of jobs with key fields like title, company, location, employment type, and link.

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

Full per-job detail rows including description, requirements, benefits, salary, and contact info.

# 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": "",
    "bundesland": "",
    "employmentTypes": [],
    "industry": "",
    "datePosted": "",
    "sortBy": "relevance",
    "includeJobDetails": true,
    "maxResults": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("solidcode/karriere-at-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": "",
    "bundesland": "",
    "employmentTypes": [],
    "industry": "",
    "datePosted": "",
    "sortBy": "relevance",
    "includeJobDetails": True,
    "maxResults": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("solidcode/karriere-at-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": "",
  "bundesland": "",
  "employmentTypes": [],
  "industry": "",
  "datePosted": "",
  "sortBy": "relevance",
  "includeJobDetails": true,
  "maxResults": 100
}' |
apify call solidcode/karriere-at-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "karriere.at Job Scraper",
        "description": "[💰 $2.5 / 1K] Scrape jobs from karriere.at, Austria's largest job board. Search by keyword, city, and federal state; filter by employment type, industry, and posting date. Returns title, company, location, salary, full description, and recruiter contact details.",
        "version": "1.0",
        "x-build-id": "Z9ssT3nlMGGkZDo1W"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/solidcode~karriere-at-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-solidcode-karriere-at-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~karriere-at-scraper/runs": {
            "post": {
                "operationId": "runs-sync-solidcode-karriere-at-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~karriere-at-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-solidcode-karriere-at-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",
                        "type": "array",
                        "description": "One or more job keywords to search for, such as 'Pflege', 'Software Engineer', or 'Buchhaltung'. Each keyword is searched separately and the results are combined with duplicates removed. Leave empty to browse jobs without a keyword.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "A city or region in Austria to search within, for example 'Wien', 'Graz', or 'Linz'. Leave empty to search all of Austria."
                    },
                    "bundesland": {
                        "title": "Austrian State",
                        "enum": [
                            "",
                            "Wien",
                            "Niederosterreich",
                            "Oberosterreich",
                            "Steiermark",
                            "Tirol",
                            "Karnten",
                            "Salzburg",
                            "Vorarlberg",
                            "Burgenland"
                        ],
                        "type": "string",
                        "description": "Limit results to one Austrian federal state (Bundesland). Leave on 'Any state' to include the whole country.",
                        "default": ""
                    },
                    "employmentTypes": {
                        "title": "Employment Type",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Only include jobs offering one of these employment types. Leave empty to include every type.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "Vollzeit",
                                "Teilzeit",
                                "Geringfugig",
                                "Lehrstelle",
                                "Praktikum"
                            ],
                            "enumTitles": [
                                "Full-time (Vollzeit)",
                                "Part-time (Teilzeit)",
                                "Marginal employment (Geringfügig)",
                                "Apprenticeship (Lehrstelle)",
                                "Internship (Praktikum)"
                            ]
                        },
                        "default": []
                    },
                    "industry": {
                        "title": "Industry",
                        "type": "string",
                        "description": "Filter jobs by industry or sector, for example 'IT', 'Gesundheit', or 'Handel'. Leave empty to include all industries."
                    },
                    "datePosted": {
                        "title": "Posted Within",
                        "enum": [
                            "",
                            "1",
                            "7",
                            "30"
                        ],
                        "type": "string",
                        "description": "Only include jobs posted within this time window.",
                        "default": ""
                    },
                    "sortBy": {
                        "title": "Sort Results By",
                        "enum": [
                            "relevance",
                            "date"
                        ],
                        "type": "string",
                        "description": "Choose whether to return the most relevant jobs first or the most recently posted jobs first.",
                        "default": "relevance"
                    },
                    "includeJobDetails": {
                        "title": "Include Full Job Details",
                        "type": "boolean",
                        "description": "Fetch the full description, requirements, benefits, and contact details for each job. This produces richer results but takes longer. Turn off for a faster, lighter run that returns only the listing summary.",
                        "default": true
                    },
                    "maxResults": {
                        "title": "Maximum Results",
                        "minimum": 0,
                        "type": "integer",
                        "description": "The maximum number of jobs to return in total across all keywords. Set to 0 for unlimited (capped at 50,000 for safety). Use 0 with care — large searches can return thousands of jobs.",
                        "default": 100
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
