# JobsDB Jobs Scraper — HK & Thailand Hiring Data (`khadinakbar/jobsdb-jobs-scraper`) Actor

Scrape public JobsDB listings in Hong Kong and Thailand for recruiting and hiring research. Returns validated jobs with employer, location, salary, classification, description, dates, and apply URL. Not for private candidate or applicant data. /bin/zsh.00375 per persisted job plus platform usage.

- **URL**: https://apify.com/khadinakbar/jobsdb-jobs-scraper.md
- **Developed by:** [Khadin Akbar](https://apify.com/khadinakbar) (community)
- **Categories:** Jobs, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.75 / 1,000 jobsdb job record scrapeds

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

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

## JobsDB Jobs Scraper

Extract structured public job listings from JobsDB in Hong Kong and Thailand. This Actor is designed for recruiters, talent intelligence teams, workforce researchers, and AI agents that need a clean, repeatable view of current hiring demand.

Use it when you need JobsDB search results by role, location, recency, or a known public JobsDB URL. It returns one validated dataset record per job, including the title, employer, location, available salary information, employment type, classification, description, posting date, and direct public job URL. It does not apply to jobs, access employer accounts, retrieve applicant data, or access private candidate profiles.

### When to use it

Use this Actor for:

- Building a recruiter sourcing list for a role in Hong Kong or Thailand.
- Monitoring hiring volume for competitors or a market segment.
- Collecting salary ranges where JobsDB makes them public.
- Creating a job-market dataset for research, dashboards, or an agent workflow.
- Refreshing a known public JobsDB search URL on a schedule.

Do not use it for JobStreet markets outside Hong Kong and Thailand, LinkedIn jobs, private employer dashboards, or candidate contact data. Those are different data surfaces with different access and reliability characteristics.

### Inputs

The default search is `software engineer` in Hong Kong, sorted by newest listing, for up to 20 records. Set `country` to `HK` or `TH`, use `location` to narrow by a city or region, and use `postedWithinDays` to focus on fresh listings. `maxResults` is both a result cap and the upper bound for the per-job event charge.

Set `includeJobDetails` to true when you need the public detail-page description. This produces richer records and can take longer because the Actor visits the selected public vacancies. Turn it off for a faster listing-only collection. Use `startUrls` only for public `hk.jobsdb.com` or `th.jobsdb.com` search or job pages; foreign hosts are rejected as actionable invalid input rather than silently ignored.

Example input:

```json
{
  "keywords": "data engineer",
  "country": "HK",
  "location": "Central",
  "postedWithinDays": "7",
  "sortBy": "date",
  "maxResults": 50,
  "includeJobDetails": true
}
````

### Output

Every dataset item uses the same flat, agent-friendly structure. Fields not exposed by the public page are explicitly `null`, rather than guessed.

| Field | Meaning |
| --- | --- |
| `jobId` | Stable public JobsDB vacancy identifier. |
| `title` | Public job title. |
| `companyName`, `companyUrl` | Employer identity and public profile URL when exposed. |
| `location`, `country` | Public location text and selected market code. |
| `salaryText`, `salaryCurrency`, `salaryMin`, `salaryMax`, `salaryPeriod` | Public salary data, parsed only when supportable. |
| `workType`, `workArrangement` | Employment and workplace arrangement when shown. |
| `classification`, `subClassification` | Public JobsDB role taxonomy when shown. |
| `description` | Public teaser or enriched detail description. |
| `jobUrl` | Canonical public vacancy URL. |
| `postedAt`, `postedText` | Structured and original posting dates where exposed. |
| `sourceUrl`, `scrapedAt` | Search source and collection timestamp. |

Example result:

```json
{
  "jobId": "92506170",
  "title": "Senior Data Engineer",
  "companyName": "Example Limited",
  "companyUrl": null,
  "location": "Central",
  "country": "HK",
  "salaryText": "HK$30,000 - HK$45,000 per month",
  "salaryCurrency": "HKD",
  "salaryMin": 30000,
  "salaryMax": 45000,
  "salaryPeriod": "month",
  "workType": "Full time",
  "workArrangement": null,
  "classification": "Information Technology",
  "subClassification": "Developers/Programmers",
  "description": "Build data pipelines and cloud services.",
  "jobUrl": "https://hk.jobsdb.com/job/92506170",
  "postedAt": "2026-07-19T00:00:00.000Z",
  "postedText": "1d ago",
  "sourceUrl": "https://hk.jobsdb.com/data-engineer-jobs",
  "scrapedAt": "2026-07-19T12:00:00.000Z"
}
```

### Pricing

This Actor uses Pay per event + usage. It charges `$0.00005` for the actor-start event and `$0.00375` only for each validated job record successfully persisted to the default dataset. Platform compute and residential proxy usage are billed separately by Apify under the usage pass-through setting.

For example, a run capped at 20 job records has a maximum job-event charge of `$0.075`, plus the actor-start event and platform usage. The Actor logs this maximum event charge at run start and reports the actual charged-event count in `OUTPUT` and `RUN_SUMMARY`. It never charges a job record before it has been validated and persisted.

### Reliability and outcomes

JobsDB uses anti-bot protections, so the Actor uses a country-matched Apify Residential proxy with a consistent Chromium session. It captures structured public responses when the site exposes them and falls back to embedded JSON-LD, embedded JSON, and visible listing cards. Detail-page failure never discards a valid listing record; the Actor preserves it with a warning.

Every run writes two key-value records:

- `OUTPUT` is a compact machine-readable terminal contract.
- `RUN_SUMMARY` contains page, record, validation, billing, warning, and error diagnostics.

`COMPLETE`, `PARTIAL`, `VALID_EMPTY`, and `INVALID_INPUT` finish successfully. `UPSTREAM_FAILED` is used only if every required public route failed and no useful records were recovered. This makes empty searches, user-correctable input mistakes, and target outages distinguishable in automations.

### Practical guidance

Start with 20–50 records while validating a query. Use a specific role and location for more predictable results. If a run returns `VALID_EMPTY`, broaden the keyword, remove the location, or choose `any` for the posting window. If a run returns `UPSTREAM_FAILED`, retry later; the run summary will state whether the browser session was blocked or the public target did not respond.

JobsDB public pages may change their presentation over time. The Actor does not fabricate fields when the public data changes. It preserves useful data where possible, flags recoverable degradation as `PARTIAL`, and honestly reports an upstream failure if no supported public route remains.

### Data responsibility

Use this Actor only for legitimate recruiting, market-research, analytics, and workflow purposes. Respect applicable privacy, employment, and data-protection obligations. The Actor intentionally limits its scope to public job-posting data and does not collect private account, candidate, applicant, or application-submission information.

# Actor input Schema

## `keywords` (type: `string`):

Use this when you need a public JobsDB keyword search, for example 'senior data engineer'. Enter ordinary job-search text up to 120 characters. The default is 'software engineer'. This is not a JobsDB URL or applicant name.

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

Use this when choosing the public JobsDB market to search. Select HK for Hong Kong or TH for Thailand, for example 'HK'. The default is HK. This is not a city or an all-country mode.

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

Use this when narrowing a JobsDB search to a city or region, for example 'Central' or 'Bangkok'. Leave it empty to search the selected country. The default is empty. This is not a country code; choose country separately.

## `postedWithinDays` (type: `string`):

Use this when you need recent JobsDB listings. Select a number of days such as '7', or 'any' to retain every listing returned by the target. The default is 7 days. Listings without an exposed timestamp are retained because the actor cannot truthfully infer their age.

## `sortBy` (type: `string`):

Use this when choosing JobsDB's public keyword order. Select 'date' for newest available listings or 'relevance' for the target's keyword ordering. The default is date. This is a search preference, not a guarantee that the target exposes all ranking signals.

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

Use this when capping returned records and Pay per event charges. Enter an integer from 1 to 500, for example 50. The default is 20 and the maximum event charge is displayed at run start. This is not a page count and cannot return over 500 rows.

## `includeJobDetails` (type: `boolean`):

Use this when you want the actor to visit each selected public job page for a fuller description. Set true for richer records or false for faster search-result records. The default is true. This does not bypass a login wall or retrieve applicant information.

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

Use this when you need to scrape one or more known public JobsDB pages instead of generating a keyword search. Each entry must be an hk.jobsdb.com or th.jobsdb.com URL, for example 'https://hk.jobsdb.com/software-engineer-jobs'. Leave empty to use keywords, country, and location. This is not for job-board URLs from other sites.

## Actor input object example

```json
{
  "keywords": "data analyst",
  "country": "TH",
  "location": "Bangkok",
  "postedWithinDays": "7",
  "sortBy": "date",
  "maxResults": 50,
  "includeJobDetails": true,
  "startUrls": [
    {
      "url": "https://hk.jobsdb.com/software-engineer-jobs"
    }
  ]
}
```

# Actor output Schema

## `jobs` (type: `string`):

No description

## `output` (type: `string`):

No description

## `summary` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "keywords": "software engineer",
    "country": "HK",
    "postedWithinDays": "7",
    "sortBy": "date",
    "maxResults": 20,
    "includeJobDetails": true,
    "startUrls": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("khadinakbar/jobsdb-jobs-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "keywords": "software engineer",
    "country": "HK",
    "postedWithinDays": "7",
    "sortBy": "date",
    "maxResults": 20,
    "includeJobDetails": True,
    "startUrls": [],
}

# Run the Actor and wait for it to finish
run = client.actor("khadinakbar/jobsdb-jobs-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "keywords": "software engineer",
  "country": "HK",
  "postedWithinDays": "7",
  "sortBy": "date",
  "maxResults": 20,
  "includeJobDetails": true,
  "startUrls": []
}' |
apify call khadinakbar/jobsdb-jobs-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "JobsDB Jobs Scraper — HK & Thailand Hiring Data",
        "description": "Scrape public JobsDB listings in Hong Kong and Thailand for recruiting and hiring research. Returns validated jobs with employer, location, salary, classification, description, dates, and apply URL. Not for private candidate or applicant data. /bin/zsh.00375 per persisted job plus platform usage.",
        "version": "1.3",
        "x-build-id": "twR5fj8jGEQnXa6Qz"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/khadinakbar~jobsdb-jobs-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-khadinakbar-jobsdb-jobs-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/khadinakbar~jobsdb-jobs-scraper/runs": {
            "post": {
                "operationId": "runs-sync-khadinakbar-jobsdb-jobs-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/khadinakbar~jobsdb-jobs-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-khadinakbar-jobsdb-jobs-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "keywords"
                ],
                "properties": {
                    "keywords": {
                        "title": "Job search keywords",
                        "type": "string",
                        "description": "Use this when you need a public JobsDB keyword search, for example 'senior data engineer'. Enter ordinary job-search text up to 120 characters. The default is 'software engineer'. This is not a JobsDB URL or applicant name.",
                        "default": "software engineer"
                    },
                    "country": {
                        "title": "JobsDB country",
                        "enum": [
                            "HK",
                            "TH"
                        ],
                        "type": "string",
                        "description": "Use this when choosing the public JobsDB market to search. Select HK for Hong Kong or TH for Thailand, for example 'HK'. The default is HK. This is not a city or an all-country mode.",
                        "default": "HK"
                    },
                    "location": {
                        "title": "Location filter",
                        "type": "string",
                        "description": "Use this when narrowing a JobsDB search to a city or region, for example 'Central' or 'Bangkok'. Leave it empty to search the selected country. The default is empty. This is not a country code; choose country separately.",
                        "default": ""
                    },
                    "postedWithinDays": {
                        "title": "Posted within",
                        "enum": [
                            "any",
                            "1",
                            "3",
                            "7",
                            "14",
                            "30"
                        ],
                        "type": "string",
                        "description": "Use this when you need recent JobsDB listings. Select a number of days such as '7', or 'any' to retain every listing returned by the target. The default is 7 days. Listings without an exposed timestamp are retained because the actor cannot truthfully infer their age.",
                        "default": "7"
                    },
                    "sortBy": {
                        "title": "Sort preference",
                        "enum": [
                            "date",
                            "relevance"
                        ],
                        "type": "string",
                        "description": "Use this when choosing JobsDB's public keyword order. Select 'date' for newest available listings or 'relevance' for the target's keyword ordering. The default is date. This is a search preference, not a guarantee that the target exposes all ranking signals.",
                        "default": "date"
                    },
                    "maxResults": {
                        "title": "Maximum job records",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Use this when capping returned records and Pay per event charges. Enter an integer from 1 to 500, for example 50. The default is 20 and the maximum event charge is displayed at run start. This is not a page count and cannot return over 500 rows.",
                        "default": 20
                    },
                    "includeJobDetails": {
                        "title": "Include job details",
                        "type": "boolean",
                        "description": "Use this when you want the actor to visit each selected public job page for a fuller description. Set true for richer records or false for faster search-result records. The default is true. This does not bypass a login wall or retrieve applicant information.",
                        "default": true
                    },
                    "startUrls": {
                        "title": "Public JobsDB search URLs",
                        "type": "array",
                        "description": "Use this when you need to scrape one or more known public JobsDB pages instead of generating a keyword search. Each entry must be an hk.jobsdb.com or th.jobsdb.com URL, for example 'https://hk.jobsdb.com/software-engineer-jobs'. Leave empty to use keywords, country, and location. This is not for job-board URLs from other sites.",
                        "items": {
                            "type": "object",
                            "properties": {
                                "url": {
                                    "title": "JobsDB URL",
                                    "type": "string",
                                    "description": "Public JobsDB search or vacancy URL on an allowed Hong Kong or Thailand host."
                                }
                            },
                            "required": [
                                "url"
                            ]
                        },
                        "default": []
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
