# GulfTalent Scraper - Middle East Jobs (`benthepythondev/gulftalent-scraper`) Actor

Scrape GulfTalent jobs with company, location, dates, job type, industry, requirements, company description and direct-apply indicators.

- **URL**: https://apify.com/benthepythondev/gulftalent-scraper.md
- **Developed by:** [Ben](https://apify.com/benthepythondev) (community)
- **Categories:** Jobs, Lead generation, Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.20 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## GulfTalent Scraper - Middle East Jobs

Collect structured job listings from **GulfTalent**, a major employment platform covering the Gulf and wider Middle East. Search by job title and optional country, or paste complete GulfTalent result URLs for a country, city, category, industry, seniority level, employer, or title. The Actor returns clean hiring-company, location, role, publication, description, and application data.

Detail enrichment is enabled by default. A result can include the full role description, responsibilities, requirements, company profile, job type, nationality preference, salary text, industry, job function, publication date, expiry date, company logo, and direct-apply indicators. Export the default dataset to JSON, CSV, Excel, or XML, use it through the Apify API, or connect it to Make, Zapier, n8n, webhooks, and your own services.

### What can you use it for?

- Monitor hiring activity across the UAE, Saudi Arabia, Qatar, Bahrain, Oman, Kuwait, Egypt, Jordan, and other GulfTalent markets.
- Build daily or weekly job alerts for selected roles and countries.
- Track which employers are recruiting for engineering, finance, construction, hospitality, sales, healthcare, or technology skills.
- Compare hiring demand by country, city, role, function, and industry.
- Create company prospect lists based on current public vacancies.
- Archive job descriptions and requirements before listings expire.
- Build recruiting dashboards, labor-market research, or talent-intelligence feeds.
- Route new jobs into a spreadsheet, CRM, database, Slack channel, email digest, or internal search product.

GulfTalent search pages are useful because they combine cross-country coverage with focused title, category, industry, and location pages. The Actor keeps the originating search URL and search rank on every row, so analysts can compare several market segments in one run.

### Input options

You can use simple title fields or complete search-result URLs.

#### Search by job title

Set `keyword` to a title such as `python developer`, `project manager`, `civil engineer`, `accountant`, or `sales manager`. The Actor converts the title to GulfTalent's public title-search path.

Add an optional `country` slug to restrict the search. Examples include `uae`, `saudi-arabia`, `qatar`, `bahrain`, `oman`, and `egypt`. Leave it empty to search all available countries.

```json
{
  "keyword": "python developer",
  "country": "uae",
  "includeDetails": true,
  "maxResults": 25
}
````

#### Use GulfTalent search URLs

Paste one or more complete URLs into `searchUrls` when you need a page configured by the website. This works for job-title, country, city, company, category, industry, or seniority searches. When URLs are supplied, the separate keyword and country fields are ignored.

```json
{
  "searchUrls": [
    "https://www.gulftalent.com/jobs/title/python-developer",
    "https://www.gulftalent.com/uae/jobs/city/dubai"
  ],
  "includeDetails": true,
  "maxResults": 50
}
```

`maxResults` is a global cap across the run. Duplicate job IDs found in overlapping searches are saved only once. The default is intentionally small so first runs, scheduled Tasks, and Apify quality checks finish quickly.

### Detail enrichment

Keep `includeDetails` enabled for recruiting, market research, and employer intelligence. The Actor opens each public vacancy page and reads its structured `JobPosting` data plus public role sections. This can add:

- complete job description;
- responsibilities and accountabilities;
- qualifications, experience, and requirements;
- public company description;
- employment type and direct-apply indicator;
- job function and company industry;
- nationality, gender, language, and salary text when shown;
- original publication and validity dates;
- company logo and structured country/location fields.

Disable enrichment when you only need the fastest possible search-card export. If an individual detail request fails, the Actor retains the available search summary rather than dropping the vacancy.

### Output fields

Each default-dataset row represents one unique GulfTalent vacancy. Common fields include:

| Field | Description |
| --- | --- |
| `id` | Stable GulfTalent job identifier |
| `title` | Vacancy title |
| `company` | Public hiring or recruiting company name |
| `company_url` | GulfTalent company profile |
| `company_logo` | Source-provided employer logo |
| `location`, `city`, `region`, `country` | Search and structured detail locations |
| `postal_code` | Postal code when supplied |
| `posted_display` | Date text shown on the search card |
| `date_posted` | Structured publication timestamp |
| `valid_through` | Listing validity or expiry timestamp |
| `description` | Clean complete role description |
| `responsibilities` | Public responsibilities section |
| `requirements` | Public qualifications and requirements section |
| `company_description` | Employer or recruiter profile text |
| `employment_types` | Structured employment-type list |
| `job_type` | Human-readable job type |
| `job_function` | GulfTalent role function |
| `industry` | Company industry |
| `salary` | Public salary text, including `Not Specified` when shown |
| `nationality`, `gender`, `arabic_fluency` | Public role preferences when present |
| `easy_apply`, `direct_apply` | Application-flow indicators |
| `lead_score` | Transparent record-completeness score |
| `url` | Canonical vacancy page |
| `search_url`, `source_page`, `search_rank` | Search provenance |
| `source_total_results` | Result count reported by GulfTalent |
| `scraped_at` | UTC collection timestamp |

Fields remain empty when GulfTalent or the employer does not disclose the value. The Actor does not invent salary, demographic preferences, or company information.

#### Example result

```json
{
  "id": "586154",
  "title": "Senior Python Developer",
  "company": "Propel Consult",
  "location": "Bahrain",
  "country": "Bahrain",
  "job_type": "Full Time",
  "industry": "Finance, Investment & Asset Management",
  "employment_types": ["FULL_TIME"],
  "direct_apply": true,
  "easy_apply": true,
  "date_posted": "2026-05-17T00:00:00+00:00",
  "valid_through": "2026-08-15T00:00:00+00:00",
  "lead_score": 100,
  "url": "https://www.gulftalent.com/bahrain/jobs/senior-python-developer-586154"
}
```

This demonstrates the shape of a real public listing used during validation. Live jobs and dates change continuously.

### Pricing

The Actor uses transparent pay-per-event pricing:

- a small Actor-start event covers run initialization;
- each unique job written to the default dataset is one `result` event at **$0.0012**;
- detail enrichment is included in the result price;
- duplicates discarded before output are not charged twice.

At the current rate, 1,000 unique jobs cost $1.20 plus the small start event. The Apify Console shows the complete pricing configuration before every run.

### Scheduling and automation

Create a saved Task for every market segment you monitor, then schedule it daily or weekly. Use `id` as the stable key in your destination and compare it with the previous run to identify newly advertised roles.

A practical workflow is:

1. Run one Task for a role and country.
2. Retrieve the default dataset through the API.
3. Upsert records by `id`.
4. Keep jobs not seen in the prior snapshot.
5. Deliver them to recruiters, analysts, a dashboard, or an alert channel.

For employer research, group results by `company`, `industry`, `job_function`, `country`, or `city`. For expiring-job workflows, filter by `valid_through` before sending notifications.

### Extraction and reliability

GulfTalent search pages render job rows in the initial HTML and expose structured result counts and pagination. Detail pages publish schema.org `JobPosting` data alongside human-readable role metadata. The Actor parses those structured surfaces instead of relying on visual browser coordinates.

Requests use Chrome-compatible TLS behavior with bounded retries and concurrency. The Actor starts with direct HTTP for low overhead. If GulfTalent rejects the datacenter route, it can rotate to a sticky UAE residential session. Result and page traversal are bounded, and a run that returns no usable jobs fails explicitly instead of appearing healthy with an empty dataset.

### Responsible use

The Actor reads public job and company information at runtime. It does not log in, submit applications, collect private candidate profiles, or bypass employer-only pages. It is not affiliated with or endorsed by GulfTalent.

Use the data for legitimate recruiting, job discovery, market analysis, and business research. Follow applicable terms, database rights, privacy rules, employment laws, and marketing requirements. Do not use nationality, gender, or language fields for unlawful discrimination. Avoid republishing full descriptions as a competing job board, and keep schedules proportionate to the workflow.

### FAQ

#### Does it require a GulfTalent account or API key?

No. It reads public search and vacancy pages.

#### Can it scrape a country or city page?

Yes. Copy the relevant GulfTalent URL and add it to `searchUrls`.

#### Can it return full descriptions and requirements?

Yes, when `includeDetails` is enabled and the public vacancy exposes those sections.

#### Why is salary empty or `Not Specified`?

Many employers do not publish compensation. The Actor preserves the public value rather than estimating one.

#### Can I provide several searches?

Yes. Add multiple URLs. The global `maxResults` cap applies across them, and repeated job IDs are returned once.

#### What happens if one detail page fails?

The search-card record is retained with available fields. The Actor does not add a separate charge for enrichment attempts.

#### How do I report a problem?

Open an issue on the Actor page with the run ID, a small reproducible input, and the expected result. Do not include credentials or private information. If the Actor is useful, a Store review helps other users evaluate it and supports maintenance priorities.

### Related Actors

- [Bayt Jobs Scraper](https://apify.com/benthepythondev/bayt-jobs-scraper) for another major Middle East employment source.
- [Naukri Jobs Scraper](https://apify.com/benthepythondev/naukri-jobs-scraper) for India-focused hiring data.
- [StepStone Scraper](https://apify.com/benthepythondev/stepstone-scraper) for European job-board monitoring.
- [Welcome to the Jungle Jobs Scraper](https://apify.com/benthepythondev/welcome-to-the-jungle-jobs-scraper) for employer-profile and startup hiring research.
- [Remote Jobs Aggregator](https://apify.com/benthepythondev/remote-jobs-aggregator) for normalized remote roles across several sources.

Keywords: GulfTalent scraper, Gulf jobs API, Middle East jobs data, UAE jobs scraper, Saudi Arabia jobs, Qatar jobs, Bahrain jobs, MENA hiring intelligence, employer hiring signals, recruitment research, GulfTalent export, Middle East job alerts.

# Actor input Schema

## `searchUrls` (type: `array`):

Optional GulfTalent search-result URLs. Use these for country, city, category, industry, seniority or title pages. When supplied, keyword and country are ignored.

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

Job title to search, for example python developer, project manager, accountant or civil engineer.

## `country` (type: `string`):

Optional GulfTalent country slug, for example uae, saudi-arabia, qatar, bahrain, oman or egypt. Leave empty for all countries.

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

Fetch full descriptions, requirements, company information, employment type, dates and role metadata.

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

Maximum unique GulfTalent jobs returned across all searches.

## Actor input object example

```json
{
  "searchUrls": [
    "https://www.gulftalent.com/jobs/title/python-developer"
  ],
  "keyword": "python developer",
  "country": "uae",
  "includeDetails": true,
  "maxResults": 5
}
```

# Actor output Schema

## `results` (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 = {
    "searchUrls": [
        "https://www.gulftalent.com/jobs/title/python-developer"
    ],
    "keyword": "python developer",
    "country": "uae",
    "includeDetails": true,
    "maxResults": 5
};

// Run the Actor and wait for it to finish
const run = await client.actor("benthepythondev/gulftalent-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 = {
    "searchUrls": ["https://www.gulftalent.com/jobs/title/python-developer"],
    "keyword": "python developer",
    "country": "uae",
    "includeDetails": True,
    "maxResults": 5,
}

# Run the Actor and wait for it to finish
run = client.actor("benthepythondev/gulftalent-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 '{
  "searchUrls": [
    "https://www.gulftalent.com/jobs/title/python-developer"
  ],
  "keyword": "python developer",
  "country": "uae",
  "includeDetails": true,
  "maxResults": 5
}' |
apify call benthepythondev/gulftalent-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "GulfTalent Scraper - Middle East Jobs",
        "description": "Scrape GulfTalent jobs with company, location, dates, job type, industry, requirements, company description and direct-apply indicators.",
        "version": "1.0",
        "x-build-id": "yo1CXj1xqRefARyoM"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/benthepythondev~gulftalent-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-benthepythondev-gulftalent-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/benthepythondev~gulftalent-scraper/runs": {
            "post": {
                "operationId": "runs-sync-benthepythondev-gulftalent-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/benthepythondev~gulftalent-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-benthepythondev-gulftalent-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": {
                    "searchUrls": {
                        "title": "GulfTalent search URLs",
                        "type": "array",
                        "description": "Optional GulfTalent search-result URLs. Use these for country, city, category, industry, seniority or title pages. When supplied, keyword and country are ignored.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "keyword": {
                        "title": "Job title",
                        "type": "string",
                        "description": "Job title to search, for example python developer, project manager, accountant or civil engineer.",
                        "default": "python developer"
                    },
                    "country": {
                        "title": "Country",
                        "type": "string",
                        "description": "Optional GulfTalent country slug, for example uae, saudi-arabia, qatar, bahrain, oman or egypt. Leave empty for all countries.",
                        "default": ""
                    },
                    "includeDetails": {
                        "title": "Enrich job details",
                        "type": "boolean",
                        "description": "Fetch full descriptions, requirements, company information, employment type, dates and role metadata.",
                        "default": true
                    },
                    "maxResults": {
                        "title": "Maximum results",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum unique GulfTalent jobs returned across all searches.",
                        "default": 10
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
