# LinkedIn Jobs Scraper (Pay-Per-Event) (`prodiger/linkedin-jobs-scraper`) Actor
Scrape LinkedIn job listings via the public guest API — no login or cookies. Filter by keyword, location, job type, experience level, workplace type and date posted. Returns title, company, salary, full description, seniority, employment type and applicant count. HTTP-only drop-in.
- **URL**: https://apify.com/prodiger/linkedin-jobs-scraper.md
- **Developed by:** [Arnas](https://apify.com/prodiger) (community)
- **Categories:** Jobs
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet
## Pricing
Pay per event
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 web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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
**LinkedIn Jobs Scraper** extracts job posting data from [LinkedIn](https://www.linkedin.com/jobs) using its **public guest API** — no login, cookies, or account required. Search by keyword and location, filter by job type, experience level, workplace type and date posted, and get structured job data: title, company, location, salary, full description, seniority level, employment type, applicant count and more. It's HTTP-only (no headless browser), so it's fast and lightweight, and it runs on the Apify platform with API access, scheduling, integrations, proxy rotation and monitoring built in.
This actor is a **pay-per-event drop-in** for `automation-lab/linkedin-jobs-scraper`: the same input fields and output field names, at the **same pricing** ($0.005 / run start + $0.58 / 1,000 jobs) — no monthly fee. What you gain over the reference: run-level deduplication, batch query × location, a machine-readable `postedDate`, migration-safe resumable state, and an optional custom map function.
### What does LinkedIn Jobs Scraper do?
It calls LinkedIn's logged-out ("guest") jobs endpoints — the same data anyone sees browsing LinkedIn jobs without signing in — paginates the search results, and (optionally) fetches each job's detail page for the full description, salary, seniority, employment type, job function, industries and applicant count. Results are written to a structured dataset you can export as JSON, CSV, or Excel, or pull via the Apify API.
### Why use LinkedIn Jobs Scraper?
- **No login or cookies** — uses LinkedIn's public guest endpoints, so there's no session to break.
- **Full job detail extraction** — salary, description (HTML + plain text), seniority, job function, industries and applicant count.
- **Hiring-intent lead generation** — find companies actively hiring for a role, then prioritize outreach.
- **Recruiting & salary intelligence** — monitor competitor hiring and benchmark compensation from live pay-transparency data.
- **Job-market research** — analyze demand, remote-vs-onsite mix, and job-description language at scale.
- **Fast and lightweight** — pure HTTP + cheerio parsing, low memory, no browser overhead.
- **Flexible filters** — keyword, location, job type, experience level, workplace type, date posted and sort order.
### How to use LinkedIn Jobs Scraper
1. Enter a **Search query** (e.g. `software engineer`, `data analyst`, `marketing manager`).
2. Enter a **Location** (e.g. `New York`, `London`, `United States`) or leave it empty to search worldwide.
3. Optionally filter by **job type**, **experience level**, **workplace type** or **date posted**, and choose a **sort order**.
4. Set **Max jobs** (up to 1,000 per search).
5. Leave **Scrape full job details** on for descriptions and salary, or turn it off for faster listing-only runs.
6. Click **Start** and download your results as JSON, CSV, or Excel — or access them via the Apify API.
### Input
Configure the run from the **Input** tab or via the API. The input matches `automation-lab/linkedin-jobs-scraper` field-for-field.
| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `searchQuery` | string | **required** | Job title, keyword, or company name |
| `location` | string | `""` | City, state, country, or `Remote`; empty = worldwide |
| `maxJobs` | integer | `50` | Max jobs to scrape per search (up to 1,000) |
| `jobType` | string | `all` | `F`=Full-time, `P`=Part-time, `C`=Contract, `T`=Temporary, `I`=Internship |
| `experienceLevel` | string | `all` | `1`=Internship, `2`=Entry, `3`=Associate, `4`=Mid-Senior, `5`=Director, `6`=Executive |
| `workplaceType` | string | `all` | `1`=On-site, `2`=Remote, `3`=Hybrid |
| `datePosted` | string | `all` | `r86400`=Past 24h, `r604800`=Past week, `r2592000`=Past month |
| `sortBy` | string | `R` | `R`=Most relevant, `DD`=Most recent |
| `scrapeJobDetails` | boolean | `true` | Fetch full details (description, salary, criteria, applicants) |
| `maxRequestRetries` | integer | `3` | Retry budget per request; each retry rotates the proxy IP |
| `proxyConfiguration` | object | Apify Proxy (datacenter) | Proxy settings |
#### Input example
```json
{
"searchQuery": "software engineer",
"location": "United States",
"maxJobs": 50,
"jobType": "F",
"workplaceType": "2",
"scrapeJobDetails": true
}
````
> Tip: when calling the actor via the Apify API you can also pass `searchQuery` and `location` as **lists** of strings — every query is searched in every location in one run.
### Output
Each job is one dataset row. You can download the dataset in various formats such as JSON, HTML, CSV, or Excel.
```json
{
"id": "4442187240",
"title": "Data Analyst 2",
"url": "https://www.linkedin.com/jobs/view/data-analyst-2-at-new-york-state-department-of-health-4442187240",
"companyName": "New York State Department of Health",
"companyLinkedinUrl": "https://www.linkedin.com/company/nysdoh",
"companyLogo": "https://media.licdn.com/dms/image/v2/.../nysdoh_logo",
"location": "Albany, NY",
"postedAt": "1 week ago",
"postedDate": "2026-07-17",
"salary": "$86,681.00/yr - $109,650.00/yr",
"applicantsCount": 109,
"workplaceType": "Remote",
"descriptionHtml": "Minimum Qualifications ...",
"descriptionText": "Minimum Qualifications ...",
"seniorityLevel": "Not Applicable",
"employmentType": "Full-time",
"jobFunction": "Science, Information Technology, and Engineering",
"industries": "Public Health",
"applyUrl": "https://www.linkedin.com/jobs/view/data-analyst-2-at-new-york-state-department-of-health-4442187240",
"benefits": null,
"searchQuery": "data analyst",
"searchLocation": "New York",
"scrapedAt": "2026-07-27T10:38:17.961Z"
}
```
#### Data fields
| Field | Description |
|-------|-------------|
| `id` | LinkedIn job posting ID |
| `title` | Full position title |
| `url` | Direct LinkedIn job posting link |
| `companyName` | Hiring company |
| `companyLinkedinUrl` | Company's LinkedIn page |
| `companyLogo` | Company logo image URL |
| `location` | Job location (city, state, country) |
| `postedAt` | Relative posted label (e.g. "3 days ago") |
| `postedDate` | Machine-readable posted date (YYYY-MM-DD) |
| `salary` | Salary range when disclosed |
| `applicantsCount` | Number of applicants (integer) |
| `workplaceType` | Remote / On-site / Hybrid (when a workplace filter is set) |
| `descriptionHtml` | Full job description (HTML) |
| `descriptionText` | Full job description (plain text) |
| `seniorityLevel` | Entry, Mid-Senior, Director, etc. |
| `employmentType` | Full-time, Part-time, Contract, etc. |
| `jobFunction` | Engineering, Marketing, Sales, etc. |
| `industries` | Industry sectors |
| `applyUrl` | Application link (the job page) |
| `benefits` | Listed benefits, when present |
| `searchQuery` / `searchLocation` | The query and location this row came from |
| `scrapedAt` | ISO timestamp of extraction |
Fields that a listing doesn't disclose (salary, benefits) are returned as `null`.
### How much does it cost to scrape LinkedIn jobs?
This actor uses **pay-per-event** pricing:
| Event | Price | Description |
|-------|-------|-------------|
| Run started | $0.005 | One-time charge when the scraper starts |
| Job scraped | $0.58 / 1,000 | Per job written to the dataset (deduplicated by job ID) |
Scraping **1,000 jobs costs about $0.585** ($0.005 start + $0.58 for listings). Higher Apify subscription tiers get a lower per-job rate automatically. Apify's free plan includes monthly platform credits, so you can scrape thousands of jobs per month for free. A job is billed only **after** it is successfully written, so failed fetches never cost you.
### Tips for best results
- Use **specific keywords** — `react developer` beats `developer` for relevance.
- Combine filters (**job type + experience level + workplace type**) to narrow results.
- Set `scrapeJobDetails: false` for faster runs when the listing summary (title, company, location) is enough.
- Sort by **`DD` (Most recent)** to catch the freshest postings first.
- LinkedIn caps a query at **~1,000 results** — use more specific queries or split by location to go deeper.
- If you see frequent rate limits on very large runs, switch `proxyConfiguration` to **RESIDENTIAL** groups.
### FAQ and support
**Does it require a LinkedIn account?** No. It uses LinkedIn's public guest API, which needs no login, cookies, or tokens.
**What's the maximum number of results?** LinkedIn's guest API caps search results at ~1,000 per query. For more, run multiple searches with different keyword/location/filter combinations.
**Why are some fields null?** Not every listing discloses salary, workplace type, or benefits. When an employer omits them, the field is `null`.
**Is it legal to scrape LinkedIn?** This actor is provided for educational and research purposes and accesses only publicly available, logged-out data. You are responsible for ensuring your use complies with LinkedIn's Terms of Service and applicable laws. Use scraped data responsibly.
**Known limitations:** LinkedIn occasionally rotates its HTML structure — if extraction breaks, please open an issue on the **Issues** tab. The guest API does not expose company-detail pages (employee count, revenue) or a guest-usable external apply URL, so `applyUrl` points to the LinkedIn job page.
Found a bug or need a custom variant? Open an issue on the **Issues** tab.
# Actor input Schema
## `searchQuery` (type: `string`):
Job title, keyword, or company name to search for, e.g. `software engineer`, `data analyst`, `marketing manager`.
## `location` (type: `string`):
City, state, country, or `Remote`, e.g. `United States`, `New York`, `London`. Leave empty to search worldwide.
## `maxJobs` (type: `integer`):
Maximum number of job listings to scrape for the search. LinkedIn's guest API caps a query at ~1,000 results.
## `jobType` (type: `string`):
Filter by employment type.
## `experienceLevel` (type: `string`):
Filter by seniority.
## `workplaceType` (type: `string`):
Filter by work arrangement.
## `datePosted` (type: `string`):
Only return jobs posted within this window.
## `sortBy` (type: `string`):
Result ordering. `Most relevant` is LinkedIn's default; `Most recent` surfaces the freshest postings first.
## `scrapeJobDetails` (type: `boolean`):
Fetch each job's detail page for the full description, salary, seniority level, employment type, job function, industries and applicant count. Turn off for faster runs when the listing summary (title, company, location) is enough.
## `maxRequestRetries` (type: `integer`):
Retry budget per request for rate limits and transient errors. Each retry rotates to a fresh proxy IP.
## `customMapFunction` (type: `string`):
Optional JavaScript function body that transforms each job before it is pushed to the dataset. Receives the item as argument `item` and must return the modified item. Errors are logged and the unmodified item is emitted. Example: `return { id: item.id, role: item.title, company: item.companyName };`
## `proxyConfiguration` (type: `object`):
Apify Proxy configuration. Default: Apify Proxy with AUTO rotation (datacenter), which works for LinkedIn's guest API. Switch to RESIDENTIAL groups if you see frequent rate limits on large runs.
## Actor input object example
```json
{
"searchQuery": "software engineer",
"location": "United States",
"maxJobs": 50,
"jobType": "all",
"experienceLevel": "all",
"workplaceType": "all",
"datePosted": "all",
"sortBy": "R",
"scrapeJobDetails": true,
"maxRequestRetries": 3,
"proxyConfiguration": {
"useApifyProxy": true
}
}
```
# Actor output Schema
## `dataset` (type: `string`):
Scraped LinkedIn job listings — one row per job.
# 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 '' with your token
const client = new ApifyClient({
token: '',
});
// Prepare Actor input
const input = {
"searchQuery": "software engineer",
"location": "United States",
"proxyConfiguration": {
"useApifyProxy": true
}
};
// Run the Actor and wait for it to finish
const run = await client.actor("prodiger/linkedin-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 '' with your token.
client = ApifyClient("")
# Prepare the Actor input
run_input = {
"searchQuery": "software engineer",
"location": "United States",
"proxyConfiguration": { "useApifyProxy": True },
}
# Run the Actor and wait for it to finish
run = client.actor("prodiger/linkedin-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 '{
"searchQuery": "software engineer",
"location": "United States",
"proxyConfiguration": {
"useApifyProxy": true
}
}' |
apify call prodiger/linkedin-jobs-scraper --silent --output-dataset
```
## MCP server setup
```json
{
"mcpServers": {
"apify": {
"command": "npx",
"args": [
"mcp-remote",
"https://mcp.apify.com/?tools=prodiger/linkedin-jobs-scraper",
"--header",
"Authorization: Bearer "
]
}
}
}
```
## OpenAPI specification
```json
{
"openapi": "3.0.1",
"info": {
"title": "LinkedIn Jobs Scraper (Pay-Per-Event)",
"description": "Scrape LinkedIn job listings via the public guest API — no login or cookies. Filter by keyword, location, job type, experience level, workplace type and date posted. Returns title, company, salary, full description, seniority, employment type and applicant count. HTTP-only drop-in.",
"version": "0.1",
"x-build-id": "JSkIN13um6UYnudJb"
},
"servers": [
{
"url": "https://api.apify.com/v2"
}
],
"paths": {
"/acts/prodiger~linkedin-jobs-scraper/run-sync-get-dataset-items": {
"post": {
"operationId": "run-sync-get-dataset-items-prodiger-linkedin-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/prodiger~linkedin-jobs-scraper/runs": {
"post": {
"operationId": "runs-sync-prodiger-linkedin-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/prodiger~linkedin-jobs-scraper/run-sync": {
"post": {
"operationId": "run-sync-prodiger-linkedin-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": [
"searchQuery"
],
"properties": {
"searchQuery": {
"title": "Search query",
"type": "string",
"description": "Job title, keyword, or company name to search for, e.g. `software engineer`, `data analyst`, `marketing manager`."
},
"location": {
"title": "Location",
"type": "string",
"description": "City, state, country, or `Remote`, e.g. `United States`, `New York`, `London`. Leave empty to search worldwide."
},
"maxJobs": {
"title": "Max jobs",
"minimum": 1,
"maximum": 1000,
"type": "integer",
"description": "Maximum number of job listings to scrape for the search. LinkedIn's guest API caps a query at ~1,000 results.",
"default": 50
},
"jobType": {
"title": "Job type",
"enum": [
"all",
"F",
"P",
"C",
"T",
"I"
],
"type": "string",
"description": "Filter by employment type.",
"default": "all"
},
"experienceLevel": {
"title": "Experience level",
"enum": [
"all",
"1",
"2",
"3",
"4",
"5",
"6"
],
"type": "string",
"description": "Filter by seniority.",
"default": "all"
},
"workplaceType": {
"title": "Workplace type",
"enum": [
"all",
"1",
"2",
"3"
],
"type": "string",
"description": "Filter by work arrangement.",
"default": "all"
},
"datePosted": {
"title": "Date posted",
"enum": [
"all",
"r86400",
"r604800",
"r2592000"
],
"type": "string",
"description": "Only return jobs posted within this window.",
"default": "all"
},
"sortBy": {
"title": "Sort by",
"enum": [
"R",
"DD"
],
"type": "string",
"description": "Result ordering. `Most relevant` is LinkedIn's default; `Most recent` surfaces the freshest postings first.",
"default": "R"
},
"scrapeJobDetails": {
"title": "Scrape full job details",
"type": "boolean",
"description": "Fetch each job's detail page for the full description, salary, seniority level, employment type, job function, industries and applicant count. Turn off for faster runs when the listing summary (title, company, location) is enough.",
"default": true
},
"maxRequestRetries": {
"title": "Max request retries",
"minimum": 1,
"maximum": 10,
"type": "integer",
"description": "Retry budget per request for rate limits and transient errors. Each retry rotates to a fresh proxy IP.",
"default": 3
},
"customMapFunction": {
"title": "Custom map function",
"type": "string",
"description": "Optional JavaScript function body that transforms each job before it is pushed to the dataset. Receives the item as argument `item` and must return the modified item. Errors are logged and the unmodified item is emitted. Example: `return { id: item.id, role: item.title, company: item.companyName };`"
},
"proxyConfiguration": {
"title": "Proxy configuration",
"type": "object",
"description": "Apify Proxy configuration. Default: Apify Proxy with AUTO rotation (datacenter), which works for LinkedIn's guest API. Switch to RESIDENTIAL groups if you see frequent rate limits on large runs.",
"default": {
"useApifyProxy": true
}
}
}
},
"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
}
}
}
}
}
}
}
}
}
}
```