# Xing Jobs Scraper (`fetch_cat/xing-jobs-scraper`) Actor

Scrape public XING job listings by keyword, location, or direct URL. Export job titles, companies, locations, salaries, descriptions, and URLs.

- **URL**: https://apify.com/fetch\_cat/xing-jobs-scraper.md
- **Developed by:** [Hanna Nosova](https://apify.com/fetch_cat) (community)
- **Categories:** Jobs, Lead generation, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.31 / 1,000 job saveds

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

## Xing Jobs Scraper

Scrape public XING job listings by keyword, location, or direct XING job/search URLs. Export structured job data for recruiting, sourcing, labor-market analysis, competitive hiring intelligence, and DACH job monitoring.

Use this Actor when you need repeatable XING job collection with clean dataset rows, detail-page descriptions, salary text when visible, and exports for CSV, JSON, Excel, API, dashboards, and automation workflows.

### At a glance

- **Primary job**: collect public XING job listings for recruiting and market intelligence.
- **Input**: enter search keywords and a location, or paste XING job/search URLs.
- **Output**: one dataset row per job with title, company, location, salary, employment type, description, and source URL fields.
- **Best for**: DACH recruiting teams, sourcing vendors, job aggregators, sales intelligence, and labor-market analysts.

### Use cases

- **Recruiting market scans**: collect active XING postings by role and city to understand demand.
- **Sourcing vendor workflows**: build lists of hiring companies and open roles for outreach.
- **Labor-market analysis**: monitor salary signals, employment types, and hiring trends in DACH markets.
- **Competitive intelligence**: track which companies are hiring for specific functions over time.

### Input recipes

#### Example input: small smoke test

```json
{
  "keywords": ["software engineer"],
  "location": "Berlin",
  "maxItems": 10,
  "maxPages": 2,
  "includeDetails": true
}
````

#### Recruiter market scan

```json
{
  "keywords": ["marketing manager", "sales manager"],
  "location": "Munich",
  "maxItems": 100,
  "maxPages": 10,
  "includeDetails": true
}
```

#### Direct XING URLs

```json
{
  "startUrls": [
    { "url": "https://www.xing.com/jobs/search?keywords=data%20analyst&location=Hamburg" },
    { "url": "https://www.xing.com/jobs/berlin-senior-software-engineer-155853218" }
  ],
  "maxItems": 50,
  "includeDetails": true
}
```

### What data can you extract?

| Field | Description |
| --- | --- |
| `jobId` | XING job identifier parsed from the job URL. |
| `jobUrl` | Canonical public XING job URL. |
| `title` | Job title. |
| `companyName` | Hiring company name. |
| `companyUrl` | Public company URL when XING exposes one. |
| `location` | Job location text. |
| `remoteOrHybrid` | Remote, hybrid, or on-site hint when visible. |
| `postedAt` | Structured posting date when available. |
| `postedText` | Human-readable posting freshness text when visible. |
| `employmentType` | Employment type such as full-time or part-time. |
| `salaryText` | Salary text when shown publicly. |
| `descriptionText` | Plain-text public job description from the detail page. |
| `skills` | Tags, labels, or skills visible on the listing/detail page. |
| `applyUrl` | Application URL when exposed publicly. |
| `sourceSearchUrl` | Search page where the listing was found. |
| `sourceType` | `search` or `detail`. |
| `scrapedAt` | Timestamp when the record was saved. |

### Input configuration

| Setting | JSON key | Use it for | Example |
| --- | --- | --- | --- |
| Keywords | `keywords` | Job titles, skills, or hiring terms to search. | `["software engineer"]` |
| Location | `location` | City, region, or country for keyword searches. | `"Berlin"` |
| Start URLs | `startUrls` | XING search URLs or direct XING job URLs. | `https://www.xing.com/jobs/search?keywords=...` |
| Maximum jobs | `maxItems` | Cap saved rows and control spend. | `10` |
| Maximum pages | `maxPages` | Limit paginated search pages per query. | `5` |
| Fetch job detail pages | `includeDetails` | Extract public description, dates, and structured detail fields. | `true` |
| Proxy configuration | `proxyConfiguration` | Optional Apify or custom proxy settings. The default uses Apify Residential proxy in Germany for stable cloud access. | `{ "useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"], "countryCode": "DE" }` |

### Example output

```json
{
  "jobId": "155853218",
  "jobUrl": "https://www.xing.com/jobs/berlin-senior-software-engineer-155853218",
  "title": "Senior Software Engineer",
  "companyName": "Nulegal GmbH",
  "companyUrl": null,
  "location": "Berlin, DE",
  "remoteOrHybrid": null,
  "postedAt": "2026-07-08",
  "postedText": null,
  "employmentType": "Full-time",
  "salaryText": "EUR 61,000 - 81,500",
  "descriptionText": "Bureaucracy and legal friction are holding Europe back...",
  "skills": ["Urgently hiring", "Full-time"],
  "applyUrl": "https://www.xing.com/jobs/berlin-senior-software-engineer-155853218",
  "sourceSearchUrl": "https://www.xing.com/jobs/search?keywords=software+engineer&location=Berlin",
  "sourceType": "search",
  "scrapedAt": "2026-07-09T18:45:00.000Z"
}
```

### Pricing

| Event | Price | Charged when |
| --- | --- | --- |
| Run start | `$0.010` per run | Once when the Actor starts. |
| Job saved | from `$0.00014391` to `$0.00059106` per saved job by usage tier (`$0.00051397` Bronze) | Each XING job listing saved to the dataset. |

Bronze users pay about **$0.514 per 1,000 saved jobs**, plus the small run-start fee. Store discount tiers are configured as Free, Bronze, Silver, Gold, Platinum, and Diamond, so high-volume users pay less per saved job.

### Tips for best results

- Start with `maxItems: 10` and `maxPages: 2` to confirm the search returns the expected roles.
- Use German and English keywords when monitoring DACH markets, for example `softwareentwickler`, `sales manager`, or `data analyst`.
- Keep location values specific (`Berlin`, `Munich`, `Hamburg`) for focused datasets.
- Set `includeDetails: false` when you only need fast title/company/location/salary listing rows.
- Schedule repeat runs to monitor new postings and changing hiring demand over time.

### API usage

Node.js:

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor("fetch_cat/xing-jobs-scraper").call({
  keywords: ["software engineer"],
  location: "Berlin",
  maxItems: 10,
  includeDetails: true
});
console.log(run.defaultDatasetId);
```

Python:

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("fetch_cat/xing-jobs-scraper").call(run_input={
    "keywords": ["software engineer"],
    "location": "Berlin",
    "maxItems": 10,
    "includeDetails": True,
})
print(run["defaultDatasetId"])
```

cURL:

```bash
curl -X POST "https://api.apify.com/v2/acts/fetch_cat~xing-jobs-scraper/runs?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"keywords":["software engineer"],"location":"Berlin","maxItems":10,"includeDetails":true}'
```

### MCP and AI agents

Use this Actor from MCP-compatible tools through the official Apify MCP Server.

```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=fetch_cat/xing-jobs-scraper"
```

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=fetch_cat/xing-jobs-scraper"
    }
  }
}
```

Example prompt: "Run Xing Jobs Scraper for software engineer roles in Berlin and summarize the top hiring companies from the dataset."

### Limits and caveats

- XING can change public markup or throttle very large/frequent runs.
- Some jobs do not expose salary, remote status, apply URL, or company URL publicly.
- Search results can change between pages while new jobs are posted or removed.
- This Actor reads public job pages only; it does not log in, apply to jobs, or access private XING data.

### Legality and responsible use

Process only data you are allowed to access. Follow XING's terms, Apify's terms, and applicable privacy, employment, and data-protection laws. Use the data for legitimate recruiting, analytics, monitoring, and research workflows.

### Related actors

- [ATS Jobs Scraper](https://apify.com/fetch_cat/ats-jobs-scraper)
- [Lever Jobs Scraper](https://apify.com/fetch_cat/lever-jobs-scraper)
- [Remote.com Jobs Scraper](https://apify.com/fetch_cat/remote-dot-com-jobs-scraper)

### FAQ

#### Can I export results?

Yes. Apify datasets support JSON, CSV, Excel, XML, RSS, and API access.

#### Why are some fields empty?

XING does not expose every field on every public listing. The Actor leaves unavailable fields empty instead of guessing.

#### Can I scrape direct job URLs?

Yes. Add direct `https://www.xing.com/jobs/...` URLs to `startUrls`. Each direct job URL produces one dataset row when accessible publicly.

#### Does this need a proxy?

The default uses Apify Residential proxy in Germany because XING can serve different result pages to cloud datacenter traffic. You can override `proxyConfiguration` if you have a custom proxy setup.

### Support

Open an issue from the Actor page if a run fails or output looks wrong. Include the run ID or run URL, input JSON, expected output, actual output, and one reproducible public URL, such as the XING search or job URL that produced the problem.

# Actor input Schema

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

Job titles, skills, or hiring keywords to search on XING. Leave empty when using only Start URLs.

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

City, region, or country for keyword searches, such as Berlin, Munich, Hamburg, or Germany.

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

Optional XING job search URLs or direct XING job detail URLs to scrape.

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

Maximum number of job listings to save across all searches and start URLs.

## `maxPages` (type: `integer`):

Safety limit for paginated search result pages. XING usually returns around 10-20 jobs per page.

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

Open each job detail page to extract public structured description, dates, salary, employment type, company URL, and apply URL when available.

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

Optional proxy settings. The default uses Apify Residential proxy in Germany for stable cloud access to public XING job pages.

## Actor input object example

```json
{
  "keywords": [
    "software engineer"
  ],
  "location": "Berlin",
  "startUrls": [
    {
      "url": "https://www.xing.com/jobs/search?keywords=software%20engineer&location=Berlin"
    }
  ],
  "maxItems": 10,
  "maxPages": 5,
  "includeDetails": true,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "countryCode": "DE"
  }
}
```

# 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": [
        "software engineer"
    ],
    "location": "Berlin",
    "startUrls": [
        {
            "url": "https://www.xing.com/jobs/search?keywords=software%20engineer&location=Berlin"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("fetch_cat/xing-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": ["software engineer"],
    "location": "Berlin",
    "startUrls": [{ "url": "https://www.xing.com/jobs/search?keywords=software%20engineer&location=Berlin" }],
}

# Run the Actor and wait for it to finish
run = client.actor("fetch_cat/xing-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": [
    "software engineer"
  ],
  "location": "Berlin",
  "startUrls": [
    {
      "url": "https://www.xing.com/jobs/search?keywords=software%20engineer&location=Berlin"
    }
  ]
}' |
apify call fetch_cat/xing-jobs-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Xing Jobs Scraper",
        "description": "Scrape public XING job listings by keyword, location, or direct URL. Export job titles, companies, locations, salaries, descriptions, and URLs.",
        "version": "0.1",
        "x-build-id": "bFNA927ZNg1zMyLIl"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/fetch_cat~xing-jobs-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-fetch_cat-xing-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/fetch_cat~xing-jobs-scraper/runs": {
            "post": {
                "operationId": "runs-sync-fetch_cat-xing-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/fetch_cat~xing-jobs-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-fetch_cat-xing-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 hiring keywords to search on XING. Leave empty when using only Start URLs.",
                        "default": [
                            "software engineer"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "City, region, or country for keyword searches, such as Berlin, Munich, Hamburg, or Germany.",
                        "default": "Berlin"
                    },
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "Optional XING job search URLs or direct XING job detail URLs to scrape.",
                        "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 listings to save across all searches and start URLs.",
                        "default": 10
                    },
                    "maxPages": {
                        "title": "Maximum search pages per query",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Safety limit for paginated search result pages. XING usually returns around 10-20 jobs per page.",
                        "default": 5
                    },
                    "includeDetails": {
                        "title": "Fetch job detail pages",
                        "type": "boolean",
                        "description": "Open each job detail page to extract public structured description, dates, salary, employment type, company URL, and apply URL when available.",
                        "default": true
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional proxy settings. The default uses Apify Residential proxy in Germany for stable cloud access to public XING job pages.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ],
                            "countryCode": "DE"
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```