# Jobware.de Jobs Scraper (`automation-lab/jobware-de-jobs-scraper`) Actor

Extract German job postings from Jobware.de with titles, companies, locations, descriptions, apply URLs, and source search metadata.

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

## Pricing

Pay per event

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## Jobware.de Jobs Scraper

Extract German job postings from Jobware.de search results and job detail pages. The actor returns structured listings with job title, company, location, employment type, apply URL, canonical job URL, posting dates, and optional full description text.

### What does Jobware.de Jobs Scraper do?

Jobware.de Jobs Scraper collects public job ads from Jobware.de, a German professional job board. Give it keywords, a location, or Jobware search URLs and it saves clean job records to an Apify dataset.

The actor uses Jobware's public web APIs behind the visible search pages, so it is fast and lightweight. It does not open a browser by default.

### Who is it for?

- 🧲 **Recruiters** monitoring roles and hiring companies in Germany.
- 📈 **B2B lead generation teams** finding companies with current hiring intent.
- 📰 **Job-board aggregators** refreshing German job inventory.
- 🧪 **Labor-market analysts** tracking demand by skill, title, and city.
- 🧰 **Sales operations teams** building account lists from hiring signals.

### Why use this Jobware scraper?

- Searches Jobware.de by keyword and optional location.
- Accepts direct Jobware `/jobsuche` URLs.
- Fetches full detail descriptions when enabled.
- Returns source query and page metadata for auditability.
- Runs with low memory and no browser overhead.
- Supports optional Apify Proxy only when you need it.

### Data you can extract

| Field | Description |
| --- | --- |
| `title` | Job title |
| `companyName` | Hiring company name |
| `location` | Jobware listing location |
| `locations` | Location list from detail payload |
| `employmentTypes` | Full-time, part-time, and similar labels when provided |
| `postedAt` | Posting date as ISO timestamp |
| `expiryAt` | Expiry date when available |
| `description` | Full cleaned job description when detail fetching is enabled |
| `applyUrl` | Jobware application URL |
| `detailUrl` | Canonical Jobware job URL |
| `sourceQuery` | Keyword used for the search |
| `sourceLocation` | Location used for the search |

### How much does it cost to scrape Jobware.de jobs?

This actor uses pay-per-event pricing. You pay a small start fee plus a per-job result fee. The exact live prices are shown on the Apify actor page before you run it.

To keep first runs affordable, the default input is capped at 100 jobs and proxy use is disabled.

### Input options

#### Keywords

Use `keywords` for role names, skills, industries, or German search phrases, for example:

```json
{
  "keywords": ["data analyst", "software engineer"],
  "location": "Berlin",
  "maxItems": 100
}
````

#### Location

Use `location` for a city or region. Jobware may also return remote or multi-city listings if they match the search.

#### Start URLs

You can paste Jobware search URLs instead of keywords:

```json
{
  "startUrls": [
    { "url": "https://www.jobware.de/jobsuche?jw_jobname=controller&jw_jobort=Hamburg" }
  ],
  "maxItems": 50
}
```

#### Full details

Set `includeDetails` to `true` to fetch each detail endpoint and add the full description, canonical URL, expiry date, and richer company data. Turn it off for faster search-only runs.

### Output example

```json
{
  "title": "Data Analyst & KI (m/w/d) Growth",
  "companyName": "Verlag Herder GmbH",
  "location": "Freiburg, München, Berlin oder 100% remote",
  "employmentTypes": [],
  "postedAt": "2026-07-02T05:00:00.000Z",
  "expiryAt": "2026-08-01T21:59:59.000Z",
  "jobId": "1993058575",
  "businessReference": "062492150",
  "description": "Du möchtest datengetriebenes Wachstum aktiv mitgestalten...",
  "applyUrl": "https://www.jobware.de/apply/...",
  "detailUrl": "https://www.jobware.de/job/data-analyst-ki-m-w-d-growth.1993058575.html",
  "sourceQuery": "data analyst",
  "sourceLocation": "Berlin",
  "sourcePage": 1
}
```

### How to run it

1. Open the actor on Apify.
2. Enter one or more keywords or Jobware search URLs.
3. Optionally add a location.
4. Set `maxItems`.
5. Run the actor.
6. Export results as JSON, CSV, Excel, XML, or via API.

### Tips for better results

- Use German and English job titles if your market uses both.
- Keep `includeDetails` enabled when you need descriptions or expiry dates.
- Use multiple focused searches instead of one very broad query for cleaner lead lists.
- Start with a small `maxItems` value to validate your query.
- Disable details for quick count or discovery checks.

### Integrations

Use Jobware.de Jobs Scraper in workflows such as:

- Send new matching jobs to Google Sheets every morning.
- Enrich a CRM with companies currently hiring target roles.
- Monitor a city-specific labor market for analyst reports.
- Feed a private job board or newsletter with selected German roles.
- Trigger Slack alerts when a target employer posts a new position.

### API usage

#### Node.js

```js
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/jobware-de-jobs-scraper').call({
  keywords: ['data analyst'],
  location: 'Berlin',
  maxItems: 100,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_APIFY_TOKEN')
run = client.actor('automation-lab/jobware-de-jobs-scraper').call(run_input={
    'keywords': ['software engineer'],
    'location': 'München',
    'maxItems': 100,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

#### cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/automation-lab~jobware-de-jobs-scraper/runs?token=YOUR_APIFY_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"keywords":["controller"],"location":"Hamburg","maxItems":50}'
```

### MCP usage

Connect this actor to AI tools through Apify MCP:

- Claude Desktop: `https://mcp.apify.com/?tools=automation-lab/jobware-de-jobs-scraper`
- Claude Code CLI:

```bash
claude mcp add apify-jobware "https://mcp.apify.com/?tools=automation-lab/jobware-de-jobs-scraper"
```

Example Claude Desktop JSON configuration:

```json
{
  "mcpServers": {
    "apify-jobware": {
      "url": "https://mcp.apify.com/?tools=automation-lab/jobware-de-jobs-scraper"
    }
  }
}
```

Example prompts:

- "Find 50 Jobware postings for data analyst roles in Berlin and summarize top hiring companies."
- "Monitor Jobware software engineering jobs in Munich and group them by employer."
- "Extract current controller jobs in Hamburg and prepare a CRM import table."

### Proxy notes

The actor normally works without proxy because Jobware's public search APIs are reachable anonymously. If a run is blocked from your environment, enable Apify Proxy in the input.

### Performance

The actor uses sequential pagination and lightweight HTTP requests. This keeps memory and compute cost low while avoiding unnecessary pressure on the target site.

### Limitations

- It extracts public Jobware.de data only.
- It cannot access private applicant portals or external employer application pages.
- Some optional fields, such as salary ranges, are populated only when Jobware provides them.
- Search relevance and availability are controlled by Jobware.de.

### Legality

This actor extracts publicly available Jobware.de job listing data. You are responsible for using the data lawfully, respecting Jobware.de terms, privacy rules, and applicable regulations such as GDPR. Avoid collecting or storing personal data unless you have a lawful basis.

### Is it legal to scrape Jobware.de?

The legality depends on your use case, jurisdiction, and compliance process. Use the actor for legitimate business intelligence, labor-market analysis, and job aggregation workflows, and consult your legal team for high-risk use cases.

### FAQ

#### Why did my run return zero jobs?

Your keyword/location combination may not have current Jobware results. Try a broader keyword, remove the location, or paste a Jobware search URL that returns visible results in your browser.

#### Why are employment types empty for some records?

Jobware does not expose every optional field for every listing. The actor keeps the schema stable and leaves missing optional arrays empty.

#### Can I scrape company profile pages?

This version focuses on job listings and detail records. Company profile scraping can be added later if there is enough demand.

#### Can I schedule monitoring?

Yes. Use Apify schedules to run the actor daily or weekly, then compare results by `jobId` or `businessReference`.

### Related scrapers

Explore other automation-lab actors for job-market and lead-generation workflows:

- https://apify.com/automation-lab/linkedin-jobs-scraper
- https://apify.com/automation-lab/indeed-scraper
- https://apify.com/automation-lab/website-contact-finder

### Support

If the actor stops returning data or Jobware changes its API, open an issue on the Apify actor page with your run ID and input. Include whether `includeDetails` was enabled and whether you used a proxy.

### Changelog

- Initial version: keyword search, Jobware search URL support, pagination, full detail extraction, and structured dataset output.

# Actor input Schema

## `keywords` (type: `array`):

Job titles, skills, or search terms to look up on Jobware.de.

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

Optional German city, region, or remote-related location text to send as Jobware's job location parameter.

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

Optional Jobware.de /jobsuche URLs. Query parameters such as jw\_jobname, jw\_jobort, jw\_start\_count, q, keyword, and location are converted into API searches.

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

Maximum number of job records to save across all searches.

## `includeDetails` (type: `boolean`):

When enabled, the actor calls each Jobware detail endpoint to add raw description text, canonical URL, expiry date, and richer company data.

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

Optional Apify proxy settings. Jobware's public APIs usually work without a proxy; enable this only if your run is blocked.

## Actor input object example

```json
{
  "keywords": [
    "data analyst",
    "software engineer"
  ],
  "location": "Berlin",
  "startUrls": [
    {
      "url": "https://www.jobware.de/jobsuche?jw_jobname=data%20analyst&jw_jobort=Berlin"
    }
  ],
  "maxItems": 20,
  "includeDetails": true,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `overview` (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 = {
    "keywords": [
        "data analyst",
        "software engineer"
    ],
    "location": "Berlin",
    "startUrls": [
        {
            "url": "https://www.jobware.de/jobsuche?jw_jobname=data%20analyst&jw_jobort=Berlin"
        }
    ],
    "maxItems": 20,
    "includeDetails": true,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/jobware-de-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 = {
    "keywords": [
        "data analyst",
        "software engineer",
    ],
    "location": "Berlin",
    "startUrls": [{ "url": "https://www.jobware.de/jobsuche?jw_jobname=data%20analyst&jw_jobort=Berlin" }],
    "maxItems": 20,
    "includeDetails": True,
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/jobware-de-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 '{
  "keywords": [
    "data analyst",
    "software engineer"
  ],
  "location": "Berlin",
  "startUrls": [
    {
      "url": "https://www.jobware.de/jobsuche?jw_jobname=data%20analyst&jw_jobort=Berlin"
    }
  ],
  "maxItems": 20,
  "includeDetails": true,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call automation-lab/jobware-de-jobs-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Jobware.de Jobs Scraper",
        "description": "Extract German job postings from Jobware.de with titles, companies, locations, descriptions, apply URLs, and source search metadata.",
        "version": "0.1",
        "x-build-id": "aXgHvj5a4V3zBf5qK"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~jobware-de-jobs-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-jobware-de-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/automation-lab~jobware-de-jobs-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-jobware-de-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/automation-lab~jobware-de-jobs-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-jobware-de-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",
                "properties": {
                    "keywords": {
                        "title": "Keywords",
                        "type": "array",
                        "description": "Job titles, skills, or search terms to look up on Jobware.de.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "Optional German city, region, or remote-related location text to send as Jobware's job location parameter."
                    },
                    "startUrls": {
                        "title": "Jobware search URLs",
                        "type": "array",
                        "description": "Optional Jobware.de /jobsuche URLs. Query parameters such as jw_jobname, jw_jobort, jw_start_count, q, keyword, and location are converted into API searches.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxItems": {
                        "title": "Maximum jobs",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of job records to save across all searches.",
                        "default": 20
                    },
                    "includeDetails": {
                        "title": "Fetch full job details",
                        "type": "boolean",
                        "description": "When enabled, the actor calls each Jobware detail endpoint to add raw description text, canonical URL, expiry date, and richer company data.",
                        "default": true
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional Apify proxy settings. Jobware's public APIs usually work without a proxy; enable this only if your run is blocked.",
                        "default": {
                            "useApifyProxy": false
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```