# Jora Scraper Ppe (`silentflow/jora-scraper-ppe`) Actor

Scrape job listings from Jora.com across Australia, New Zealand, and Singapore. Extract titles, companies, salaries, locations, job types, full descriptions, employer ratings, and posting dates. Pay only per result with proxies included. Supports deduplication.

- **URL**: https://apify.com/silentflow/jora-scraper-ppe.md
- **Developed by:** [SilentFlow](https://apify.com/silentflow) (community)
- **Categories:** Jobs, Automation
- **Stats:** 6 total users, 2 monthly users, 100.0% runs succeeded, 2 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.90 / 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.
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

## Jora Scraper - Pay Per Event

by [SilentFlow](https://apify.com/silentflow)

**Pay only for the data you get!** Proxies included, no compute costs.

Extract structured job listings from Jora.com across Australia, New Zealand, and Singapore. Search by keywords and location, get job titles, companies, salaries, full descriptions, and more.

### Why use this scraper?

- **No login required**: Access public job listings without authentication
- **Multi-country support**: Scrape jobs from Australia (AU), New Zealand (NZ), and Singapore (SG)
- **Full job descriptions**: Optionally visit each job page to get the complete description text
- **Rich job data**: Titles, companies, locations, job types, salaries, company ratings, posting dates
- **Separated salary field**: Salary data is cleanly separated from job type
- **AI summary detection**: Know whether the job summary was AI-generated or original
- **High reliability**: Automatic retry on failures with session rotation
- **Flexible input**: Search by keywords, location, or provide direct Jora URLs

### Use cases

| Industry | Application |
|----------|-------------|
| **Recruiting** | Aggregate job listings across AU, NZ, and SG for candidate sourcing |
| **Market research** | Analyze job volumes, salary ranges, and regional demand by role |
| **HR analytics** | Track hiring trends, popular job types, and employer activity |
| **Data science** | Build job market datasets for NLP, classification, or trend analysis |
| **Competitive intelligence** | Monitor competitor hiring patterns and new roles |

### Input parameters

#### URL Scraping

| Parameter | Type | Description |
|-----------|------|-------------|
| `startUrls` | array | Jora search result URLs to scrape directly |

#### Search

| Parameter | Type | Description |
|-----------|------|-------------|
| `searches` | string[] | Job search terms (e.g., "Software Developer", "Nurse") |
| `location` | string | City or region filter (e.g., "Sydney NSW", "Auckland") |
| `country` | select | Country site: `au` (Australia), `nz` (New Zealand), `sg` (Singapore) |

#### Limits

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `maxItems` | integer | 50 | Maximum total job listings to save |
| `maxPages` | integer | 10 | Maximum result pages per search |

#### Advanced

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `scrapeDetails` | boolean | false | Visit each job page to get full descriptions |
| `requestTimeout` | integer | 30 | HTTP request timeout in seconds |
| `debugMode` | boolean | false | Enable detailed logs |

### Output data

#### Job listing example

```json
{
  "jobId": "12b4304ebefa330af56a2d9dcc01f79f",
  "url": "https://au.jora.com/job/Software-Engineer-12b4304ebefa330af56a2d9dcc01f79f?...",
  "title": "Software Engineer",
  "company": "Crystal Delta",
  "location": "Melbourne VIC",
  "jobType": "Full time",
  "salary": "$85,000 - $95,000 a year",
  "summary": "Crystal Delta is hiring a Full time Software Engineer role in Melbourne, VIC...",
  "description": "Crystal Delta is hiring a Full time Software Engineer role in Melbourne, VIC. Apply now to be part of our team.\n\nRequirements for this role:...",
  "postedDate": "Posted 12h ago",
  "isSponsored": true,
  "isNewJob": true,
  "isEarlyApplicant": false,
  "companyRating": 4.0,
  "hasQuickApply": true,
  "abstractType": "extended_llm",
  "searchRank": 1,
  "country": "au",
  "searchQuery": "Software Developer",
  "scrapedAt": "2026-02-26T12:53:40Z",
  "dataType": "jobListing"
}
````

### Data fields

| Category | Fields |
|----------|--------|
| **Identity** | jobId, url, title |
| **Employer** | company, companyRating |
| **Location** | location, country |
| **Job details** | jobType, salary, summary, description, hasQuickApply |
| **Listing info** | postedDate, isSponsored, isNewJob, isEarlyApplicant, abstractType, searchRank |
| **Metadata** | searchQuery, scrapedAt, dataType |

### Examples

#### Search for developers in Sydney

```json
{
  "searches": ["Software Developer"],
  "location": "Sydney NSW",
  "country": "au",
  "maxItems": 100
}
```

#### Search with full descriptions

```json
{
  "searches": ["Data Analyst"],
  "country": "au",
  "scrapeDetails": true,
  "maxItems": 50
}
```

#### Search multiple roles in New Zealand

```json
{
  "searches": ["Nurse", "Doctor", "Pharmacist"],
  "country": "nz",
  "maxItems": 200,
  "maxPages": 20
}
```

#### Scrape a specific Jora search URL

```json
{
  "startUrls": [
    { "url": "https://sg.jora.com/Data-Analyst-jobs" }
  ],
  "maxItems": 50
}
```

### Integrations

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_API_TOKEN>")

run_input = {
    "searches": ["Software Developer"],
    "location": "Melbourne VIC",
    "country": "au",
    "scrapeDetails": True,
    "maxItems": 100,
}

run = client.actor("silentflow/jora-scraper-ppe").call(run_input=run_input)

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(f"{item['title']} at {item['company']} - {item['location']}")
    if item.get('description'):
        print(f"  Description: {item['description'][:100]}...")
```

#### JavaScript

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

const client = new ApifyClient({ token: '<YOUR_API_TOKEN>' });

const input = {
    searches: ['Software Developer'],
    location: 'Melbourne VIC',
    country: 'au',
    scrapeDetails: true,
    maxItems: 100,
};

const run = await client.actor('silentflow/jora-scraper-ppe').call(input);

const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach(item => {
    console.log(`${item.title} at ${item.company} - ${item.location}`);
});
```

### Performance & limits

| Metric | Value |
|--------|-------|
| Results per page | ~6-10 listings |
| Typical speed (search only) | ~3 pages/minute |
| Typical speed (with details) | ~3-4 items/minute |
| Supported countries | AU, NZ, SG |

### Tips for best results

1. **Start with a specific search**: Use targeted keywords like "Software Engineer" rather than broad terms
2. **Add location for precision**: Filter by city or state to get relevant local results
3. **Use reasonable limits**: Start with 50-100 items to test, then scale up
4. **Multiple searches**: Run several keyword searches in one run to cover different roles
5. **Enable details for rich data**: Use `scrapeDetails: true` when you need full job descriptions

### FAQ

**Q: Which countries are supported?**
A: Australia (au.jora.com), New Zealand (nz.jora.com), and Singapore (sg.jora.com).

**Q: Does the scraper get full job descriptions?**
A: Yes! Enable `scrapeDetails` to visit each job page and extract the complete description. Without it, you get the search result summary.

**Q: What is `abstractType`?**
A: It indicates how the job summary was generated. `extended_llm` means AI-generated summary, `original` means the employer's original text.

**Q: What happens if the site blocks requests?**
A: The scraper automatically retries with session rotation. Proxies are included in the PPE plan.

**Q: How many results can I get?**
A: Jora typically shows up to ~500 results per search query. Use multiple search terms to get more data.

**Q: Are salary details included?**
A: Yes, salary is extracted as a dedicated field when available on the listing (e.g., "$85,000 - $95,000 a year").

### Support

Need help? We're here for you:

- **Feature requests**: Let us know what you need
- **Custom solutions**: Contact us for enterprise integrations or high-volume needs

Check out our other scrapers: [SilentFlow on Apify](https://apify.com/silentflow)

# Actor input Schema

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

Jora search result URL(s) to scrape directly (e.g., https://au.jora.com/Software-Developer-jobs).

## `searches` (type: `array`):

Job search terms (e.g., 'Software Developer', 'Nurse', 'Accountant').

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

City or region to filter results (e.g., 'Sydney NSW', 'Auckland', 'Singapore').

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

Jora country site to scrape.

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

The maximum total number of job listings to save.

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

Maximum number of result pages to scrape per search query.

## `scrapeDetails` (type: `boolean`):

Visit each job detail page to extract the full description. Slower but provides much richer data.

## `requestTimeout` (type: `integer`):

HTTP request timeout in seconds.

## `debugMode` (type: `boolean`):

Activate to see detailed logs.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://au.jora.com/Software-Developer-jobs"
    }
  ],
  "location": "",
  "country": "au",
  "maxItems": 50,
  "maxPages": 10,
  "scrapeDetails": false,
  "requestTimeout": 30,
  "debugMode": false
}
```

# Actor output Schema

## `results` (type: `string`):

Complete job listing data including: jobId, url, title, company, location, jobType, summary, postedDate, isSponsored, companyRating, hasQuickApply, country, searchQuery, scrapedAt.

## `resultsCSV` (type: `string`):

CSV format export for spreadsheet analysis

## `resultsExcel` (type: `string`):

Excel format export

# 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 = {
    "startUrls": [
        {
            "url": "https://au.jora.com/Software-Developer-jobs"
        }
    ],
    "location": "",
    "country": "au",
    "maxItems": 50,
    "maxPages": 10,
    "requestTimeout": 30
};

// Run the Actor and wait for it to finish
const run = await client.actor("silentflow/jora-scraper-ppe").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 = {
    "startUrls": [{ "url": "https://au.jora.com/Software-Developer-jobs" }],
    "location": "",
    "country": "au",
    "maxItems": 50,
    "maxPages": 10,
    "requestTimeout": 30,
}

# Run the Actor and wait for it to finish
run = client.actor("silentflow/jora-scraper-ppe").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 '{
  "startUrls": [
    {
      "url": "https://au.jora.com/Software-Developer-jobs"
    }
  ],
  "location": "",
  "country": "au",
  "maxItems": 50,
  "maxPages": 10,
  "requestTimeout": 30
}' |
apify call silentflow/jora-scraper-ppe --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Jora Scraper Ppe",
        "description": "Scrape job listings from Jora.com across Australia, New Zealand, and Singapore. Extract titles, companies, salaries, locations, job types, full descriptions, employer ratings, and posting dates. Pay only per result with proxies included. Supports deduplication.",
        "version": "1.0",
        "x-build-id": "m6alji1w0ZDUFV5Kh"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/silentflow~jora-scraper-ppe/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-silentflow-jora-scraper-ppe",
                "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/silentflow~jora-scraper-ppe/runs": {
            "post": {
                "operationId": "runs-sync-silentflow-jora-scraper-ppe",
                "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/silentflow~jora-scraper-ppe/run-sync": {
            "post": {
                "operationId": "run-sync-silentflow-jora-scraper-ppe",
                "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": {
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "Jora search result URL(s) to scrape directly (e.g., https://au.jora.com/Software-Developer-jobs).",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "searches": {
                        "title": "Search queries",
                        "type": "array",
                        "description": "Job search terms (e.g., 'Software Developer', 'Nurse', 'Accountant').",
                        "items": {
                            "type": "string"
                        }
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "City or region to filter results (e.g., 'Sydney NSW', 'Auckland', 'Singapore').",
                        "default": ""
                    },
                    "country": {
                        "title": "Country",
                        "enum": [
                            "au",
                            "nz",
                            "sg"
                        ],
                        "type": "string",
                        "description": "Jora country site to scrape.",
                        "default": "au"
                    },
                    "maxItems": {
                        "title": "Maximum number of items",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "The maximum total number of job listings to save.",
                        "default": 50
                    },
                    "maxPages": {
                        "title": "Maximum pages per search",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Maximum number of result pages to scrape per search query.",
                        "default": 10
                    },
                    "scrapeDetails": {
                        "title": "Scrape full job descriptions",
                        "type": "boolean",
                        "description": "Visit each job detail page to extract the full description. Slower but provides much richer data.",
                        "default": false
                    },
                    "requestTimeout": {
                        "title": "Request timeout (seconds)",
                        "minimum": 10,
                        "maximum": 120,
                        "type": "integer",
                        "description": "HTTP request timeout in seconds.",
                        "default": 30
                    },
                    "debugMode": {
                        "title": "Debug Mode",
                        "type": "boolean",
                        "description": "Activate to see detailed logs.",
                        "default": 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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
