# LinkedIn Jobs Scraper — pay only for unique, fresh jobs (`slim81/linkedin-jobs-scraper`) Actor

Scrapes LinkedIn job postings from public guest endpoints. Deduplicates on stable job IDs across pages and queries, enforces freshness against verified posted-at timestamps, and bills only for the unique jobs delivered.

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

## Pricing

$0.75 / 1,000 unique job delivereds

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 — pay only for unique, fresh jobs

Scrapes LinkedIn job postings from **public guest endpoints** — no login, no
cookies, no personal data — and bills you **only for unique jobs**. Raw
LinkedIn search results repeat heavily across pages and overlapping queries
(we measure ~1.8–2.2× duplicate inflation on real runs). This actor
deduplicates on LinkedIn's stable job ID before anything is delivered or
charged, so the duplicates cost you nothing.

Every run ends with a **receipt** (`RUN_SUMMARY`) that shows exactly what
happened: rows seen, duplicates suppressed, stale rows dropped, unique jobs
delivered, and the count actually charged — numbers you can audit against
your dataset, not vibes.

### Why this actor

- **Unique-only billing.** Dedupe by stable `jobId` across all pages and all
  your queries in a run. Delivered == charged, structurally: pushing and
  charging are the same code path.
- **Verified freshness.** Every job carries a real machine timestamp
  (`postedAt`) read from LinkedIn's own markup — not a parsed "2 weeks ago"
  guess. Ask for `postedWithin: "week"` and stale rows are dropped and
  counted, never billed.
- **Honest failure semantics.** A blocked or empty run says so, loudly. If
  your `maxTotalChargeUsd` budget runs out, the run stops immediately with a
  `budget_exhausted` receipt — it never silently keeps scraping. Even a
  crash persists a partial receipt of what was delivered and charged.
- **No account risk, no PII.** Guest surface only: job postings, never
  recruiter or applicant data, no login of any kind.

### Input

```jsonc
{
  "keywords":        ["software engineer", "data engineer"],  // 1..N phrases
  "locations":       ["United States", "New York"],           // 1..N locations
  "postedWithin":    "week",          // "any" | "24h" | "week" | "month"
  "jobType":         ["fulltime", "contract"],  // optional; also parttime,
                                                //   temporary, internship, volunteer
  "experienceLevel": ["entry", "associate"],    // optional; also internship,
                                                //   mid-senior, director, executive
  "easyApply":       false,           // optional: only Easy Apply postings
  "maxUniqueJobs":   500,             // hard cap = your billing ceiling
  "strictMatch":     false,           // opt-in: drop titles not matching keywords
  "fetchJobDetails": true,            // per-job enrichment (default true)
  "proxy":           { "useApifyProxy": true }
}
````

`jobType`, `experienceLevel`, and `easyApply` are optional filters applied by
**LinkedIn's own search** — leave them out for unfiltered results. When
`fetchJobDetails` is on, each is corroborated by the matching detail field
(`employmentType`, `seniority`, `easyApply`), but unlike freshness they are
not independently enforced by the actor.

Tip: LinkedIn caps any single query at ~1,000 results. To scale, split into
several keyword × location queries — the deduper neutralizes their overlap,
so you never pay twice for the same job.

### Output

One dataset row per unique job:

```jsonc
{
  "jobId": "3959471234",
  "title": "Senior Software Engineer",
  "company": "Acme Corp",
  "location": "New York, NY",
  "url": "https://www.linkedin.com/jobs/view/3959471234",
  "postedAt": "2026-07-21",            // verified machine timestamp
  "postedAtText": "2 days ago",        // LinkedIn's own label, for transparency
  "isNew": false,
  "employmentType": "Full-time",       // detail fields null when
  "seniority": "Mid-Senior level",     //   fetchJobDetails=false or fetch failed
  "easyApply": true,
  "applicants": 47,
  "salaryRaw": "$120,000.00/yr - $150,000.00/yr",
  "salaryMin": 120000,                 // parsed when an annual USD range is shown
  "salaryMax": 150000,
  "workTypeDerived": null,             // "remote"|"hybrid"|"onsite" ONLY on a
                                       //   high-confidence signal, else null
  "matchedQuery": { "keywords": "software engineer", "location": "New York" },
  "detailFetched": true,
  "scrapedAt": "2026-07-23T13:02:19Z"
}
```

### The receipt (`RUN_SUMMARY`)

Stored in the run's key-value store and printed at the end of the log:
per-query pages fetched, rows seen and stop reason; unique jobs emitted;
**charged count**; duplicates suppressed (with the measured inflation
factor); stale and strict-match drops; detail-fetch failures; proxy tier.
If the numbers ever look off, this is where you check them.

### Honest limitations

- LinkedIn's guest surface does not expose work type (remote/hybrid/onsite).
  `workTypeDerived` is a best-effort derivation from explicit title/location
  signals like "(Remote)" — when signals conflict or are ambiguous it stays
  `null` rather than guessing.
- Salary appears on only a minority of postings; `salaryMin/Max` parse
  annual USD ranges. Hourly and non-USD ranges ship raw in `salaryRaw`.
- Dedupe is per-run in this version (cross-run dedupe is planned).
- A failed detail fetch never loses the job: the row ships with
  `detailFetched: false` and null detail fields.

### Pricing

Pay-per-event: you are charged per **unique job delivered** — duplicates,
stale rows, and filtered rows are free. Set `maxUniqueJobs` (and optionally
Apify's `maxTotalChargeUsd`) to cap spend; the run stops the moment either
limit is reached.

***

#### Development

```
npm install
npm test        # node --test; fixture-pinned, no network
```

`src/` — parser, dedupe, freshness, strict-match, salary, worktype, query
planner, run-summary, fetch layer, pipeline, error ledger, thin actor shell.
`.actor/` — Apify packaging. `test/` — 209 unit + mocked-integration tests
pinned to live-captured fixtures.

# Actor input Schema

## `keywords` (type: `array`):

One or more search phrases (e.g. "software engineer", "data analyst"). Every keyword is combined with every location into its own search; overlapping results are deduplicated automatically and never double-billed.

## `locations` (type: `array`):

One or more locations as you would type them into LinkedIn's location box (e.g. "United States", "London"). Adding locations is also how to get past LinkedIn's ~1,000-result ceiling per search — splits overlap safely because results are deduplicated.

## `postedWithin` (type: `string`):

Freshness window. Enforced against each job's verified posted-at timestamp, not just LinkedIn's filter — jobs outside the window are dropped, reported in the run summary, and never billed.

## `jobType` (type: `array`):

Only search for these employment types. Applied by LinkedIn's own search filter — corroborated by each job's employment type field when "Fetch job details" is on, but not independently guaranteed. Leave empty for all job types.

## `experienceLevel` (type: `array`):

Only search for these experience levels. Applied by LinkedIn's own search filter — approximately corroborated by each job's seniority field when "Fetch job details" is on, but not independently guaranteed. Leave empty for all levels.

## `easyApply` (type: `boolean`):

Only search for jobs with LinkedIn Easy Apply. Applied by LinkedIn's own search filter — corroborated by each job's verified easyApply field when "Fetch job details" is on, but not independently guaranteed.

## `maxUniqueJobs` (type: `integer`):

Stop after this many unique jobs. This is also your billing ceiling: you are charged per unique job delivered, never more than this number.

## `strictMatch` (type: `boolean`):

Only keep jobs whose title actually matches your keywords. Dropped rows are counted in the run summary and are not billed. Off by default — LinkedIn's own relevance is used as-is.

## `fetchJobDetails` (type: `boolean`):

Fetch each unique job's detail page to add employment type, seniority, verified Easy Apply flag, applicant count, and salary when present. Included in the per-job price. If a detail fetch fails, the job still ships with search-level fields and detailFetched: false.

## `proxy` (type: `object`):

Proxy settings. Apify datacenter proxies (the default) are verified to work well; residential is available as a fallback if your runs get rate-limited.

## Actor input object example

```json
{
  "keywords": [
    "software engineer"
  ],
  "locations": [
    "United States"
  ],
  "postedWithin": "any",
  "easyApply": false,
  "maxUniqueJobs": 50,
  "strictMatch": false,
  "fetchJobDetails": true,
  "proxy": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

One row per unique, deduplicated job posting — the billed output. Fields: jobId, title, company, location, url, verified postedAt, salary, workTypeDerived, easyApply, applicants and more.

## `runReceipt` (type: `string`):

Billing and freshness receipt: rows seen, duplicates suppressed, charged count, stale drops, per-query stop reasons.

# 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"
    ],
    "locations": [
        "United States"
    ],
    "maxUniqueJobs": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("slim81/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 '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "keywords": ["software engineer"],
    "locations": ["United States"],
    "maxUniqueJobs": 50,
}

# Run the Actor and wait for it to finish
run = client.actor("slim81/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 '{
  "keywords": [
    "software engineer"
  ],
  "locations": [
    "United States"
  ],
  "maxUniqueJobs": 50
}' |
apify call slim81/linkedin-jobs-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "LinkedIn Jobs Scraper — pay only for unique, fresh jobs",
        "description": "Scrapes LinkedIn job postings from public guest endpoints. Deduplicates on stable job IDs across pages and queries, enforces freshness against verified posted-at timestamps, and bills only for the unique jobs delivered.",
        "version": "0.1",
        "x-build-id": "rCsncPlaNnhRVnOFL"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/slim81~linkedin-jobs-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-slim81-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/slim81~linkedin-jobs-scraper/runs": {
            "post": {
                "operationId": "runs-sync-slim81-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/slim81~linkedin-jobs-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-slim81-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": [
                    "keywords",
                    "locations",
                    "maxUniqueJobs"
                ],
                "properties": {
                    "keywords": {
                        "title": "Search keywords",
                        "minItems": 1,
                        "type": "array",
                        "description": "One or more search phrases (e.g. \"software engineer\", \"data analyst\"). Every keyword is combined with every location into its own search; overlapping results are deduplicated automatically and never double-billed.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "locations": {
                        "title": "Locations",
                        "minItems": 1,
                        "type": "array",
                        "description": "One or more locations as you would type them into LinkedIn's location box (e.g. \"United States\", \"London\"). Adding locations is also how to get past LinkedIn's ~1,000-result ceiling per search — splits overlap safely because results are deduplicated.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "postedWithin": {
                        "title": "Posted within",
                        "enum": [
                            "any",
                            "24h",
                            "week",
                            "month"
                        ],
                        "type": "string",
                        "description": "Freshness window. Enforced against each job's verified posted-at timestamp, not just LinkedIn's filter — jobs outside the window are dropped, reported in the run summary, and never billed.",
                        "default": "any"
                    },
                    "jobType": {
                        "title": "Job type",
                        "type": "array",
                        "description": "Only search for these employment types. Applied by LinkedIn's own search filter — corroborated by each job's employment type field when \"Fetch job details\" is on, but not independently guaranteed. Leave empty for all job types.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "fulltime",
                                "parttime",
                                "contract",
                                "temporary",
                                "internship",
                                "volunteer"
                            ],
                            "enumTitles": [
                                "Full-time",
                                "Part-time",
                                "Contract",
                                "Temporary",
                                "Internship",
                                "Volunteer"
                            ]
                        }
                    },
                    "experienceLevel": {
                        "title": "Experience level",
                        "type": "array",
                        "description": "Only search for these experience levels. Applied by LinkedIn's own search filter — approximately corroborated by each job's seniority field when \"Fetch job details\" is on, but not independently guaranteed. Leave empty for all levels.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "internship",
                                "entry",
                                "associate",
                                "mid-senior",
                                "director",
                                "executive"
                            ],
                            "enumTitles": [
                                "Internship",
                                "Entry level",
                                "Associate",
                                "Mid-Senior level",
                                "Director",
                                "Executive"
                            ]
                        }
                    },
                    "easyApply": {
                        "title": "Easy Apply only",
                        "type": "boolean",
                        "description": "Only search for jobs with LinkedIn Easy Apply. Applied by LinkedIn's own search filter — corroborated by each job's verified easyApply field when \"Fetch job details\" is on, but not independently guaranteed.",
                        "default": false
                    },
                    "maxUniqueJobs": {
                        "title": "Max unique jobs",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Stop after this many unique jobs. This is also your billing ceiling: you are charged per unique job delivered, never more than this number.",
                        "default": 500
                    },
                    "strictMatch": {
                        "title": "Strict keyword match",
                        "type": "boolean",
                        "description": "Only keep jobs whose title actually matches your keywords. Dropped rows are counted in the run summary and are not billed. Off by default — LinkedIn's own relevance is used as-is.",
                        "default": false
                    },
                    "fetchJobDetails": {
                        "title": "Fetch job details",
                        "type": "boolean",
                        "description": "Fetch each unique job's detail page to add employment type, seniority, verified Easy Apply flag, applicant count, and salary when present. Included in the per-job price. If a detail fetch fails, the job still ships with search-level fields and detailFetched: false.",
                        "default": true
                    },
                    "proxy": {
                        "title": "Proxy",
                        "type": "object",
                        "description": "Proxy settings. Apify datacenter proxies (the default) are verified to work well; residential is available as a fallback if your runs get rate-limited.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```