# Karriere.at Job Listings Scraper (`automation-lab/karriere-at-job-listings-scraper`) Actor

Scrape public Karriere.at job listings for Austrian roles, salaries, companies, descriptions, requirements, benefits, and apply URLs.

- **URL**: https://apify.com/automation-lab/karriere-at-job-listings-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Jobs, Lead generation
- **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

## Karriere.at Job Listings Scraper

Scrape public Austrian job listings from Karriere.at search pages and job detail pages. Export job titles, companies, locations, salaries, employment types, descriptions, requirements, benefits, phone numbers when visible, apply links, and source URLs.

### What does Karriere.at Job Listings Scraper do?

Karriere.at Job Listings Scraper collects public vacancy data from [karriere.at](https://www.karriere.at/) and stores it in a structured Apify dataset. You can search by keyword and Austrian location, pass existing Karriere.at search URLs, or combine multiple keywords and locations in one run.

The actor uses lightweight HTTP extraction for the public HTML and job detail JSON-LD. It does not require a Karriere.at account.

### Who is it for?

- 🧑‍💼 Recruiters tracking Austrian hiring demand by city and role.
- 📈 Labor-market analysts monitoring salary bands and employment types.
- 🏢 Sales and lead-generation teams finding companies currently hiring.
- 🧪 HR-tech builders enriching job intelligence databases.
- 📰 Journalists and researchers following vacancy trends in Austria.

### Why use this actor?

Karriere.at pages are optimized for people, not for repeatable exports. This actor turns public listings into a clean dataset that can be downloaded as JSON, CSV, Excel, XML, or HTML through Apify.

It also opens detail pages when requested, so you get richer fields than a simple search-page scraper.

### Key features

- 🔎 Search by keyword and location.
- 🔗 Use custom Karriere.at start URLs with filters already applied.
- 📄 Optional detail-page extraction.
- 💶 Salary extraction when visible.
- 🏷️ Employment type and posting date extraction.
- 🧾 Full description, requirements, and benefits from detail pages.
- 🚀 HTTP-first implementation for lower runtime cost.

### Data you can extract

| Field | Description |
| --- | --- |
| `jobId` | Karriere.at numeric job identifier when present |
| `title` | Job title |
| `company` | Hiring company |
| `location` | Primary location |
| `locations` | All locations found on the detail page or listing card |
| `salary` | Salary text or JSON-LD salary range when visible |
| `employmentType` | Full-time, part-time, internship, or schema.org employment type |
| `postedDate` | Human-readable posted label from search results |
| `datePosted` | Machine-readable date from JSON-LD when available |
| `description` | Full job description text |
| `requirements` | Best-effort requirements/profile section |
| `benefits` | Best-effort benefits/offer section |
| `phone` | Phone number when publicly visible in the job text |
| `applyUrl` | External or Karriere.at application link when visible |
| `jobUrl` | Karriere.at job detail URL |
| `companyUrl` | Karriere.at company profile URL |
| `sourceSearchUrl` | Search URL that produced the listing |

### How much does it cost to scrape Karriere.at job listings?

This actor uses pay-per-event pricing. You pay a small run start fee plus a per-result fee for each job listing saved. The input prefill is intentionally small, so your first run is cheap.

For large monitoring jobs, start with a small `maxItems` value, check the output quality, then increase the limit.

### How to scrape Karriere.at jobs

1. Open the actor on Apify.
2. Add a `searchQueries` item such as keyword `software engineer` and location `wien`.
3. Set `maxItems` to the number of jobs you need.
4. Keep `includeDetails` enabled if you need descriptions, requirements, benefits, salary, and apply URLs.
5. Click **Start**.
6. Download the dataset when the run finishes.

### Input options

#### `searchQueries`

Use this for precise keyword/location pairs.

```json
[
  { "keyword": "software engineer", "location": "wien" },
  { "keyword": "marketing", "location": "linz" }
]
````

#### `keywords` and `locations`

Use these arrays when you want all combinations. For example, two keywords and three locations create six search URLs.

#### `startUrls`

Use this when you already have a filtered Karriere.at URL from your browser.

```json
[
  { "url": "https://www.karriere.at/jobs/software-engineer/wien" }
]
```

#### `maxItems`

The maximum number of jobs saved across all searches.

#### `maxPagesPerSearch`

The maximum pagination depth for each search URL.

#### `includeDetails`

When enabled, the actor opens each job detail page and extracts richer fields. Disable it for faster list-only monitoring.

### Example input

```json
{
  "searchQueries": [
    { "keyword": "software engineer", "location": "wien" }
  ],
  "maxItems": 25,
  "maxPagesPerSearch": 3,
  "includeDetails": true
}
```

### Example output

```json
{
  "jobId": "10009538",
  "title": "Senior Full Stack Software Engineer (all genders)",
  "company": "PRODYNA SE",
  "location": "Wien, Wien, AT",
  "locations": ["Wien, Wien, AT"],
  "salary": "4500–5000 EUR month",
  "employmentType": "FULL_TIME",
  "postedDate": "vor 3 Tagen veröffentlicht",
  "datePosted": "2026-05-30T00:00:00+02:00",
  "description": "Full public job description...",
  "requirements": "Profile and requirements...",
  "benefits": "Benefits and offer details...",
  "phone": null,
  "applyUrl": "https://example.com/apply",
  "jobUrl": "https://www.karriere.at/jobs/10009538",
  "companyUrl": "https://www.karriere.at/f/prodyna",
  "sourceSearchUrl": "https://www.karriere.at/jobs/software-engineer/wien"
}
```

### Tips for best results

- Use Austrian city names as Karriere.at users write them, for example `wien`, `graz`, `linz`, or `salzburg`.
- Keep `includeDetails` enabled for research datasets.
- Disable `includeDetails` for quick vacancy counts or URL discovery.
- Use `startUrls` when you need filters not represented by keyword/location inputs.
- Increase `maxPagesPerSearch` gradually for broad keywords.

### Common use cases

- Track weekly software engineering vacancies in Vienna.
- Compare salary bands across Austrian cities.
- Build company hiring lead lists.
- Monitor competitor job postings.
- Feed job-market dashboards and BI tools.
- Enrich internal recruiting databases.

### Integrations

You can connect the dataset to Google Sheets, Make, Zapier, webhooks, or your data warehouse. Common workflows include:

- 📊 Push new job rows to a spreadsheet every morning.
- 🔔 Trigger a webhook when a company posts a matching vacancy.
- 🧩 Join job listings with CRM company records.
- 🗄️ Store historical snapshots in BigQuery, Snowflake, or Postgres.

### 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/karriere-at-job-listings-scraper').call({
  searchQueries: [{ keyword: 'software engineer', location: 'wien' }],
  maxItems: 25,
  includeDetails: true,
});
console.log(run.defaultDatasetId);
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_APIFY_TOKEN')
run = client.actor('automation-lab/karriere-at-job-listings-scraper').call(run_input={
    'searchQueries': [{'keyword': 'software engineer', 'location': 'wien'}],
    'maxItems': 25,
    'includeDetails': True,
})
print(run['defaultDatasetId'])
```

#### cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/automation-lab~karriere-at-job-listings-scraper/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"searchQueries":[{"keyword":"software engineer","location":"wien"}],"maxItems":25,"includeDetails":true}'
```

### MCP usage

Use this actor through Apify MCP in Claude Code or Claude Desktop with:

```text
https://mcp.apify.com/?tools=automation-lab/karriere-at-job-listings-scraper
```

Example prompts:

- "Find 20 software engineering jobs in Vienna and summarize salary ranges."
- "Scrape marketing roles in Linz and return companies that are hiring."
- "Compare data analyst vacancies in Graz and Vienna."

### Legality and responsible use

This actor extracts publicly available job listing data. Always respect Karriere.at terms, privacy rules, and applicable laws. Do not use scraped personal data for spam or unlawful outreach. If a field is not publicly visible, the actor cannot and should not extract it.

### Troubleshooting

#### Why did I get fewer jobs than `maxItems`?

The search may have fewer public results than requested, or `maxPagesPerSearch` may be too low. Increase pagination depth or broaden the keyword/location.

#### Why are some fields null?

Karriere.at listings vary. Salary, phone, benefits, and apply links are only returned when visible on the public page or detail JSON-LD.

#### Why is detail mode slower?

Detail mode fetches one extra page per job. Disable `includeDetails` if you only need listing-card fields.

### Related scrapers

Explore other Automation Lab actors:

- https://apify.com/automation-lab/workday-jobs-scraper
- https://apify.com/automation-lab/remoteok-jobs-scraper
- https://apify.com/automation-lab/welcome-to-the-jungle-jobs-scraper
- https://apify.com/automation-lab/xing-jobs-scraper

### Limitations

- The actor only scrapes public pages.
- It does not log in or apply to jobs.
- Section extraction for requirements and benefits is best-effort because employers format descriptions differently.
- Site layout changes may require extractor updates.

### Changelog

Initial version: public Karriere.at search and detail extraction with HTTP + Cheerio.

# Actor input Schema

## `searchQueries` (type: `array`):

Keyword/location combinations to search on Karriere.at.

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

Optional keywords. Combined with Locations when Search queries are not enough.

## `locations` (type: `array`):

Optional Austrian cities/regions to combine with Keywords.

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

Karriere.at search URLs such as https://www.karriere.at/jobs/software-engineer/wien or direct filtered search pages.

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

Maximum number of job listings to save.

## `maxPagesPerSearch` (type: `integer`):

Pagination depth for each search URL or generated query.

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

Fetch each job detail page to extract schema.org fields, full description, requirements, benefits, salary, and apply URL.

## Actor input object example

```json
{
  "searchQueries": [
    {
      "keyword": "software engineer",
      "location": "wien"
    }
  ],
  "keywords": [
    "software engineer"
  ],
  "locations": [
    "wien"
  ],
  "startUrls": [
    {
      "url": "https://www.karriere.at/jobs/software-engineer/wien"
    }
  ],
  "maxItems": 25,
  "maxPagesPerSearch": 3,
  "includeDetails": true
}
```

# 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 = {
    "searchQueries": [
        {
            "keyword": "software engineer",
            "location": "wien"
        }
    ],
    "keywords": [
        "software engineer"
    ],
    "locations": [
        "wien"
    ],
    "startUrls": [
        {
            "url": "https://www.karriere.at/jobs/software-engineer/wien"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/karriere-at-job-listings-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 = {
    "searchQueries": [{
            "keyword": "software engineer",
            "location": "wien",
        }],
    "keywords": ["software engineer"],
    "locations": ["wien"],
    "startUrls": [{ "url": "https://www.karriere.at/jobs/software-engineer/wien" }],
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/karriere-at-job-listings-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 '{
  "searchQueries": [
    {
      "keyword": "software engineer",
      "location": "wien"
    }
  ],
  "keywords": [
    "software engineer"
  ],
  "locations": [
    "wien"
  ],
  "startUrls": [
    {
      "url": "https://www.karriere.at/jobs/software-engineer/wien"
    }
  ]
}' |
apify call automation-lab/karriere-at-job-listings-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Karriere.at Job Listings Scraper",
        "description": "Scrape public Karriere.at job listings for Austrian roles, salaries, companies, descriptions, requirements, benefits, and apply URLs.",
        "version": "0.1",
        "x-build-id": "IVARlgMciFo9C6aCL"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~karriere-at-job-listings-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-karriere-at-job-listings-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~karriere-at-job-listings-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-karriere-at-job-listings-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~karriere-at-job-listings-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-karriere-at-job-listings-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": {
                    "searchQueries": {
                        "title": "Search queries",
                        "type": "array",
                        "description": "Keyword/location combinations to search on Karriere.at."
                    },
                    "keywords": {
                        "title": "Keywords",
                        "type": "array",
                        "description": "Optional keywords. Combined with Locations when Search queries are not enough.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "locations": {
                        "title": "Locations",
                        "type": "array",
                        "description": "Optional Austrian cities/regions to combine with Keywords.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "Karriere.at search URLs such as https://www.karriere.at/jobs/software-engineer/wien or direct filtered search pages.",
                        "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.",
                        "default": 25
                    },
                    "maxPagesPerSearch": {
                        "title": "Maximum pages per search",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Pagination depth for each search URL or generated query.",
                        "default": 3
                    },
                    "includeDetails": {
                        "title": "Open job detail pages",
                        "type": "boolean",
                        "description": "Fetch each job detail page to extract schema.org fields, full description, requirements, benefits, salary, and apply URL.",
                        "default": true
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```