# Arbeitsagentur.de - Job Scraper, Bundesagentur für Arbeit (`mof1re/arbeitsagentur-scraper`) Actor

Fast, browser-free scraper for German job and Ausbildung listings from arbeitsagentur.de via internal web API. Solves captchas automatically, uses own proxies(zero proxy charge), and returns full company and contact details alongside each ad — the most complete dataset available for this source.

- **URL**: https://apify.com/mof1re/arbeitsagentur-scraper.md
- **Developed by:** [Vladimir Efimenco](https://apify.com/mof1re) (community)
- **Categories:** Developer tools, Jobs, Lead generation
- **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.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

## German Job Ads Scraper (Arbeitsagentur), 🇩🇪 Bundesagentur für Arbeit

Fast, browser-free scraper for job and Ausbildung listings from **arbeitsagentur.de** — built on the site's internal API, not a headless browser. Every ad comes back enriched with full company profile and contact details, not just the search-result snippet.

### ⚡ Why this one


- **Most complete dataset available for this source** — merges three separate upstream endpoints (search results, company profile, contact details) into one flat record per ad. Most alternatives only give you the search snippet.
- **CAPTCHA solved automatically** — the Arbeitsagentur contact endpoint is protected by an image captcha. This actor runs its own OCR solver, so contact details (email, phone, application links) come back without manual intervention.
- **All Public data only** — everything returned here is publicly visible on arbeitsagentur.de. No login bypass, no private data access, no ToS-violating scraping technique. Just structured extraction of what's already public.
- **Proxies included** — residential proxy pool is built in. You don't need to bring your own.
- **Fast** — no browser, no rendering wait. Pure HTTP calls to the same API the arbeitsagentur.de frontend uses.

### 🧾 What you get, per job ad

- Job details — title, profession, offer type, training type, salary by year, working hours, remote eligibility, dates
- Company profile — description, size, founding year, headquarters, photos, social links, employee benefits
- Contact details — name, email, phone, postal address, accepted application methods
- Optional keyword matching flag (`word_match`) against your own keyword list

### 📋 Example output

```json
{
  "job_title": "Fachinformatiker/in - Anwendungsentwicklung",
  "main_profession": "Fachinformatiker/in",
  "job_offer_type": "Ausbildung",
  "reference_number": "10001-1234567890-S",
  "training_salary_year_1": "1.100 €",
  "training_salary_year_2": "1.200 €",
  "full_time": true,
  "job_locations": [
    { "city": "Berlin", "zip_code": "10115", "latitude": 52.5321, "longitude": 13.3846 }
  ],
  "company": "Example GmbH",
  "company_description": "IT services company specializing in...",
  "company_size": "50-249 employees",
  "founding_year": "1998",
  "contact_name": "Frau Schmidt",
  "contact_email": "jobs@example.de",
  "contact_phone": "+49 30 1234567",
  "apply_online": true,
  "word_match": false
}
````

*(field descriptions below — full list of ~60 fields is also documented in the actor's dataset schema, visible in the Output tab)*

### 📊 Data Fields

#### 💼 Job Details

| Field | Description |
|---|---|
| `job_title` | Job posting title |
| `main_profession` | Primary profession/occupation category |
| `job_offer_type` | Type of job offer (e.g. Ausbildung, dual study) |
| `training_type` | Type of vocational training |
| `reference_number` | Arbeitsagentur reference number for the ad |
| `reference_code` | Employer's own reference/chiffre code |
| `external_url` | External application URL, if the employer posts off-platform |
| `suitable_for_career_changers` | Whether career changers are accepted |
| `study_format` | Dual study format, if applicable |
| `degree_program` | Degree program name, if applicable |
| `training_salary_year_1` | Training salary, year 1 |
| `training_salary_year_2` | Training salary, year 2 |
| `training_salary_year_3` | Training salary, year 3 |
| `training_salary_year_4` | Training salary, year 4 |
| `salary_disclosure` | General salary/pay disclosure text |
| `contract_duration` | Contract duration, if fixed-term |
| `shift_night_weekend_work` | Whether shift/night/weekend work is required |
| `full_time` | Full-time position |
| `part_time_morning/afternoon/evening/flexible` | Part-time availability windows |
| `remote_work_possible` | Whether remote/home office work is possible |
| `is_minor_employment` | Whether this is minor/marginal employment (Minijob) |
| `disability_required` | Whether a disability status is required |
| `is_private_employment_agency` | Whether posted by a private employment agency |
| `is_temp_staffing` | Whether this is temp/staffing agency work |
| `is_managed_account` | Whether the employer account is agency-managed |
| `job_locations` | List of job location objects (address, city, coordinates) |
| `start_date_range` | Earliest/latest possible start date range |
| `publication_period` | Publication date range used in the search filter |
| `first_published_date` | Date the ad was first published |
| `last_modified_date` | Date the ad was last modified |
| `all_professions` | All profession codes associated with the ad |
| `employer_customer_id_hash` | Hashed employer customer ID, used to fetch company profile |

#### 🏢 Company Profile

| Field | Description |
|---|---|
| `company` | Company/employer name |
| `company_description` | Company profile description text |
| `company_headquarters` | Company headquarters city |
| `company_size` | Company size category |
| `founding_year` | Year the company was founded |
| `company_images` | List of company photo URLs |
| `company_links` | Company website/other links by type |
| `social_media_links` | Company social media links by platform |
| `company_tags` | Company profile tags/keywords |
| `company_employee_benefits` | List of employee benefits offered |
| `company_contact_information` | Raw company contact info block |
| `similar_search_terms` | Related search terms suggested by the API |

#### 📇 Contact & Application

| Field | Description |
|---|---|
| `contact_name` | Contact person's full name |
| `contact_company` | Contact person's company name |
| `contact_salutation` | Contact person's salutation |
| `contact_email` | Contact email address |
| `contact_phone` | Contact phone number, formatted |
| `contact_address` | Contact postal address |
| `apply_via_arbeitsagentur_de` | Whether applications go through arbeitsagentur.de |
| `apply_online` | Whether online applications are accepted |
| `apply_by_email` | Whether applications can be sent by email |
| `apply_in_person` | Whether in-person applications are accepted |
| `apply_in_writing` | Whether written/postal applications are accepted |
| `apply_by_phone` | Whether phone applications are accepted |
| `application_form_url` | URL to the online application form |
| `required_documents` | List of documents required to apply |

#### 🎯 Matching

| Field | Description |
|---|---|
| `word_match` | `true` if the ad matched any keyword from your `matchWords` input |

### 🔧 Input options

| Field | Description |
|---|---|
| `query` | Search keyword (job title, profession) |
| `cities` | One or more German cities (multi-select) |
| `zipCode` + `area` | Radius search around a ZIP code (10–200 km) |
| `publishedSince` | Today / yesterday / 1 / 2 / 4 weeks |
| `workingHours` | Full time / part time |
| `matchWords` | Your own keyword list — flags matching ads |
| `maxResults` | How many ads to fetch total |

### 💳 Pricing

Pay-per-result. You're charged for ads actually delivered, not for pages fetched or requests made.

### ⚠️ Notes

- Free-tier accounts are capped at a small sample size per run — upgrade to a paid Apify plan for full volume.
- Data reflects what's publicly listed on arbeitsagentur.de at the time of the run; the source updates continuously.

# Actor input Schema

## `query` (type: `string`):

Job title / keyword to search for (was= param)

## `cities` (type: `array`):

Pick one or more cities. Sent to the API joined with ';' as arbeitsort=City1;City2

## `zipCode` (type: `string`):

Optional. Required if you want to use the 'area' radius filter (wo= param)

## `area` (type: `string`):

Only applied if ZIP code is set (umkreis= param)

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

How far back to search (veroeffentlichtseit= param)

## `workingHours` (type: `string`):

Full time or part time (arbeitszeit= param)

## `matchWords` (type: `array`):

List of keywords to flag matching ads (checked against job title / profession / company description). Leave empty to skip matching.

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

Total number of job ads to fetch. Pages are fetched at 200 results/page, stopping early if the source runs out of results. Max 5000

## Actor input object example

```json
{
  "query": "",
  "cities": [],
  "area": "10",
  "publishedSince": "4",
  "matchWords": [],
  "maxResults": 100
}
```

# Actor output Schema

## `jobAds` (type: `string`):

No description

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("mof1re/arbeitsagentur-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 = {}

# Run the Actor and wait for it to finish
run = client.actor("mof1re/arbeitsagentur-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 '{}' |
apify call mof1re/arbeitsagentur-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Arbeitsagentur.de - Job Scraper, Bundesagentur für Arbeit",
        "description": "Fast, browser-free scraper for German job and Ausbildung listings from arbeitsagentur.de via internal web API. Solves captchas automatically, uses own proxies(zero proxy charge), and returns full company and contact details alongside each ad — the most complete dataset available for this source.",
        "version": "0.1",
        "x-build-id": "4dfFgNbT7oi6qEme2"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/mof1re~arbeitsagentur-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-mof1re-arbeitsagentur-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/mof1re~arbeitsagentur-scraper/runs": {
            "post": {
                "operationId": "runs-sync-mof1re-arbeitsagentur-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/mof1re~arbeitsagentur-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-mof1re-arbeitsagentur-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": [
                    "query"
                ],
                "properties": {
                    "query": {
                        "title": "Search query",
                        "type": "string",
                        "description": "Job title / keyword to search for (was= param)",
                        "default": ""
                    },
                    "cities": {
                        "title": "Cities",
                        "type": "array",
                        "description": "Pick one or more cities. Sent to the API joined with ';' as arbeitsort=City1;City2",
                        "items": {
                            "type": "string",
                            "enum": [
                                "Berlin",
                                "Hamburg",
                                "München",
                                "Köln",
                                "Düsseldorf",
                                "Nürnberg, Mittelfranken",
                                "Stuttgart",
                                "Bremen",
                                "Dortmund",
                                "Hannover",
                                "Frankfurt am Main",
                                "Essen, Ruhr",
                                "Duisburg",
                                "Karlsruhe, Baden",
                                "Münster, Westfalen",
                                "Dresden",
                                "Bochum",
                                "Mönchengladbach",
                                "Leipzig",
                                "Mannheim",
                                "Würzburg",
                                "Aachen",
                                "Bielefeld",
                                "Lübeck",
                                "Freiburg im Breisgau",
                                "Augsburg, Bayern",
                                "Ulm, Donau",
                                "Wuppertal",
                                "Heilbronn, Neckar",
                                "Regensburg",
                                "Osnabrück",
                                "Kiel",
                                "Braunschweig",
                                "Bonn",
                                "Aalen, Württemberg",
                                "Oldenburg (Oldb)",
                                "Krefeld",
                                "Kassel, Hessen",
                                "Trier",
                                "Weiden in der Oberpfalz",
                                "Gelsenkirchen",
                                "Hamm, Westfalen",
                                "Paderborn",
                                "Heidelberg, Neckar",
                                "Memmingen",
                                "Ingolstadt, Danube",
                                "Saarbrücken",
                                "Magdeburg",
                                "Reutlingen",
                                "Hagen, Westphalia",
                                "Oberhausen, Rheinland",
                                "Koblenz am Rhein",
                                "Chemnitz, Saxony",
                                "Bocholt",
                                "Mülheim an der Ruhr",
                                "Siegen",
                                "Ludwigshafen am Rhein",
                                "Esslingen am Neckar",
                                "Fulda",
                                "Straubing",
                                "Pforzheim",
                                "Bremerhaven",
                                "Erfurt",
                                "Bayreuth",
                                "Gera",
                                "Baden-Baden",
                                "Fürth, Bayern",
                                "Schweinfurt",
                                "Rheine",
                                "Kempten (Allgäu)",
                                "Mainz am Rhein",
                                "Offenburg",
                                "Göppingen",
                                "Herne, Westphalia",
                                "Bamberg",
                                "Papenburg",
                                "Wiesbaden",
                                "Passau",
                                "Erlangen",
                                "Halle (Saale)",
                                "Neuss",
                                "Lingen (Ems)",
                                "Potsdam",
                                "Rostock",
                                "Nördlingen",
                                "Arnsberg, Westfalen",
                                "Villingen-Schwenningen",
                                "Darmstadt",
                                "Melle, Wiehengebirge",
                                "Gießen, Lahn",
                                "Neumünster, Holstein",
                                "Lüneburg",
                                "Nordhorn",
                                "Marburg",
                                "Neu-Ulm",
                                "Schwerin, Mecklenburg",
                                "Rosenheim, Upper Bavaria",
                                "Flensburg",
                                "Detmold",
                                "Recklinghausen, Westphalia",
                                "Berkheim, Kreis Biberach an der Riß"
                            ]
                        },
                        "default": []
                    },
                    "zipCode": {
                        "title": "ZIP code",
                        "type": "string",
                        "description": "Optional. Required if you want to use the 'area' radius filter (wo= param)"
                    },
                    "area": {
                        "title": "Search radius (km)",
                        "enum": [
                            "10",
                            "15",
                            "25",
                            "50",
                            "100",
                            "200"
                        ],
                        "type": "string",
                        "description": "Only applied if ZIP code is set (umkreis= param)",
                        "default": "10"
                    },
                    "publishedSince": {
                        "title": "Published since",
                        "enum": [
                            "0",
                            "1",
                            "2",
                            "3",
                            "4"
                        ],
                        "type": "string",
                        "description": "How far back to search (veroeffentlichtseit= param)",
                        "default": "4"
                    },
                    "workingHours": {
                        "title": "Working hours",
                        "enum": [
                            "vz",
                            "tz"
                        ],
                        "type": "string",
                        "description": "Full time or part time (arbeitszeit= param)"
                    },
                    "matchWords": {
                        "title": "Match words",
                        "type": "array",
                        "description": "List of keywords to flag matching ads (checked against job title / profession / company description). Leave empty to skip matching.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxResults": {
                        "title": "Max results",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Total number of job ads to fetch. Pages are fetched at 200 results/page, stopping early if the source runs out of results. Max 5000",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
