# EU Jobs Scraper – Search Jobs Across Europe (`scholarstack/eu-jobs-aggregator`) Actor

Scrape and search job listings across Europe in one run — all levels (student to executive) and all fields. Filter by keyword, country, seniority, type, category and remote. Clean, deduplicated JSON/CSV/Excel output with salary estimates — for recruiters, job boards, research and alerts.

- **URL**: https://apify.com/scholarstack/eu-jobs-aggregator.md
- **Developed by:** [ScholarStack](https://apify.com/scholarstack) (community)
- **Categories:** Jobs, Automation, Developer tools
- **Stats:** 4 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $4.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

**EU Job Search Scraper** finds **jobs across Europe** in a single run and returns them as clean, structured data. Search **job listings in Germany, France, the UK, Spain, Italy, the Netherlands, Sweden, Poland, Austria, Ireland, Belgium, Portugal** and more — covering **every level from internships and graduate roles to senior and executive positions**, across **every field** (IT & software, finance, healthcare, sales, marketing, engineering, operations and more). Filter by keyword, country, seniority, employment type, category and remote, then download the results as **JSON, CSV, Excel or XML** or pull them via the Apify API.

Need **European job market data** for a recruiting tool, a job board, market research, or a personal job alert? This scraper gives you a **deduplicated, normalized European jobs dataset** with salary estimates and apply links — no manual searching across dozens of sites.

### Why use EU Job Search Scraper?

- **One search, all of Europe** — collect thousands of **EU job postings** in minutes instead of checking many career sites by hand.
- **Every level and field** — students, graduates, full-time professionals, senior specialists and executives, across all industries.
- **Clean, structured output** — unified fields, **cross-source deduplication** (each job appears once), and **salary normalized to monthly EUR** for easy comparison.
- **Built for automation** — schedule daily/weekly runs, use **incremental mode** to get only new jobs, and connect to Google Sheets, Slack, webhooks, Zapier or Make via the Apify platform.
- **Use cases:** recruitment & sourcing, job board content, HR & labor-market analytics, relocation & immigration services, lead generation, and personal **job alerts in Europe**.

### How to use the EU jobs scraper

1. Click **Try for free**.
2. Enter your **keywords** (e.g. `["software engineer", "data analyst"]`) and **countries** (e.g. `["DE","FR","GB"]`). Leave keywords empty to browse everything and filter instead.
3. (Optional) Narrow by **seniority level**, **employment type**, **category**, **remote only**, or **posted within days**.
4. Click **Start**. When the run finishes, download the dataset as JSON / CSV / Excel / XML, or fetch it through the Apify API.

**Tip:** for a recurring **EU job alert**, schedule the actor and enable **Incremental mode** to receive only newly posted jobs each run.

### Input

| Field | Description |
|---|---|
| `keywords` | Search terms (OR logic). Multi-word entries match as a phrase. |
| `countries` | ISO-2 codes to include (empty = all supported European countries). |
| `seniorityLevels` | student · junior · mid · senior · lead · executive |
| `employmentTypes` | full-time · part-time · internship · working-student · apprenticeship · contract · temporary · freelance |
| `categories` | e.g. Software & IT, Finance & Accounting, Healthcare & Medical, Sales |
| `remoteOnly` | Return only remote-friendly jobs |
| `postedWithinDays` | Only jobs posted within N days |
| `maxResults` | Maximum jobs to collect per query |
| `incrementalMode` | Return only jobs not seen in previous runs |
| `translateKeywords` | Auto-match keywords in local languages |

### Output

Each job is returned as a structured record:

```json
{
  "id": "3a8f2c19e4b7d06f",
  "title": "Senior Frontend Developer",
  "company": "Example GmbH",
  "country": "DE",
  "city": "Berlin",
  "isRemote": true,
  "seniorityLevel": "senior",
  "employmentType": "full-time",
  "category": ["Software & IT"],
  "salaryMin": 65000,
  "salaryMax": 80000,
  "salaryCurrency": "EUR",
  "salaryMonthlyEur": 6042,
  "visaSponsorship": null,
  "postedDate": "2026-06-01",
  "descriptionSummary": "Short, privacy-safe summary of the role…",
  "applicationUrl": "https://…",
  "scrapedAt": "2026-06-13T10:00:00Z"
}
````

You can download the dataset in **JSON, CSV, Excel or XML**, or access it through the Apify API and integrations.

#### Output fields

| Field | Description |
|---|---|
| `title`, `company` | Job title and hiring company |
| `country`, `city`, `isRemote` | Location and remote flag |
| `seniorityLevel`, `employmentType`, `category` | Classified level, type and field |
| `salaryMin/Max`, `salaryCurrency`, `salaryMonthlyEur` | Salary range + estimated monthly EUR |
| `postedDate` | Date the job was posted |
| `descriptionSummary` | Short summary (personal contact details removed) |
| `applicationUrl` | Direct link to apply on the original posting |

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

Pricing is **pay-per-result** — you only pay for the jobs you receive. A typical search returns hundreds to a few thousand unique listings. Start on the **free tier** to test, then scale up with scheduled runs. See the actor's pricing tab for current rates.

### FAQ

**Which countries are covered?** All major European markets — Germany, France, the UK, Spain, Italy, the Netherlands, Sweden, Poland, Austria, Ireland, Belgium, Portugal, and more.

**Can I get only new jobs?** Yes — enable **Incremental mode** and schedule the run; you'll receive only jobs not seen before.

**Is the data deduplicated?** Yes. The same role appearing in multiple places is collapsed into a single record.

**How do I apply to a job?** Each record includes an `applicationUrl` linking to the original posting where you apply.

**Is this GDPR-friendly?** The output focuses on job and company information; direct personal contact details are removed from descriptions. You remain responsible for how you use the data under applicable laws.

**Data & legal.** This actor collects publicly available job listings and returns them as structured data with links back to the original postings. Use the data in compliance with applicable laws and the terms of the sites you visit when applying.

### Support

Found an issue or need a custom version (other regions, extra fields, larger volume)? Open an issue from the actor's **Issues** tab — we're happy to help.

# Actor input Schema

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

Job search terms, combined with OR (a job matching ANY keyword is kept). Use a multi-word entry like 'data analyst' to match that phrase. Leave empty to return all jobs and rely on the filters below.

## `countries` (type: `array`):

ISO-2 country codes to include, e.g. \['DE','FR','GB','NL','ES','SE','PL']. Leave empty to search across all supported European countries.

## `seniorityLevels` (type: `array`):

Filter by experience level. Empty = all. 'student' covers internships, working-student roles, apprenticeships and student jobs; use 'senior', 'lead' or 'executive' for leadership.

## `employmentTypes` (type: `array`):

Filter by employment type. Empty = all.

## `categories` (type: `array`):

Filter by job category, e.g. 'Software & IT', 'Finance & Accounting', 'Healthcare & Medical', 'Sales & Business Dev'. Empty = all.

## `remoteOnly` (type: `boolean`):

Return only jobs that can be done remotely.

## `postedWithinDays` (type: `integer`):

Only return jobs posted within this many days. Set to 0 to disable.

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

How many jobs to collect per source/query. Higher = more results (and longer runs / higher cost). Common searches can return 1000+ across sources; niche keywords return fewer. Use 'Maximum total results' to set a hard overall cap.

## `maxTotalResults` (type: `integer`):

Overall cap on the number of unique jobs returned. Set to 0 for no cap.

## `translateKeywords` (type: `boolean`):

Expand recognised keywords into the local languages of the selected countries (e.g. an English term also matches its German/French/Italian equivalents) to surface local-language postings.

## `deepMode` (type: `boolean`):

Search more thoroughly to return a larger, more complete result set. Slower and uses more compute — recommended only for bulk collection with a high 'Maximum results'.

## `incrementalMode` (type: `boolean`):

Return only jobs not seen in previous runs. Ideal for scheduled job alerts — run on a schedule and receive only the new postings each time.

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

Optional proxy settings.

## Actor input object example

```json
{
  "keywords": [
    "software engineer"
  ],
  "countries": [
    "DE"
  ],
  "seniorityLevels": [],
  "employmentTypes": [],
  "categories": [],
  "remoteOnly": false,
  "postedWithinDays": 30,
  "maxResults": 1000,
  "maxTotalResults": 0,
  "translateKeywords": true,
  "deepMode": false,
  "incrementalMode": false,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `dataset` (type: `string`):

No description

## `runMeta` (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"
    ],
    "countries": [
        "DE"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("scholarstack/eu-jobs-aggregator").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"],
    "countries": ["DE"],
}

# Run the Actor and wait for it to finish
run = client.actor("scholarstack/eu-jobs-aggregator").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"
  ],
  "countries": [
    "DE"
  ]
}' |
apify call scholarstack/eu-jobs-aggregator --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "EU Jobs Scraper – Search Jobs Across Europe",
        "description": "Scrape and search job listings across Europe in one run — all levels (student to executive) and all fields. Filter by keyword, country, seniority, type, category and remote. Clean, deduplicated JSON/CSV/Excel output with salary estimates — for recruiters, job boards, research and alerts.",
        "version": "1.0",
        "x-build-id": "LDsroHUz6FAAyCBDv"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scholarstack~eu-jobs-aggregator/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scholarstack-eu-jobs-aggregator",
                "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/scholarstack~eu-jobs-aggregator/runs": {
            "post": {
                "operationId": "runs-sync-scholarstack-eu-jobs-aggregator",
                "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/scholarstack~eu-jobs-aggregator/run-sync": {
            "post": {
                "operationId": "run-sync-scholarstack-eu-jobs-aggregator",
                "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 search terms, combined with OR (a job matching ANY keyword is kept). Use a multi-word entry like 'data analyst' to match that phrase. Leave empty to return all jobs and rely on the filters below.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "countries": {
                        "title": "Countries",
                        "type": "array",
                        "description": "ISO-2 country codes to include, e.g. ['DE','FR','GB','NL','ES','SE','PL']. Leave empty to search across all supported European countries.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "seniorityLevels": {
                        "title": "Seniority levels",
                        "type": "array",
                        "description": "Filter by experience level. Empty = all. 'student' covers internships, working-student roles, apprenticeships and student jobs; use 'senior', 'lead' or 'executive' for leadership.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "student",
                                "junior",
                                "mid",
                                "senior",
                                "lead",
                                "executive"
                            ]
                        },
                        "default": []
                    },
                    "employmentTypes": {
                        "title": "Employment types",
                        "type": "array",
                        "description": "Filter by employment type. Empty = all.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "full-time",
                                "part-time",
                                "internship",
                                "working-student",
                                "apprenticeship",
                                "contract",
                                "temporary",
                                "freelance"
                            ]
                        },
                        "default": []
                    },
                    "categories": {
                        "title": "Categories",
                        "type": "array",
                        "description": "Filter by job category, e.g. 'Software & IT', 'Finance & Accounting', 'Healthcare & Medical', 'Sales & Business Dev'. Empty = all.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "remoteOnly": {
                        "title": "Remote only",
                        "type": "boolean",
                        "description": "Return only jobs that can be done remotely.",
                        "default": false
                    },
                    "postedWithinDays": {
                        "title": "Posted within days",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only return jobs posted within this many days. Set to 0 to disable.",
                        "default": 30
                    },
                    "maxResults": {
                        "title": "Maximum results",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "How many jobs to collect per source/query. Higher = more results (and longer runs / higher cost). Common searches can return 1000+ across sources; niche keywords return fewer. Use 'Maximum total results' to set a hard overall cap.",
                        "default": 1000
                    },
                    "maxTotalResults": {
                        "title": "Maximum total results",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Overall cap on the number of unique jobs returned. Set to 0 for no cap.",
                        "default": 0
                    },
                    "translateKeywords": {
                        "title": "Auto-translate keywords",
                        "type": "boolean",
                        "description": "Expand recognised keywords into the local languages of the selected countries (e.g. an English term also matches its German/French/Italian equivalents) to surface local-language postings.",
                        "default": true
                    },
                    "deepMode": {
                        "title": "Deep search",
                        "type": "boolean",
                        "description": "Search more thoroughly to return a larger, more complete result set. Slower and uses more compute — recommended only for bulk collection with a high 'Maximum results'.",
                        "default": false
                    },
                    "incrementalMode": {
                        "title": "Incremental mode (new jobs only)",
                        "type": "boolean",
                        "description": "Return only jobs not seen in previous runs. Ideal for scheduled job alerts — run on a schedule and receive only the new postings each time.",
                        "default": false
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional proxy settings.",
                        "default": {
                            "useApifyProxy": false
                        }
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
