# theprotocol.it Job Scraper (`czub_w/theprotocol-it-job-scraper`) Actor

Scrapes IT job listings from theprotocol.it – Poland's leading IT job board. Extracts title, company, salary, tech stack, location, seniority, and full job descriptions. Supports keyword search, multi-filter (technology, city, category, seniority, contract type), pagination, and incremental mode.

- **URL**: https://apify.com/czub\_w/theprotocol-it-job-scraper.md
- **Developed by:** [Wiktor](https://apify.com/czub_w) (community)
- **Categories:** Jobs, Lead generation, Automation
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $17.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.
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

## theprotocol.it Job Scraper

Extract structured IT job listings from **[theprotocol.it](https://theprotocol.it)** — Poland's leading IT job board. Filter by technology, city, seniority, contract type, or keyword and get clean, ready-to-use data in JSON, CSV, or Excel.

No coding required. Runs entirely in the cloud.

### What does it do?

This Actor visits theprotocol.it, applies your filters, and collects detailed information from every matching job listing — automatically navigating through all result pages. For each offer it extracts:

- Job title, company name, and direct link to the offer
- Salary range (min / max / currency / pay period / contract type)
- Work location with remote / hybrid / on-site flags
- Required technologies and skills
- Job category and seniority level
- Publication date
- Full job description

### How to use

1. Go to the Actor page and click **Try for free**
2. Fill in the **Input** form — all fields are optional, leave them empty to scrape all listings
3. Click **Start** and wait a few minutes for the run to finish
4. Open the **Output** tab and download your results as JSON, CSV, or Excel

### Input

All fields are optional. Combining multiple fields narrows the search (AND logic); multiple values within one field broaden it (OR logic).

| Field | Type | Description | Example |
|---|---|---|---|
| `keyword` | string | Job title, company name, or any keyword | `"React Developer"` |
| `technologies` | string[] | Technology / skill filter | `["javascript", "react"]` |
| `categories` | checkboxes | Specialization category | Frontend, Backend, DevOps… |
| `locations` | string[] | City filter (Polish diacritics handled) | `["Warszawa", "Kraków"]` |
| `seniorityLevels` | checkboxes | Experience level | Junior, Mid, Senior… |
| `contractTypes` | checkboxes | Contract type | B2B, Employment contract… |
| `maxResults` | integer | Max offers to collect (0 = all) | `100` |
| `incrementalMode` | boolean | Skip offers scraped in previous runs | `true` |
| `proxyConfiguration` | object | Proxy settings (Residential recommended) | — |

#### Example input (JSON)

```json
{
  "technologies": ["javascript", "typescript"],
  "categories": ["frontend"],
  "locations": ["Warszawa"],
  "seniorityLevels": ["senior"],
  "contractTypes": ["b2b"],
  "maxResults": 50
}
````

### Output

Each job offer is saved as one JSON record in the dataset.

```json
{
  "title": "Senior Frontend Developer",
  "company": "Example Sp. z o.o.",
  "url": "https://theprotocol.it/szczegoly/praca/senior-frontend-developer-warszawa,oferta,abc123",
  "postedAt": "2026-05-20T09:00:00.000Z",
  "locations": [
    { "city": "Warszawa", "isRemote": false, "isHybrid": true, "isOnsite": false }
  ],
  "salary": {
    "min": 18000,
    "max": 26000,
    "currency": "PLN",
    "period": "mies.",
    "kind": "netto",
    "contractTypes": ["kontrakt B2B"]
  },
  "technologies": ["JavaScript", "TypeScript", "React", "Next.js"],
  "categories": ["Frontend"],
  "seniorityLevels": ["senior"],
  "description": "About the project, Join our growing team..."
}
```

#### Output fields

| Field | Type | Description |
|---|---|---|
| `title` | string | Job position name |
| `company` | string | Hiring company name |
| `url` | string | Direct link to the offer |
| `postedAt` | string | Publication date (ISO 8601) |
| `locations` | array | `[{ city, isRemote, isHybrid, isOnsite }]` |
| `salary.min` | number | Minimum salary (`null` if not disclosed) |
| `salary.max` | number | Maximum salary (`null` if not disclosed) |
| `salary.currency` | string | Currency (PLN, EUR, …) |
| `salary.period` | string | Pay period (e.g. `mies.` = monthly, `godz.` = hourly) |
| `salary.kind` | string | Net / gross indicator (e.g. `netto (+ VAT)`) |
| `salary.contractTypes` | array | Contract types this salary applies to |
| `technologies` | array | Required and nice-to-have tech stack |
| `categories` | array | Job specialization categories |
| `seniorityLevels` | array | Required experience levels |
| `description` | string | Full job description text |

### Pricing

This Actor runs on Apify's pay-as-you-go infrastructure. Typical costs:

| Scenario | Jobs collected | Estimated cost |
|---|---|---|
| Targeted filter (e.g. senior JavaScript in Warsaw) | ~50–150 | < $0.20 |
| Broad technology filter (e.g. all JavaScript jobs) | ~200–500 | ~$0.50–1.00 |
| Full board scrape | ~3 000–5 000 | ~$3–8 |
| Daily incremental (new listings only) | ~50–150 | < $0.20 |

**Tip:** Enable **Incremental mode** and schedule the Actor to run daily. It remembers which offers it has already seen and only collects new ones — keeping your costs low.

### Tips

- **Filters are cumulative** — selecting "Senior" + "Warsaw" + "JavaScript" returns only offers that match all three.
- **Multiple values in one filter** are OR-matched — selecting "Junior" and "Mid" returns both levels.
- **Proxy** — Apify Residential proxies are strongly recommended. The site detects and blocks datacenter IPs.
- **Max results** — set `maxResults` to a small number (e.g. 10) when testing to avoid unnecessary costs.
- **Scheduling** — use Apify's built-in scheduler to run the Actor automatically every day or week.

### FAQ

**Is this legal?**
The Actor only collects publicly available job listings. Use the data responsibly and in accordance with theprotocol.it's Terms of Service and applicable data protection laws.

**Salary shows as `null`.**
Many employers choose not to publish a salary range. This is common practice on theprotocol.it — not a scraping error.

**I'm getting fewer results than expected.**
The site may throttle frequent requests. Try switching to Apify Residential proxies and reducing concurrency to 1 in the proxy settings.

**How do I get only new jobs each day?**
Enable **Incremental mode** and set up a daily schedule in Apify Console. The Actor stores previously seen offer URLs and skips them on subsequent runs.

**How do I report a problem or request a feature?**
Open an issue on the Actor page. Custom scraping solutions are available on request.

# Actor input Schema

## `keyword` (type: `string`):

Free-text keyword to search (e.g. company name, job title). Maps to /praca?kw=.

## `technologies` (type: `array`):

Filter by tech stack. Type the technology name as used on theprotocol.it (e.g. 'javascript', 'python', 'next.js', 'asp.net-web-api'). Multiple values are OR-matched.

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

Filter by job specialization. Select one or more categories.

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

Filter by city. Polish diacritics are handled automatically (e.g. 'Kraków', 'Łódź', 'Warszawa'). Multiple values are OR-matched.

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

Filter by experience level. Select one or more.

## `contractTypes` (type: `array`):

Filter by employment contract type. Select one or more.

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

Maximum number of job listings to scrape. Set to 0 to scrape all available results.

## `maxRequestsPerCrawl` (type: `integer`):

Hard cap on the total number of HTTP requests (listing + detail pages combined). 0 = unlimited. Useful during testing.

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

When enabled, job offers already scraped in previous runs are skipped. Ideal for daily scheduled runs — only new listings are collected.

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

Proxy settings. Apify Residential proxies are strongly recommended — the site blocks datacenter IPs.

## Actor input object example

```json
{
  "keyword": "React Developer",
  "technologies": [
    "javascript",
    "python",
    "java"
  ],
  "categories": [],
  "locations": [
    "Warszawa",
    "Kraków",
    "Wrocław",
    "Gdańsk",
    "Poznań"
  ],
  "seniorityLevels": [],
  "contractTypes": [],
  "maxResults": 0,
  "maxRequestsPerCrawl": 0,
  "incrementalMode": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

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

No description

## `seenUrls` (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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("czub_w/theprotocol-it-job-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 = {}

# Run the Actor and wait for it to finish
run = client.actor("czub_w/theprotocol-it-job-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 '{}' |
apify call czub_w/theprotocol-it-job-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "theprotocol.it Job Scraper",
        "description": "Scrapes IT job listings from theprotocol.it – Poland's leading IT job board. Extracts title, company, salary, tech stack, location, seniority, and full job descriptions. Supports keyword search, multi-filter (technology, city, category, seniority, contract type), pagination, and incremental mode.",
        "version": "1.0",
        "x-build-id": "qhS4gD5ffZnttUL8d"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/czub_w~theprotocol-it-job-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-czub_w-theprotocol-it-job-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/czub_w~theprotocol-it-job-scraper/runs": {
            "post": {
                "operationId": "runs-sync-czub_w-theprotocol-it-job-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/czub_w~theprotocol-it-job-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-czub_w-theprotocol-it-job-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": {
                    "keyword": {
                        "title": "Keyword search",
                        "type": "string",
                        "description": "Free-text keyword to search (e.g. company name, job title). Maps to /praca?kw=."
                    },
                    "technologies": {
                        "title": "Technologies / skills",
                        "type": "array",
                        "description": "Filter by tech stack. Type the technology name as used on theprotocol.it (e.g. 'javascript', 'python', 'next.js', 'asp.net-web-api'). Multiple values are OR-matched.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "categories": {
                        "title": "Specialization / category",
                        "type": "array",
                        "description": "Filter by job specialization. Select one or more categories.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "frontend",
                                "backend",
                                "fullstack",
                                "mobile",
                                "devops",
                                "testing",
                                "data",
                                "ai-ml",
                                "security",
                                "pm",
                                "ux-ui",
                                "other"
                            ],
                            "enumTitles": [
                                "Frontend",
                                "Backend",
                                "Full-stack",
                                "Mobile",
                                "DevOps / SysOps",
                                "Testing / QA",
                                "Data",
                                "AI / ML",
                                "Security",
                                "Project Management",
                                "UX / UI",
                                "Other"
                            ]
                        },
                        "default": []
                    },
                    "locations": {
                        "title": "Locations (cities)",
                        "type": "array",
                        "description": "Filter by city. Polish diacritics are handled automatically (e.g. 'Kraków', 'Łódź', 'Warszawa'). Multiple values are OR-matched.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "seniorityLevels": {
                        "title": "Seniority levels",
                        "type": "array",
                        "description": "Filter by experience level. Select one or more.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "trainee",
                                "junior",
                                "mid",
                                "senior",
                                "lead",
                                "expert"
                            ],
                            "enumTitles": [
                                "Trainee",
                                "Junior",
                                "Mid",
                                "Senior",
                                "Lead",
                                "Expert"
                            ]
                        },
                        "default": []
                    },
                    "contractTypes": {
                        "title": "Contract types",
                        "type": "array",
                        "description": "Filter by employment contract type. Select one or more.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "b2b",
                                "umowa-o-prace",
                                "umowa-zlecenie",
                                "umowa-o-dzielo",
                                "umowa-o-staz--praktyki"
                            ],
                            "enumTitles": [
                                "B2B",
                                "Employment contract (umowa o pracę)",
                                "Contract of mandate (umowa zlecenie)",
                                "Contract for specific work (umowa o dzieło)",
                                "Internship / Apprenticeship"
                            ]
                        },
                        "default": []
                    },
                    "maxResults": {
                        "title": "Max results",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of job listings to scrape. Set to 0 to scrape all available results.",
                        "default": 0
                    },
                    "maxRequestsPerCrawl": {
                        "title": "Max requests per crawl",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Hard cap on the total number of HTTP requests (listing + detail pages combined). 0 = unlimited. Useful during testing.",
                        "default": 0
                    },
                    "incrementalMode": {
                        "title": "Incremental mode",
                        "type": "boolean",
                        "description": "When enabled, job offers already scraped in previous runs are skipped. Ideal for daily scheduled runs — only new listings are collected.",
                        "default": false
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Proxy settings. Apify Residential proxies are strongly recommended — the site blocks datacenter IPs.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
