# Personio Jobs Scraper & API — Any Company (`memo23/personio-scraper`) Actor

Scrape every open job from any company on Personio (jobs.personio.com). Give a company subdomain and get each position with full description, location, department, employment type and apply URL — from the public feed. Filter by title, location, remote. No proxy. JSON or CSV out.

- **URL**: https://apify.com/memo23/personio-scraper.md
- **Developed by:** [Muhamed Didovic](https://apify.com/memo23) (community)
- **Categories:** Jobs, Agents, AI
- **Stats:** 4 total users, 3 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.90 / 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.

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

## Personio Jobs Scraper 🧭

Scrape **every open job from any company hosted on [Personio](https://www.personio.com/)** (jobs.personio.com) — title, full description, location, department, and apply URL — straight from Personio's public job feed. One feed per company returns every position, fully detailed. No login, no anti-bot, no browser.

![How Personio Jobs Scraper works](https://raw.githubusercontent.com/muhamed-didovic/muhamed-didovic.github.io/main/assets/how-it-works-personio.png)

---

### Why use this scraper

- **Complete boards in one call. Personio publishes a single public feed per company — every open position, no pagination, no per-job fetches.**
- **Full job detail in English.** Each row carries the entire job — `descriptionHtml` + plain text (requested in English by default), location(s), department, seniority, schedule, employment type, and the apply URL.
- **Verify every input.** A per-input coverage report (`INPUT-REPORT.csv`) shows link-by-link which companies returned jobs, which were empty, and which weren't Personio boards — and rows stay in your input order.
- **Fast and cheap.** No proxies required (the API has no anti-bot), so runs are quick and your cost stays low.
- **Normalized schema.** Output uses a consistent ATS schema shared with our other ATS scrapers (Ashby, Lever, SmartRecruiters, Personio, BambooHR) — write one parser, reuse it across every ATS.
- **Built-in filters.** Narrow by title, location, department, employment type, remote, or posted date — applied before a row is emitted, so you only pay for matches.

---

### Overview

[Personio](https://www.personio.com/) is a widely-used recruiting platform. Many European companies host their careers on Personio at `https://{company}.jobs.personio.com`. This actor reads each company's jobs through Personio's public job feed and emits one clean, normalized row per open job.

---

### Supported inputs

| Input type | Example | Notes |
|---|---|---|
| **Board URL** | `https://vodeno.jobs.personio.com` | The company subdomain |
| **Bare subdomain** | `vodeno`, `get-e` | The part before .jobs.personio.com |

Provide them in **Start URLs** and/or **Organization slugs**. Mix as many companies as you like in one run.

> **Where's the subdomain?** It's the part before `.jobs.personio.com` in the careers URL.

---

### Use cases

- **Job boards & aggregators** — ingest fresh, structured roles from many companies.
- **Recruiting & sourcing tools** — track who's hiring for what.
- **Market & talent intelligence** — hiring velocity, remote-vs-onsite mix.
- **Lead generation** — companies actively hiring are buying signals for many B2B products.
- **Personal job search** — pull every role across your target companies into one sheet.

---

### How it works

1. **Resolve** each input to a Personio company subdomain.
2. **Fetch** `https://{company}.jobs.personio.com/xml?language=en` — one feed per company. Requesting a language also returns full descriptions for boards whose default feed ships them blank.
3. **Parse** every `<position>` inline (descriptions are included in the feed).
4. **Normalize** to a common ATS schema and **push** one row per job, **in input order**.

Companies are fetched in parallel with a sliding-window concurrency cap, then emitted in the order you supplied them. Every run also writes a per-input coverage report (see [Run coverage report](#run-coverage-report)). No proxy is needed; you can supply one for IP rotation at very large scale.

---

### Input configuration

| Field | Type | Default | Description |
|---|---|---|---|
| `startUrls` | array | – | Personio board URLs or company subdomains (strings or {url} objects). |
| `organizations` | array | – | Bare Personio company subdomains, e.g. ["vodeno","get-e"]. Merged with startUrls. |
| `maxItems` | integer | `5000` | Max job rows emitted across the whole run. |
| `maxConcurrency` | integer | `10` | How many companies to fetch in parallel. |
| `titleKeyword` | string | – | Keep only jobs whose title contains this. |
| `location` | string | – | Keep only jobs whose location contains this. |
| `department` | string | – | Keep only jobs whose department contains this. |
| `employmentType` | string | – | Keep only jobs matching this — matches Personio's **schedule** (Full-time / Part-time) **or** **employment type** (Permanent / Intern / Trainee / Freelance / Working student). |
| `remoteOnly` | boolean | `false` | Keep only remote jobs. |
| `postedAfter` | string | – | Keep only jobs published on/after this date (YYYY-MM-DD). |
| `includeDescription` | boolean | `true` | Include `descriptionHtml` + `descriptionText`. Turn off for leaner/cheaper rows. |
| `language` | string | `en` | Feed language (ISO code). Defaults to `en`, which also fills in descriptions many boards leave blank in their default feed. Leave empty to use each board's own language. |
| `includeRawJson` | boolean | `false` | Attach the original Personio payload under `raw`. |
| `proxy` | object | – | Optional. Not required (no anti-bot); use only for IP rotation at scale. |

#### Example input

```json
{
  "organizations": ["vodeno", "get-e"],
  "maxItems": 500,
  "remoteOnly": true
}
````

***

### Output

One row per open job. Example (trimmed):

```json
{
  "ats": "personio",
  "org": "vodeno",
  "company": "Vodeno",
  "subcompany": "Vodeno S.A.",
  "jobId": "2538321",
  "globalId": "personio:vodeno:2538321",
  "title": "Business Development Manager/Director",
  "department": "Sales",
  "team": "Sales",
  "occupation": "international_sales",
  "occupationCategory": "sales_and_business_development",
  "keywords": ["Business Development", "Sales"],
  "employmentType": "permanent",
  "schedule": "full-time",
  "seniority": "experienced",
  "yearsOfExperience": "3-5",
  "workplaceType": null,
  "isRemote": null,
  "location": "Berlin, Germany",
  "locations": ["Berlin, Germany"],
  "descriptionHtml": "<h3>Your mission</h3>…",
  "descriptionText": "Your mission…",
  "publishedAt": "2026-02-20T11:30:02+00:00",
  "jobUrl": "https://vodeno.jobs.personio.com/job/2538321",
  "applyUrl": "https://vodeno.jobs.personio.com/job/2538321",
  "companyJobsFound": 14,
  "companyOrder": 0,
  "rowInCompany": 3,
  "scrapedAt": "2026-06-14T18:23:00.000Z"
}
```

#### Key output fields

| Field | Description |
|---|---|
| `ats` | Always `"personio"` — the source platform. |
| `org` | Company board identifier. |
| `company` | Company display name (derived from the subdomain). |
| `subcompany` | Legal entity name when the feed carries one, e.g. `"deskbird GmbH"`. |
| `globalId` | Stable, unique key `ats:org:jobId` — use it to dedupe across runs. |
| `title` | Job title. |
| `department` / `team` | Org grouping as set by the company. |
| `occupation` / `occupationCategory` | Personio's role taxonomy (fine + coarse), e.g. `international_sales` / `sales_and_business_development`. |
| `keywords` | Free-text tags the company attached to the role (array, may be empty). |
| `employmentType` | Personio's type: `permanent` / `intern` / `trainee` / `freelance` / `working_student`. |
| `schedule` | `full-time` / `part-time` / `full-or-part-time`. |
| `seniority` / `yearsOfExperience` | Seniority band + years-of-experience range, when set. |
| `workplaceType` / `isRemote` | Remote / Hybrid / OnSite + a boolean remote flag. |
| `location` / `locations` | Primary location + every listed location (including additional offices). |
| `descriptionHtml` / `descriptionText` | Full job description as HTML and plain text. |
| `publishedAt` | When the role was published (ISO). |
| `jobUrl` / `applyUrl` | Public posting URL + application URL. |
| `companyJobsFound` | Total open roles found for this company (before filters/`maxItems`). |
| `companyOrder` / `rowInCompany` | Input position of the company + order of the job within it — sort by these to restore exact input order. |

#### Run coverage report

Every run also writes a **per-input coverage report** to the run's key-value store, so you can verify link-by-link which inputs produced jobs and which did not:

- **`INPUT-REPORT.csv`** — opens directly in Excel / Google Sheets
- **`INPUT-REPORT`** — the same data as JSON

One row per input you supplied, in input order:

| Column | Meaning |
|---|---|
| `input` | The exact URL / slug you supplied. |
| `status` | `ok` (jobs found) · `empty` (live board, 0 open roles) · `failed` (matched a Personio org but the fetch errored) · `unmatched` (not a Personio board — e.g. a Workday or generic careers page) · `duplicate` (same company as an earlier input). |
| `org` | Resolved Personio subdomain (blank if unmatched). |
| `jobsFound` | Open roles in the feed. |
| `jobsEmitted` | Rows actually output after filters + `maxItems`. |
| `error` | Failure reason, when `status = failed`. |

Find it under the run's **Storage → Key-value store**.

***

### FAQ

**Do I need a proxy?** No. Personio's job feed is public with no anti-bot. The proxy field is available only for optional IP rotation at very large scale.

**Where does `company` come from?** The Personio feed has no display name, so it's derived from the subdomain (e.g. `vodeno` → `Vodeno`).

**Some jobs have no description — why?** By default the actor requests the feed in English (`language: "en"`), which returns full descriptions even for boards whose default feed ships them blank. A few positions (e.g. talent-pool / evergreen postings) genuinely carry no description text; those still return every other field.

**Can I force English (or another language)?** Yes — set `language` to any ISO code (default `en`). Personio returns that language's descriptions where the company published them, falling back to its own default otherwise.

**Can I scrape a company's own careers page, or a Workday / embedded page?** This actor reads Personio boards at `{company}.jobs.personio.com` — paste that subdomain or its URL. A generic careers page or a different ATS (e.g. Workday) isn't scraped; it's flagged `unmatched` in the coverage report so you can spot it. If a company only *embeds* Personio on its own site, find the underlying `{company}.jobs.personio.com` address and use that.

**How do I tell which of my input links returned jobs?** Check the per-input coverage report (`INPUT-REPORT.csv`) in the run's key-value store — one row per link with its status and job counts. See [Run coverage report](#run-coverage-report).

**Can it discover every company on Personio?** No — Personio has no public directory of all boards (true for every ATS scraper). You supply the companies you care about.

**How many jobs per company?** Whatever they have open — each row carries `companyJobsFound` (the company's total), and you can cap total output with `maxItems` to control cost.

**How fresh is the data?** Live — every run hits Personio in real time.

***

### Support

Found a bug or need a field added? Open an issue on the actor's **Issues** tab in the Apify Console.

***

### Additional services

Need a different ATS or job board? We also build scrapers for Ashby, Greenhouse, Workday, Indeed, LinkedIn, Glassdoor, and many more. Check our Apify Store profile.

***

### Explore more scrapers

- **Ashby / Greenhouse / Lever Jobs Scrapers** — open roles from those ATS platforms.
- **Workday Jobs Scraper** — jobs from any Workday career site.
- **Indeed / LinkedIn / Glassdoor** — the major job boards, fast and structured.

***

### ⚠️ Disclaimer

This actor collects only **publicly available** job-posting data exposed by Personio's own public job feed. It does not access private, authenticated, or personal data, and does not bypass any access control. You are responsible for using the scraped data in compliance with Personio's terms, the source companies' terms, and all applicable laws (including GDPR/CCPA). Use the data ethically and lawfully.

***

### SEO Keywords

Personio scraper, Personio jobs scraper, jobs.personio.com scraper, Personio job feed, Personio ATS scraper, scrape Personio jobs, Personio careers scraper, ATS job scraper, Europe jobs scraper, job postings API, company careers scraper, hiring data, recruiting data.

# Actor input Schema

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

Personio board URLs (e.g. https://deskbird.jobs.personio.com) or bare company subdomains.

## `organizations` (type: `array`):

Bare Personio company subdomains, e.g. \["vodeno", "get-e"]. The subdomain is the part before .jobs.personio.com. Merged with any Start URLs above.

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

Hard cap on job rows emitted across the whole run (across all companies). Use it to control billing — large boards like OpenAI have 700+ open roles.

## `maxConcurrency` (type: `integer`):

How many company boards to fetch in parallel.

## `titleKeyword` (type: `string`):

Keep only jobs whose title contains this text (case-insensitive), e.g. "engineer".

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

Keep only jobs whose location (primary or secondary) contains this text, e.g. "remote", "London", "New York".

## `department` (type: `string`):

Keep only jobs whose department contains this text, e.g. "Engineering".

## `employmentType` (type: `string`):

Keep only jobs matching this. Matches Personio's schedule (Full-time / Part-time) OR employment type (Permanent / Intern / Trainee / Freelance / Working student), case-insensitive.

## `remoteOnly` (type: `boolean`):

Keep only jobs flagged remote.

## `postedAfter` (type: `string`):

Keep only jobs published on or after this date (YYYY-MM-DD). Ideal for scheduled monitoring runs that only want fresh roles.

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

Include `descriptionHtml` and `descriptionText` on each row. Turn off for leaner, cheaper rows when you only need title/location/compensation/links.

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

ISO language code requested from Personio's feed (e.g. "en", "de", "fr"). Defaults to "en", which also fills in descriptions many boards leave empty in their default feed. Leave blank to use each board's own default language. Note: only languages the company actually published are available — Personio falls back to its default if the requested one is missing.

## `includeRawJson` (type: `boolean`):

Attach the original, unmodified Personio position to each row under a `raw` field. Useful for advanced fields not in the normalized schema. Off by default to keep rows lean.

## `enrichEmails` (type: `boolean`):

If enabled, tries to find a contact email for the company by discovering its website (Clearbit) and reading its contact/about pages. Adds contactEmail + contactWebsite columns plus a detailed emailEnrichment object. Best-effort.

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

Optional. Personio's public feed has no anti-bot, so a proxy is NOT required. Only enable it if you want IP rotation when scraping very large numbers of companies.

## Actor input object example

```json
{
  "startUrls": [
    "https://deskbird.jobs.personio.com"
  ],
  "organizations": [
    "vodeno",
    "get-e"
  ],
  "maxItems": 5000,
  "maxConcurrency": 10,
  "remoteOnly": false,
  "includeDescription": true,
  "language": "en",
  "includeRawJson": false,
  "enrichEmails": false
}
```

# 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 = {
    "startUrls": [
        "https://deskbird.jobs.personio.com"
    ],
    "organizations": [
        "vodeno",
        "get-e"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("memo23/personio-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 = {
    "startUrls": ["https://deskbird.jobs.personio.com"],
    "organizations": [
        "vodeno",
        "get-e",
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("memo23/personio-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 '{
  "startUrls": [
    "https://deskbird.jobs.personio.com"
  ],
  "organizations": [
    "vodeno",
    "get-e"
  ]
}' |
apify call memo23/personio-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Personio Jobs Scraper & API — Any Company",
        "description": "Scrape every open job from any company on Personio (jobs.personio.com). Give a company subdomain and get each position with full description, location, department, employment type and apply URL — from the public feed. Filter by title, location, remote. No proxy. JSON or CSV out.",
        "version": "0.0",
        "x-build-id": "c0G4hl9Blmfo7xGa3"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/memo23~personio-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-memo23-personio-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/memo23~personio-scraper/runs": {
            "post": {
                "operationId": "runs-sync-memo23-personio-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/memo23~personio-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-memo23-personio-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": {
                    "startUrls": {
                        "title": "Personio board URLs",
                        "type": "array",
                        "description": "Personio board URLs (e.g. https://deskbird.jobs.personio.com) or bare company subdomains.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "organizations": {
                        "title": "Organization slugs",
                        "type": "array",
                        "description": "Bare Personio company subdomains, e.g. [\"vodeno\", \"get-e\"]. The subdomain is the part before .jobs.personio.com. Merged with any Start URLs above.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "Maximum jobs to scrape",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Hard cap on job rows emitted across the whole run (across all companies). Use it to control billing — large boards like OpenAI have 700+ open roles.",
                        "default": 5000
                    },
                    "maxConcurrency": {
                        "title": "Max concurrency",
                        "minimum": 1,
                        "type": "integer",
                        "description": "How many company boards to fetch in parallel.",
                        "default": 10
                    },
                    "titleKeyword": {
                        "title": "Title contains",
                        "type": "string",
                        "description": "Keep only jobs whose title contains this text (case-insensitive), e.g. \"engineer\"."
                    },
                    "location": {
                        "title": "Location contains",
                        "type": "string",
                        "description": "Keep only jobs whose location (primary or secondary) contains this text, e.g. \"remote\", \"London\", \"New York\"."
                    },
                    "department": {
                        "title": "Department contains",
                        "type": "string",
                        "description": "Keep only jobs whose department contains this text, e.g. \"Engineering\"."
                    },
                    "employmentType": {
                        "title": "Employment type / schedule",
                        "enum": [
                            "Full-time",
                            "Part-time",
                            "Permanent",
                            "Intern",
                            "Trainee",
                            "Freelance",
                            "Working student",
                            "Apprenticeship"
                        ],
                        "type": "string",
                        "description": "Keep only jobs matching this. Matches Personio's schedule (Full-time / Part-time) OR employment type (Permanent / Intern / Trainee / Freelance / Working student), case-insensitive."
                    },
                    "remoteOnly": {
                        "title": "Remote only",
                        "type": "boolean",
                        "description": "Keep only jobs flagged remote.",
                        "default": false
                    },
                    "postedAfter": {
                        "title": "Posted on/after",
                        "type": "string",
                        "description": "Keep only jobs published on or after this date (YYYY-MM-DD). Ideal for scheduled monitoring runs that only want fresh roles."
                    },
                    "includeDescription": {
                        "title": "Include full job description",
                        "type": "boolean",
                        "description": "Include `descriptionHtml` and `descriptionText` on each row. Turn off for leaner, cheaper rows when you only need title/location/compensation/links.",
                        "default": true
                    },
                    "language": {
                        "title": "Job description language",
                        "type": "string",
                        "description": "ISO language code requested from Personio's feed (e.g. \"en\", \"de\", \"fr\"). Defaults to \"en\", which also fills in descriptions many boards leave empty in their default feed. Leave blank to use each board's own default language. Note: only languages the company actually published are available — Personio falls back to its default if the requested one is missing.",
                        "default": "en"
                    },
                    "includeRawJson": {
                        "title": "Include raw Personio payload",
                        "type": "boolean",
                        "description": "Attach the original, unmodified Personio position to each row under a `raw` field. Useful for advanced fields not in the normalized schema. Off by default to keep rows lean.",
                        "default": false
                    },
                    "enrichEmails": {
                        "title": "Enrich with company contact emails (experimental)",
                        "type": "boolean",
                        "description": "If enabled, tries to find a contact email for the company by discovering its website (Clearbit) and reading its contact/about pages. Adds contactEmail + contactWebsite columns plus a detailed emailEnrichment object. Best-effort.",
                        "default": false
                    },
                    "proxy": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional. Personio's public feed has no anti-bot, so a proxy is NOT required. Only enable it if you want IP rotation when scraping very large numbers of companies."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
