# Liepin China Scraper: White-Collar Jobs (`getascraper/liepin-scraper`) Actor

Scrape China's premier white-collar job platform on Liepin.com (猎聘). Extract vacancy titles, structured monthly salaries with bonus months, candidate requirements, and company profiles directly to Excel or JSON. Only $1.99 per 1,000 results.

- **URL**: https://apify.com/getascraper/liepin-scraper.md
- **Developed by:** [GetAScraper](https://apify.com/getascraper) (community)
- **Categories:** Jobs, Lead generation, E-commerce
- **Stats:** 3 total users, 1 monthly users, 83.3% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.99 / 1,000 jobs

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

## Liepin China Jobs Scraper: White-Collar Recruitment Data

**Get live white-collar Chinese job listings (including structured monthly salaries, bonus months, experience, and company profiles) ready for your spreadsheet in under 60 seconds.** Get vacancy titles, standardized CNY salary metrics, prefecture locations, candidate degree requirements, and company types for any keyword across China.

---

### What can you do with it?

*   **I am an international recruitment consultant** sourcing bilingual tech talent, executives, and white-collar job openings across China (such as Beijing, Shanghai, and Shenzhen) to backfill our headhunting pipelines.
*   **I am a compensation and labor market researcher** tracking monthly base salaries and annual bonus month structures (e.g., `15k-20k·13薪`) in major Chinese city tiers to compile competitive compensation reports.
*   **I am a B2B lead generator** extracting hiring companies, corporate registration types, and headcount sizes to build targeted sales prospecting databases.

---

### How to use it

#### Store Quick Start
1. Create a free Apify account.
2. Open the **Liepin China Jobs Scraper** in the Apify Store.
3. Select your target city (e.g. Beijing, Shanghai, Shenzhen) or "Featured"Snapshots.
4. Enter an optional keyword (e.g. `python`, `产品经理`, `AI`).
5. Click **Start** and download the dataset as JSON, CSV, or Excel.

#### API Quick Start
For developers, you can trigger a run programmatically with a single request:

```bash
curl --request POST \
  --url "https://api.apify.com/v2/acts/getascraper~liepin-scraper/runs?token=YOUR_API_TOKEN" \
  --header 'Content-Type: application/json' \
  --data '{
    "keyword": "python",
    "city": "020",
    "maxItems": 100
  }'
````

***

### Input

| Field | Type | Default | Description |
| :--- | :--- | :--- | :--- |
| `scrapeMode` | `string` | `home` | Choose how to discover jobs: `home` grabs today's featured jobs (fastest), `search` filters by keyword. |
| `keyword` | `string` | `python` | Search keyword (e.g., `AI`, `产品经理`, `Golang`). Ignored when `scrapeMode` is `home`. |
| `city` | `string` | `010` | Filter by city codes (Beijing `010`, Shanghai `020`, Guangzhou `030`, Shenzhen `040`). |
| `pagesPerQuery` | `integer` | `3` | How many search result pages to walk through (up to 40 jobs per page). |
| `includeJobDetail` | `boolean` | `true` | Visit each job's detailed page to extract the full job description. |
| `outputFormat` | `string` | `flat` | `flat` returns one row per job. `normalized` splits jobs and companies into separate tables. |
| `maxItems` | `integer` | `50` | Maximum number of job records to extract. |
| `proxyConfiguration` | `object` | `{"useApifyProxy": true}` | Premium rotating residential proxies are recommended for sustained search runs. |

***

### Output

Each row represents a single job listing from Liepin.

```json
{
  "sku": "1983197685",
  "productId": "1983197685",
  "url": "https://www.liepin.com/job/1983197685.shtml",
  "title": "艺术总监",
  "companyName": "上海博盟文化发展有限公司",
  "salaryRawText": "15-18k·13薪",
  "minSalaryMonthlyCny": 15000,
  "maxSalaryMonthlyCny": 18000,
  "bonusMonths": 13,
  "annualEstimateCny": 214500,
  "salaryDisclosed": true,
  "currency": "CNY",
  "degreeRequired": "Bachelor's",
  "companyType": "Private Enterprise",
  "experienceRequired": "3-5 Years",
  "city": "上海",
  "province": "上海",
  "region": "上海",
  "address": "上海-航华",
  "scrapedAt": "2026-06-10T13:00:00.000Z"
}
```

#### Field Reference

| Field | Type | Description |
| :--- | :--- | :--- |
| `sku` | `string` | Unique identifier of the job vacancy. |
| `url` | `string` | Direct public job detail link. |
| `title` | `string` | Job title. |
| `minSalaryMonthlyCny` | `number` | Standardized minimum monthly salary in Yuan (CNY). |
| `maxSalaryMonthlyCny` | `number` | Standardized maximum monthly salary in Yuan (CNY). |
| `bonusMonths` | `number` | Number of salary payment months per year (e.g., `13薪` = 13). |
| `annualEstimateCny` | `number` | Computed estimated annual salary in Yuan (CNY). |
| `degreeRequired` | `string` | Standardized degree requirements (Bachelor's, Master's, PhD, Any Degree). |
| `companyType` | `string` | Standardized company type (Private Enterprise, State-Owned, Foreign-Owned). |
| `experienceRequired` | `string` | Standardized required experience band (1-3 Years, 3-5 Years, etc.). |

***

### Pricing & Cost

Pricing is pay-per-result and is billed per row successfully saved to your dataset. Empty runs cost absolutely nothing.

- **Rate:** **$1.99 per 1,000 results** ($0.00199 per result).
- **100 listings** typically cost **$0.20**.
- **1,000 listings** cost exactly **$1.99**.
- **10,000 listings** cost exactly **$19.90**.
- No fixed monthly subscriptions or hidden maintenance fees.

***

### Tips & Best Practices

- **Predictable URL Extraction.** Liepin job detail URLs always follow a strict, predictable format `https://www.liepin.com/job/1{jobid}.shtml` derived from listing cards. The Actor extracts and queues details seamlessly with zero DOM fragility.
- **Bilingual Translations Natively.** The Actor automatically translates and maps complex Chinese recruitment specifications (degrees like `本科` or `硕士`, company types like `民营` or `上市公司`) into standardized B2B English fields.
- **Disable detail fetches for fast sweeps.** Turn off the `includeJobDetail` parameter to skip detailed pages, cutting execution speed by 10x and saving proxy bandwidth.

***

### FAQ

##### Does it get blocked by Liepin?

No. The scraper natively supports premium, rotating Residential Proxies with Singapore (SG), Hong Kong (HK), or Japan (JP) country codes. This ensures ideal peering with Chinese networks and completely avoids geoblocking firewalls.

##### Does it extract private candidate or recruiter contact details?

No. To protect user privacy and avoid verification blocks, the scraper does not extract private recruiters, personal contact details, or candidate accounts. It strictly extracts public vacancies, salaries, degree requirements, and corporate profiles.

##### How fresh is the data?

Extremely fresh. The scraper executes live HTTP requests on every query, retrieving the absolute latest vacancies posted on Liepin in real-time.

##### Are all categories supported?

Yes. The scraper supports all major white-collar and professional occupations including IT, Web Engineers, Consulting, Sales, Marketing, and Project Management.

***

### Target SEO Keywords

- Liepin API
- scrape Liepin
- China white-collar jobs data
- Beijing executive recruiter scraper
- Chinese recruitment API

***

### Disclaimers & Support

- **Disclaimer:** This Actor retrieves publicly available job postings on Liepin. Make sure your usage complies with Liepin's terms of service and applicable laws.
- **Support:** Open an issue from the Actor page in the Apify Console for bug reports or feature requests.

# Actor input Schema

## `scrapeMode` (type: `string`):

Pick the simplest mode that fits your use case. 'home' grabs today's featured jobs (fastest). 'search' lets you filter by keyword and city. 'urls' is for pasting direct search links.

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

Free-text keyword (e.g. 'python', 'sales').

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

Only used when scrapeMode is 'urls'. Paste specific Liepin search web links.

## `city` (type: `string`):

Pick the city to focus the search on. 'all' searches nationwide.

## `pagesPerQuery` (type: `integer`):

How many search result pages to walk through. Each page has up to 40 jobs.

## `includeJobDetail` (type: `boolean`):

If true, we visit each job's detail page to extract the full description. Set false for fast list sweeps.

## `outputFormat` (type: `string`):

'flat' = one row per job. 'normalized' = two datasets (jobs + companies) linked by company ID.

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

Cap on records returned.

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

Apify proxy settings. We recommend Residentials with country code SG (Singapore), HK (Hong Kong), or JP (Japan) for excellent peering.

## Actor input object example

```json
{
  "scrapeMode": "home",
  "keyword": "python",
  "startUrls": [],
  "city": "010",
  "pagesPerQuery": 3,
  "includeJobDetail": true,
  "outputFormat": "flat",
  "maxItems": 50,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "SG"
  }
}
```

# Actor output Schema

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

No description

## `companies` (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 = {
    "keyword": "python",
    "startUrls": [],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "SG"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("getascraper/liepin-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 = {
    "keyword": "python",
    "startUrls": [],
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "SG",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("getascraper/liepin-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 '{
  "keyword": "python",
  "startUrls": [],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "SG"
  }
}' |
apify call getascraper/liepin-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Liepin China Scraper: White-Collar Jobs",
        "description": "Scrape China's premier white-collar job platform on Liepin.com (猎聘). Extract vacancy titles, structured monthly salaries with bonus months, candidate requirements, and company profiles directly to Excel or JSON. Only $1.99 per 1,000 results.",
        "version": "1.0",
        "x-build-id": "TBHfmUzn8Jy55A6fe"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/getascraper~liepin-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-getascraper-liepin-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/getascraper~liepin-scraper/runs": {
            "post": {
                "operationId": "runs-sync-getascraper-liepin-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/getascraper~liepin-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-getascraper-liepin-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": [
                    "scrapeMode"
                ],
                "properties": {
                    "scrapeMode": {
                        "title": "How do you want to find jobs?",
                        "enum": [
                            "home",
                            "search",
                            "urls"
                        ],
                        "type": "string",
                        "description": "Pick the simplest mode that fits your use case. 'home' grabs today's featured jobs (fastest). 'search' lets you filter by keyword and city. 'urls' is for pasting direct search links.",
                        "default": "home"
                    },
                    "keyword": {
                        "title": "Search Keyword",
                        "type": "string",
                        "description": "Free-text keyword (e.g. 'python', 'sales').",
                        "default": "python"
                    },
                    "startUrls": {
                        "title": "Direct Start URLs",
                        "type": "array",
                        "description": "Only used when scrapeMode is 'urls'. Paste specific Liepin search web links.",
                        "default": [],
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "city": {
                        "title": "Target City",
                        "enum": [
                            "all",
                            "010",
                            "020",
                            "030",
                            "040",
                            "180",
                            "090",
                            "080",
                            "060",
                            "070",
                            "050",
                            "230",
                            "240",
                            "280"
                        ],
                        "type": "string",
                        "description": "Pick the city to focus the search on. 'all' searches nationwide.",
                        "default": "010"
                    },
                    "pagesPerQuery": {
                        "title": "Pages to Crawl",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "How many search result pages to walk through. Each page has up to 40 jobs.",
                        "default": 3
                    },
                    "includeJobDetail": {
                        "title": "Fetch Full Job Description?",
                        "type": "boolean",
                        "description": "If true, we visit each job's detail page to extract the full description. Set false for fast list sweeps.",
                        "default": true
                    },
                    "outputFormat": {
                        "title": "Output Format",
                        "enum": [
                            "flat",
                            "normalized"
                        ],
                        "type": "string",
                        "description": "'flat' = one row per job. 'normalized' = two datasets (jobs + companies) linked by company ID.",
                        "default": "flat"
                    },
                    "maxItems": {
                        "title": "Max Jobs to Extract",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Cap on records returned.",
                        "default": 50
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Apify proxy settings. We recommend Residentials with country code SG (Singapore), HK (Hong Kong), or JP (Japan) for excellent peering.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ],
                            "apifyProxyCountry": "SG"
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
