# Jobindex Jobs Scraper (`automation-lab/jobindex-jobs-scraper`) Actor

🇩🇰 Scrape Jobindex.dk jobs by keyword or URL. Extract titles, companies, locations, dates, descriptions, apply links, and job URLs.

- **URL**: https://apify.com/automation-lab/jobindex-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

from $0.02 / 1,000 job listing 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

## Jobindex Jobs Scraper

Extract structured Danish job listings from Jobindex.dk by keyword or search URL.

### What does Jobindex Jobs Scraper do?

Jobindex Jobs Scraper turns public Jobindex.dk search pages into clean dataset rows.
It captures titles, companies, locations, posting dates, deadlines, descriptions, apply links, Jobindex URLs, and source metadata.

Use it when you need repeatable Danish labor-market data without copying job cards by hand.

### Who is it for?

Recruiters use it to monitor new Danish roles by skill, city, or client niche.

Job aggregators use it to feed internal search indexes and deduplicate Jobindex links.

HR-tech teams use it to benchmark hiring demand in Denmark.

Labor-market analysts use it to track recurring demand for roles such as Python developer, nurse, electrician, accountant, or sales manager.

### Why scrape Jobindex.dk?

Jobindex is one of Denmark's best-known job boards.

Many regional and Danish-language roles appear there before they are easy to find in broader international job boards.

A focused Jobindex scraper helps teams cover Denmark alongside larger multi-board workflows.

### Why use this actor?

- 🇩🇰 Built for Jobindex.dk search result pages
- 🔎 Search by keyword, location keyword, or direct Jobindex search URL
- 📄 Optional detail-page fetching for richer descriptions
- 🔗 Includes apply URLs and canonical Jobindex job URLs
- 🧾 Saves source query, source URL, and scrape timestamp for audits
- ⚙️ HTTP-first implementation without a heavy browser by default

### Data you can extract

| Field | Description |
| --- | --- |
| `title` | Job title from Jobindex |
| `companyName` | Employer name |
| `location` | City or area |
| `salaryText` | Salary cue when visible |
| `employmentType` | Employment cue when visible |
| `postedAt` | First publication date |
| `deadline` | Application deadline |
| `descriptionText` | Plain-text job description |
| `descriptionHtml` | HTML description |
| `applyUrl` | Apply link or Jobindex redirect |
| `jobUrl` | Jobindex job page URL |
| `jobId` | Jobindex listing id |
| `sourceQuery` | Query used for the run |
| `sourceUrl` | Search page that produced the item |
| `scrapedAt` | ISO timestamp |

### How much does it cost to scrape Jobindex jobs?

The actor uses pay-per-event pricing.

You pay a small run-start fee and then a per-job-listing fee for each saved result.

Set `maxItems` to a low number for testing, then increase it for production monitoring.

The default prefill is designed to be inexpensive while still proving the output shape.

### How to scrape Jobindex jobs

1. Open the actor on Apify.
2. Enter a search query such as `python`, `sygeplejerske`, `marketing`, or `data analyst`.
3. Optionally enter a location keyword such as `København` or `Aarhus`.
4. Set `maxItems`.
5. Keep `includeDetails` disabled for fast monitoring, or enable it for richer descriptions.
6. Run the actor.
7. Export results as JSON, CSV, Excel, XML, or through the Apify API.

### Input options

#### query

A Jobindex keyword search term.

Examples:

- `python`
- `data engineer`
- `projektleder`
- `sygeplejerske`

#### location

An optional Danish location keyword.

The actor appends it to the search query for simple regional targeting.

Examples:

- `København`
- `Aarhus`
- `Odense`
- `Aalborg`

#### startUrls

Use direct Jobindex search URLs if you already built a filtered search in the browser.

Example:

```json
[
  { "url": "https://www.jobindex.dk/jobsoegning?q=python" }
]
````

#### maxItems

Maximum number of listings to save.

Start with `25` or `100` for validation.

#### includeDetails

When enabled, the actor opens each Jobindex detail page and tries to replace the search-card description with richer detail-page text.

Keep this disabled for faster recurring runs.

#### maxPages

Safety cap for pagination.

Jobindex usually displays about 20 jobs per search page.

### Example input

```json
{
  "query": "python",
  "location": "København",
  "maxItems": 100,
  "includeDetails": false,
  "maxPages": 10
}
```

### Example output

```json
{
  "title": "Python Software Developer",
  "companyName": "Minerva Imaging ApS",
  "location": "Ølstykke",
  "salaryText": null,
  "employmentType": null,
  "postedAt": "2026-06-16",
  "deadline": "2026-07-31T21:59:59Z",
  "descriptionText": "Python Software Developer ...",
  "descriptionHtml": "<div>...</div>",
  "applyUrl": "https://www.jobindex.dk/c?t=...",
  "jobUrl": "https://www.jobindex.dk/vis-job/h1674866",
  "jobId": "h1674866",
  "sourceQuery": "python",
  "sourceUrl": "https://www.jobindex.dk/jobsoegning?q=python",
  "scrapedAt": "2026-06-21T00:00:00.000Z"
}
```

### Tips for better results

Use Danish job titles when you want local-language coverage.

Use English skill terms when you want international or tech roles.

Run separate tasks for separate cities if you need clean regional monitoring.

Keep detail fetching off for high-volume daily monitoring.

Enable detail fetching for smaller research exports where description richness matters more than speed.

### Integrations

Send new Jobindex roles to Google Sheets for recruiter review.

Feed job URLs into an ATS enrichment workflow.

Monitor daily changes with Apify schedules and webhooks.

Export JSON to a data warehouse for labor-market dashboards.

Combine Jobindex output with `omni-jobs-board-scraper` for broader multi-board coverage.

### API usage with Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/jobindex-jobs-scraper').call({
  query: 'python',
  location: 'København',
  maxItems: 100,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items.slice(0, 3));
```

### API usage with Python

```python
from apify_client import ApifyClient
import os

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/jobindex-jobs-scraper').call(run_input={
    'query': 'python',
    'location': 'København',
    'maxItems': 100,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items[:3])
```

### API usage with cURL

```bash
curl "https://api.apify.com/v2/acts/automation-lab~jobindex-jobs-scraper/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"query":"python","location":"København","maxItems":100}'
```

### MCP usage

Use this actor through Apify MCP when working in Claude Desktop or Claude Code.

MCP URL:

```text
https://mcp.apify.com/?tools=automation-lab/jobindex-jobs-scraper
```

Claude Code setup:

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

Claude Desktop JSON configuration:

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

Example prompts:

- "Find 100 Python jobs on Jobindex in Copenhagen and summarize the hiring companies."
- "Monitor Jobindex for new data engineer roles and send me the dataset link."
- "Extract Danish nursing jobs from Jobindex and group them by location."

### Scheduling and monitoring

Create an Apify task with your chosen query.

Schedule it daily or weekly.

Use the `jobUrl` and `jobId` fields for deduplication.

Send webhook notifications when a run finishes.

### Handling duplicate listings

The actor deduplicates within a run by `jobUrl`.

For long-term monitoring, deduplicate across runs in your database using `jobId` or `jobUrl`.

### Performance notes

Search pages are fetched with HTTP and parsed from the initial HTML.

This is lighter than browser automation and suitable for recurring monitoring.

Detail pages add extra requests, so use them only when needed.

### FAQ

#### Can I scrape a specific Jobindex search URL?

Yes. Paste the URL into `startUrls` and the actor will use it instead of `query` and `location`.

#### Why are descriptions sometimes short?

Search cards contain summaries. Enable `includeDetails` when you need richer detail-page descriptions.

#### How do I monitor new jobs over time?

Schedule the actor daily and deduplicate downstream by `jobId` or `jobUrl`.

### Troubleshooting

If you receive fewer jobs than expected, increase `maxPages` or broaden the query.

If descriptions look short, enable `includeDetails` for richer detail-page content.

If a location query is too narrow, try the Danish city name without extra filters.

### Legality and responsible use

This actor extracts publicly available Jobindex search data.

Use the data responsibly, respect applicable laws, and follow Jobindex terms and robots guidance for your use case.

Do not collect personal data beyond what is necessary for a legitimate workflow.

### Related scrapers

- https://apify.com/automation-lab/omni-jobs-board-scraper
- https://apify.com/automation-lab/omni-remote-jobs-scraper
- https://apify.com/automation-lab/arbeitsagentur-jobs-scraper

### Changelog

Initial version extracts Jobindex search results by query or URL with optional detail-page fetching.

# Actor input Schema

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

Job title, skill, keyword, or phrase to search on Jobindex.dk.

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

Optional Danish city/region keyword appended to the search query, for example København, Aarhus, or Odense.

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

Optional Jobindex search URLs such as https://www.jobindex.dk/jobsoegning?q=data. If provided, these override query/location.

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

Maximum number of job listings to save.

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

Open each Jobindex detail page for richer description text. Keep disabled for faster, cheaper monitoring runs.

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

Safety cap for pagination. Jobindex usually returns 20 jobs per page.

## Actor input object example

```json
{
  "query": "python",
  "location": "København",
  "startUrls": [
    {
      "url": "https://www.jobindex.dk/jobsoegning?q=python"
    }
  ],
  "maxItems": 20,
  "includeDetails": false,
  "maxPages": 10
}
```

# 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 = {
    "query": "python",
    "location": "København",
    "startUrls": [
        {
            "url": "https://www.jobindex.dk/jobsoegning?q=python"
        }
    ],
    "maxItems": 20,
    "includeDetails": false,
    "maxPages": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/jobindex-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 = {
    "query": "python",
    "location": "København",
    "startUrls": [{ "url": "https://www.jobindex.dk/jobsoegning?q=python" }],
    "maxItems": 20,
    "includeDetails": False,
    "maxPages": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/jobindex-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 '{
  "query": "python",
  "location": "København",
  "startUrls": [
    {
      "url": "https://www.jobindex.dk/jobsoegning?q=python"
    }
  ],
  "maxItems": 20,
  "includeDetails": false,
  "maxPages": 10
}' |
apify call automation-lab/jobindex-jobs-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Jobindex Jobs Scraper",
        "description": "🇩🇰 Scrape Jobindex.dk jobs by keyword or URL. Extract titles, companies, locations, dates, descriptions, apply links, and job URLs.",
        "version": "0.1",
        "x-build-id": "JTTK2UD5OzZT5zMRr"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~jobindex-jobs-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-jobindex-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~jobindex-jobs-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-jobindex-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~jobindex-jobs-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-jobindex-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": {
                    "query": {
                        "title": "Search query",
                        "type": "string",
                        "description": "Job title, skill, keyword, or phrase to search on Jobindex.dk.",
                        "default": "python"
                    },
                    "location": {
                        "title": "Location keyword",
                        "type": "string",
                        "description": "Optional Danish city/region keyword appended to the search query, for example København, Aarhus, or Odense."
                    },
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "Optional Jobindex search URLs such as https://www.jobindex.dk/jobsoegning?q=data. If provided, these override query/location.",
                        "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": 20
                    },
                    "includeDetails": {
                        "title": "Fetch detail pages",
                        "type": "boolean",
                        "description": "Open each Jobindex detail page for richer description text. Keep disabled for faster, cheaper monitoring runs.",
                        "default": false
                    },
                    "maxPages": {
                        "title": "Maximum search pages",
                        "minimum": 1,
                        "maximum": 250,
                        "type": "integer",
                        "description": "Safety cap for pagination. Jobindex usually returns 20 jobs per page.",
                        "default": 50
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```