# Personio Jobs Scraper (`devilscrapes/personio-jobs-scraper`) Actor

Scrape every open job posting from any Personio-powered company career page via Personio's own public XML feed, no login or browser required. Get job titles, offices, departments, and full descriptions instantly for recruiter pipelines or as a DACH-region hiring-intent signal for sales and BD teams.

- **URL**: https://apify.com/devilscrapes/personio-jobs-scraper.md
- **Developed by:** [DevilScrapes](https://apify.com/devilscrapes) (community)
- **Categories:** Jobs
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.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.

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/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

<div align="center">
  <img src=".actor/icon.svg" width="160" alt="Devil Scrapes mark" />

## Personio Jobs Scraper

**💰 $0.005 actor start + $1.50 / 1 000 jobs** &nbsp;·&nbsp; pay only for results that land &nbsp;·&nbsp; no credit card to try

_The devil's in the data._ 😈

Scrape every open job posting from any Personio-powered company career page via Personio's own public XML feed — no login, no browser, no cookies. Point it at one or a thousand `{company}.jobs.personio.de` boards and get one clean row per posting: title, offices, department, seniority, and full description, ready for recruiter pipelines or as a DACH-region hiring-intent signal.

</div>

---

### 🎯 What this scrapes

Personio is Germany's leading HR/recruiting SaaS, and every company that uses it to publish open roles gets a career page at `https://{company}.jobs.personio.de`. Behind that page sits a public, unauthenticated XML feed (legacy `workzag-jobs` branding) that lists every currently-open position for that employer — job title, office, department, employment type, seniority, years of experience, keywords, and the full job description split into named sections.

This Actor walks that feed for any list of company subdomains you supply, resolves full career-page URLs down to the bare subdomain automatically, and emits one normalised, Pydantic-validated row per open position. It absorbs the retry/backoff and per-company failure isolation this feed needs in production so one bad subdomain never derails the rest of your run.

### 🔥 Features

- 🛡️ **We rotate browser fingerprints** — `curl-cffi` impersonates real Chrome / Firefox TLS handshakes so the target sees a browser, not a bare Python client.
- 🔁 **We retry with exponential backoff** on `408 / 429 / 5xx` — up to 5 attempts per company, `Retry-After` honoured.
- 🌐 **We rotate Apify Proxy sessions** on every block — fresh session ID, fresh exit IP.
- 🧱 **Per-company failure isolation** — one company's request failure never stops the rest of the run; the final status message reports exactly how many of N companies returned data.
- 🧊 **Clean, typed dataset rows** — Pydantic-validated, ISO-8601 timestamps, stable `(company, position_id)` keys, JSON / CSV / Excel export straight from the Apify Console.
- 📝 **Flexible company input** — a bare subdomain (`"chrono24"`) or a full `https://{company}.jobs.personio.de` URL, with or without the trailing `/xml` path, resolves the same way.
- 📄 **Optional full HTML descriptions** — keep the plain-text description always, or opt into the raw HTML sections for richer downstream rendering.
- 💰 **You pay only for results that land.** No data → no charge (only the small actor-start warm-up fee).

### 💡 Use cases

- **DACH-region recruiter pipelines** — pull every open role across a portfolio of German, Austrian, and Swiss employers into one normalised feed alongside `teamtailor-jobs-scraper`, `workday-jobs-scraper`, and the rest of this fleet's ATS coverage.
- **Hiring-intent signal for sales and BD teams** — track headcount growth, new-market entry, and tech-stack changes visible in job descriptions as a lead-scoring input.
- **Job-board aggregators** — fold Personio-hosted postings into a multi-ATS aggregator alongside Greenhouse, Lever, Workday, and Teamtailor feeds.
- **Competitive intelligence** — monitor a competitor's open roles over time to infer strategic priorities (which office is scaling, which department is hiring hardest).
- **Academic / labour-market research** — a structured, machine-readable sample of DACH-region job postings for wage- or skills-demand studies.
- **HR-tech tooling** — build a Personio-compatible job board mirror, alert bot, or Slack digest from the same normalised rows.

### ⚙️ How to use it

1. Open the Actor in Apify Console (or call it via the API/SDK).
2. Fill in `companies` with one or more Personio subdomains or career-page URLs.
3. Optionally set `maxJobsPerCompany` and `includeHtml`.
4. Run it. Results land in the default dataset as they're scraped — export to JSON, CSV, or Excel directly from the Console, or pull them via the API.

```json
{
  "companies": ["chrono24", "urbansportsclub"],
  "maxJobsPerCompany": 100,
  "includeHtml": false,
  "proxyConfiguration": { "useApifyProxy": true }
}
````

### 📥 Input

| Field | Type | Default | Description |
|---|---|---|---|
| `companies` | array of strings | — (required) | Personio subdomain (e.g. `"chrono24"`) or full `https://{company}.jobs.personio.de` URL. A custom-domain career page is not resolvable — use the bare Personio subdomain. |
| `maxJobsPerCompany` | integer | `100` | Cap job postings emitted per `companies` entry, applied after parsing. |
| `includeHtml` | boolean | `false` | Populate `description_html` (concatenated job-description sections) for every row. `description_text` is always populated regardless. |
| `proxyConfiguration` | object | `{"useApifyProxy": true}` | Apify Proxy configuration. |

### 📤 Output

One dataset row per open job posting:

| Field | Type | Description |
|---|---|---|
| `company` | string | Normalized input subdomain. |
| `position_id` | integer | Stable within one company's feed; `(company, position_id)` is the uniqueness key. |
| `job_title` | string | Position title. |
| `subcompany` | string | null | Sub-brand/entity, if the employer splits postings across several. |
| `office` | string | null | Primary office location. |
| `additional_offices` | array | null | Other offices this posting is open to, in feed order. |
| `department` | string | null | Department name. |
| `recruiting_category` | string | null | Personio's recruiting category tag. |
| `employment_type` | string | null | Full-time / part-time / etc. |
| `seniority` | string | null | Seniority level. |
| `schedule` | string | null | Schedule (e.g. flexible, fixed). |
| `years_of_experience` | string | null | Required experience band. |
| `keywords` | array | null | Comma-split keyword tags. |
| `occupation` | string | null | Occupation classification. |
| `occupation_category` | string | null | Broader occupation category. |
| `created_at` | string | ISO-8601 posting creation timestamp. |
| `job_url` | string | Constructed `https://{company}.jobs.personio.de/job/{position_id}` link. |
| `description_html` | string | null | Raw HTML, only when `includeHtml` is enabled. |
| `description_text` | string | Plain-text description, always populated. |
| `scraped_at` | string | ISO-8601 wall-clock time this row was scraped. |

```json
{
  "company": "chrono24",
  "position_id": 1234567,
  "job_title": "Senior Backend Engineer",
  "subcompany": null,
  "office": "Karlsruhe",
  "additional_offices": null,
  "department": "Engineering",
  "recruiting_category": "Tech",
  "employment_type": "Full-time",
  "seniority": "Senior",
  "schedule": null,
  "years_of_experience": "3-5 years",
  "keywords": ["backend", "python", "aws"],
  "occupation": "Software Development",
  "occupation_category": "IT",
  "created_at": "2026-06-01T09:00:00",
  "job_url": "https://chrono24.jobs.personio.de/job/1234567",
  "description_html": null,
  "description_text": "We are looking for a Senior Backend Engineer to join our team ...",
  "scraped_at": "2026-07-26T12:00:00Z"
}
```

### 💰 Pricing

Pay-Per-Event — you're charged only for what actually runs and lands:

| Event | Price | When |
|---|---|---|
| `actor-start` | $0.005 | Once per run |
| `result` | $0.0015 | Per job posting written to the dataset |

At $0.0015/job that's **$1.50 per 1,000 postings** plus a flat $0.005 warm-up fee per run — no subscription, no minimum spend, no charge for companies that return zero jobs.

### 🚧 Limitations

- **Personio only.** This Actor does not cover Greenhouse, Lever, Ashby, Workday, SmartRecruiters, Workable, Teamtailor, or BambooHR career sites — see `multi-ats-jobs-scraper`, `workday-jobs-scraper`, `smartrecruiters-jobs-scraper`, `workable-jobs-scraper`, and `teamtailor-jobs-scraper` for those, together an "ATS Jobs Intel" suite.
- **Bare subdomain only.** Custom-domain career sites (e.g. a company's own `careers.example.com` even if it's Personio-powered behind the scenes) are not resolvable — supply the `{company}.jobs.personio.de` form.
- **No expiry field.** Personio's feed doesn't expose a `validThrough`/expiry date — only currently-open postings appear at all; there's no way to tell how long a listing has been live beyond `created_at`.
- **One row per posting.** `additional_offices` is returned as a list column on that same row, not exploded into extra rows per office.
- **`job_url` is a convenience link.** It's constructed from the feed's `position_id`, not independently verified by loading every page — in the rare case a company's job pages differ, treat it as a best-effort deep link.
- **Live-only.** No historical or removed postings — only what the feed currently returns.

### ❓ FAQ

**Do I need a Personio account or API key?**
No. The XML feed backing this Actor is public and unauthenticated — you only need the company's subdomain.

**What if I paste a full career-page URL instead of a subdomain?**
Both work. `https://chrono24.jobs.personio.de` and `chrono24` resolve to the same company.

**What happens if a subdomain has no Personio board?**
The company is treated as returning zero jobs — the run doesn't fail, and the final status message says how many of your companies returned data versus how many failed outright.

**Can I get the raw HTML description instead of plain text?**
Yes — set `includeHtml` to `true`. The plain-text `description_text` field is always populated either way.

**How fresh is the data?**
Each run fetches the feed live at request time — there's no caching layer between your run and Personio's own board.

### 🐛 Your feedback

Found a Personio board this Actor doesn't handle right, or want a field added? Open an issue on the Actor's Apify Store page or reach out via <https://apify.com/DevilScrapes> — we read every report.

# Actor input Schema

## `companies` (type: `array`):

Personio company subdomain, e.g. "chrono24" (the employer identifier in https://{company}.jobs.personio.de/), or a full https://{company}.jobs.personio.de URL (with or without a trailing /xml path) — the subdomain is regex-extracted. A plain string with no "jobs.personio.de" substring is used as the literal subdomain; a custom-domain URL is rejected — use the bare {company}.jobs.personio.de subdomain instead.

## `maxJobsPerCompany` (type: `integer`):

Cap job postings emitted per companies entry, applied after parsing.

## `includeHtml` (type: `boolean`):

When enabled, populate description\_html (concatenated jobDescription sections) for every emitted row. description\_text (HTML-tag-stripped) is always populated regardless.

## `proxyConfiguration` (type: `object`):

Apify Proxy configuration. No anti-bot behaviour has been observed on Personio's public XML feed, so the standard (non-residential) group is enough.

## Actor input object example

```json
{
  "companies": [
    "chrono24",
    "urbansportsclub"
  ],
  "maxJobsPerCompany": 100,
  "includeHtml": false,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `datasetItems` (type: `string`):

All dataset items as JSON.

## `datasetItemsCsv` (type: `string`):

Same data exported to CSV.

## `datasetView` (type: `string`):

Open the run dataset in the Console.

# 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 = {
    "companies": [
        "chrono24",
        "urbansportsclub"
    ],
    "maxJobsPerCompany": 100,
    "includeHtml": false,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("devilscrapes/personio-jobs-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 = {
    "companies": [
        "chrono24",
        "urbansportsclub",
    ],
    "maxJobsPerCompany": 100,
    "includeHtml": False,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("devilscrapes/personio-jobs-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 '{
  "companies": [
    "chrono24",
    "urbansportsclub"
  ],
  "maxJobsPerCompany": 100,
  "includeHtml": false,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call devilscrapes/personio-jobs-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Personio Jobs Scraper",
        "description": "Scrape every open job posting from any Personio-powered company career page via Personio's own public XML feed, no login or browser required. Get job titles, offices, departments, and full descriptions instantly for recruiter pipelines or as a DACH-region hiring-intent signal for sales and BD teams.",
        "version": "0.0",
        "x-build-id": "a3ISEKZVe9Idq7EyT"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/devilscrapes~personio-jobs-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-devilscrapes-personio-jobs-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/devilscrapes~personio-jobs-scraper/runs": {
            "post": {
                "operationId": "runs-sync-devilscrapes-personio-jobs-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/devilscrapes~personio-jobs-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-devilscrapes-personio-jobs-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",
                "required": [
                    "companies"
                ],
                "properties": {
                    "companies": {
                        "title": "Companies",
                        "minItems": 1,
                        "maxItems": 1000,
                        "type": "array",
                        "description": "Personio company subdomain, e.g. \"chrono24\" (the employer identifier in https://{company}.jobs.personio.de/), or a full https://{company}.jobs.personio.de URL (with or without a trailing /xml path) — the subdomain is regex-extracted. A plain string with no \"jobs.personio.de\" substring is used as the literal subdomain; a custom-domain URL is rejected — use the bare {company}.jobs.personio.de subdomain instead."
                    },
                    "maxJobsPerCompany": {
                        "title": "Max jobs per company",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Cap job postings emitted per companies entry, applied after parsing.",
                        "default": 100
                    },
                    "includeHtml": {
                        "title": "Include HTML description",
                        "type": "boolean",
                        "description": "When enabled, populate description_html (concatenated jobDescription sections) for every emitted row. description_text (HTML-tag-stripped) is always populated regardless.",
                        "default": false
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Apify Proxy configuration. No anti-bot behaviour has been observed on Personio's public XML feed, so the standard (non-residential) group is enough.",
                        "default": {
                            "useApifyProxy": 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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
