# Linkedin Jobs Scraper (`scrapelabsapi/linkedin-jobs-scraper`) Actor

Scrape LinkedIn job listings instantly with this LinkedIn Jobs Scraper 💼 Extract job titles, company names, locations, descriptions, salaries, and post dates with ease 📊 Perfect for recruitment, market research, lead generation, and hiring trend analysis 🔍 Fast and scalable 🚀

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

## Pricing

$19.99/month + usage

To use this Actor, you pay a monthly rental fee to the developer. The rent is subtracted from your prepaid usage every month after the free trial period.You also pay for the Apify platform usage, which gets cheaper the higher Apify subscription plan you have.

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

## 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

## LinkedIn Jobs Scraper

A powerful Apify Actor for scraping LinkedIn job postings with comprehensive data extraction and intelligent proxy management.

### Why Choose Us?

- **Comprehensive Data Extraction**: Captures all job details including salary, benefits, company information, and application URLs
- **Intelligent Proxy Management**: Automatic fallback from no proxy → datacenter → residential with retry logic
- **Bulk Processing**: Supports multiple companies, keywords, and advanced filtering options
- **Robust Error Handling**: Built-in retry mechanisms and graceful error recovery
- **Real-time Logging**: Detailed progress logs to keep you informed throughout the scraping process

### Key Features

- ✅ Scrape jobs by company name, URL, or ID
- ✅ Keyword-based job searches
- ✅ Advanced filtering (location, work type, contract type, experience level)
- ✅ Automatic proxy fallback with detailed logging
- ✅ Pagination support with duplicate detection
- ✅ Comprehensive job data extraction
- ✅ Live data saving to Apify dataset

### Input

#### Example Input JSON

```json
{
  "companyInput": ["Google", "Microsoft"],
  "keywords": "Software Engineer",
  "location": "United States",
  "maxJobs": 200,
  "sortOrder": "date",
  "publishedAt": "r604800",
  "workType": "2",
  "contractType": "F",
  "experienceLevel": "4",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
````

#### Input Fields

- **companyInput** (array): Company names, LinkedIn URLs, or company IDs. Supports bulk input.
  - Examples: `["Google"]`, `["https://www.linkedin.com/company/google/"]`, `["1441"]`
- **keywords** (string): Job title or keywords to search for
- **location** (string): Job location filter (default: "United States")
- **maxJobs** (integer): Maximum number of jobs to scrape (1-10000, default: 200)
- **sortOrder** (string): Sort order - "", "relevance", or "date"
- **maxComments** (integer): Maximum comments (for future use, default: 0)
- **publishedAt** (string): Filter by date - "", "r86400" (24h), "r604800" (week), "r2592000" (month)
- **workType** (string): "1" (on-site), "2" (remote), "3" (hybrid)
- **contractType** (string): "F" (full-time), "P" (part-time), "C" (contract), "T" (temporary), "I" (internship), "V" (volunteer)
- **experienceLevel** (string): "1" (internship), "2" (entry), "3" (associate), "4" (mid-senior), "5" (director)
- **geoId** (string): Geographic ID for specific location filtering
- **proxyConfiguration** (object): Proxy settings. By default, uses no proxy. Falls back to datacenter, then residential with 3 retries if blocked.

### Output

#### Example Output JSON

```json
[
  {
    "id": "4304041530",
    "publishedAt": "2025-09-23",
    "salary": "$141,000.00/yr - $202,000.00/yr",
    "title": "Software Engineer, Full Stack, Google Workspace",
    "jobUrl": "https://www.linkedin.com/jobs/view/software-engineer-full-stack-google-workspace-at-google-4304041530",
    "companyName": "Google",
    "companyUrl": "https://www.linkedin.com/company/google",
    "location": "Seattle, WA",
    "postedTime": "1 day ago",
    "applicationsCount": "68 applicants",
    "description": "Full job description text...",
    "contractType": "Full-time",
    "experienceLevel": "Not Applicable",
    "workType": "Information Technology and Engineering",
    "sector": "Information Services and Technology, Information and Internet",
    "applyUrl": "https://careers.google.com/jobs/results/...",
    "applyType": "EXTERNAL",
    "descriptionHtml": "<div>HTML description...</div>",
    "companyId": "1441",
    "benefits": "health insurance, medical, dental, vision",
    "posterProfileUrl": "",
    "posterFullName": ""
  }
]
```

#### Output Fields

- **id**: LinkedIn job posting ID
- **publishedAt**: Publication date (YYYY-MM-DD format)
- **salary**: Salary range if available
- **title**: Job title
- **jobUrl**: Direct URL to the job posting
- **companyName**: Company name
- **companyUrl**: Company LinkedIn page URL
- **location**: Job location
- **postedTime**: Human-readable posted time (e.g., "1 day ago")
- **applicationsCount**: Number of applicants
- **description**: Full job description (plain text)
- **contractType**: Employment type (Full-time, Part-time, etc.)
- **experienceLevel**: Required experience level
- **workType**: Job function/category
- **sector**: Industry sector
- **applyUrl**: Direct application URL
- **applyType**: "EXTERNAL" or "LINKEDIN"
- **descriptionHtml**: HTML version of description
- **companyId**: LinkedIn company ID
- **benefits**: Extracted benefits information
- **posterProfileUrl**: Job poster's profile URL (if available)
- **posterFullName**: Job poster's full name (if available)

### 🚀 How to Use the Actor (via Apify Console)

1. Log in at https://console.apify.com and go to **Actors**.
2. Find your actor (linkedin-jobs-scraper) and click it.
3. Configure inputs:
   - Enter company names, URLs, or IDs in **companyInput**
   - Set **keywords** for job title searches
   - Configure **location** and other filters
   - Set **maxJobs** to limit results
   - Configure **proxyConfiguration** if needed
4. Click **Start** to run the actor.
5. Monitor logs in real time to see progress.
6. Access results in the **OUTPUT** tab once complete.
7. Export results to JSON or CSV format.

### Best Use Cases

- **Job Market Research**: Analyze job postings across multiple companies
- **Competitive Intelligence**: Track competitor hiring patterns
- **Salary Benchmarking**: Collect salary data for specific roles
- **Talent Acquisition**: Monitor new job postings in your industry
- **Market Analysis**: Study job trends and requirements

### Frequently Asked Questions

**Q: Can I scrape jobs without providing a company?**\
A: Yes! You can use the `keywords` field to search for jobs by title or keywords.

**Q: How does the proxy fallback work?**\
A: The actor starts with no proxy. If LinkedIn blocks the request, it automatically falls back to datacenter proxy, then residential proxy with 3 retries. All proxy events are logged clearly.

**Q: What's the maximum number of jobs I can scrape?**\
A: The `maxJobs` field accepts values from 1 to 10,000. Default is 200.

**Q: Can I filter by multiple criteria?**\
A: Yes! You can combine location, work type, contract type, experience level, and publication date filters.

**Q: How long does scraping take?**\
A: It depends on the number of jobs. The actor processes jobs in batches with delays to avoid rate limiting. Typically, 100 jobs take 5-10 minutes.

### Support and Feedback

For issues, questions, or feedback, please contact support through the Apify platform.

### Cautions

- Data is collected only from **publicly available sources** on LinkedIn.
- No data is taken from private accounts or password-protected content.
- The end user is responsible for ensuring legal compliance (spam laws, privacy, data protection, etc.).
- Respect LinkedIn's Terms of Service and rate limits.

# Actor input Schema

## `companyInput` (type: `array`):

List of company names (e.g., 'Google'), LinkedIn company URLs (e.g., 'https://www.linkedin.com/company/google/'), or company IDs (e.g., '1441'). Supports bulk input.

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

Job title or keywords to search for (e.g., 'Software Engineer', 'Developer'). Leave empty to get all jobs.

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

Job location filter (e.g., 'United States', 'New York, NY').

## `maxJobs` (type: `integer`):

Maximum number of jobs to scrape. Default is 200.

## `sortOrder` (type: `string`):

Sort order for results (optional).

## `maxComments` (type: `integer`):

Maximum comments to retrieve (optional, for future use).

## `publishedAt` (type: `string`):

Filter by publication date. Options: 'r86400' (last 24 hours), 'r604800' (last week), 'r2592000' (last month).

## `workType` (type: `string`):

Filter by work type. Options: '1' (on-site), '2' (remote), '3' (hybrid).

## `contractType` (type: `string`):

Filter by contract type. Options: 'F' (full-time), 'P' (part-time), 'C' (contract), 'T' (temporary), 'I' (internship), 'V' (volunteer).

## `experienceLevel` (type: `string`):

Filter by experience level. Options: '1' (internship), '2' (entry), '3' (associate), '4' (mid-senior), '5' (director).

## `geoId` (type: `string`):

Geographic ID for more specific location filtering (optional).

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

Choose which proxies to use. By default, uses no proxy. If LinkedIn rejects or blocks the request, falls back to datacenter proxy, then residential proxy with 3 retries.

## Actor input object example

```json
{
  "companyInput": [
    "Google"
  ],
  "keywords": "Software Engineer",
  "location": "United States",
  "maxJobs": 20,
  "sortOrder": "",
  "maxComments": 0,
  "publishedAt": "",
  "workType": "",
  "contractType": "",
  "experienceLevel": "",
  "geoId": "",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# 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 = {
    "companyInput": [
        "Google"
    ],
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapelabsapi/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 = {
    "companyInput": ["Google"],
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("scrapelabsapi/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 '{
  "companyInput": [
    "Google"
  ],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call scrapelabsapi/linkedin-jobs-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Linkedin Jobs Scraper",
        "description": "Scrape LinkedIn job listings instantly with this LinkedIn Jobs Scraper 💼 Extract job titles, company names, locations, descriptions, salaries, and post dates with ease 📊 Perfect for recruitment, market research, lead generation, and hiring trend analysis 🔍 Fast and scalable 🚀",
        "version": "0.1",
        "x-build-id": "vNG6mOGz0rWHHy3cN"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapelabsapi~linkedin-jobs-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapelabsapi-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/scrapelabsapi~linkedin-jobs-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapelabsapi-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/scrapelabsapi~linkedin-jobs-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapelabsapi-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",
                "properties": {
                    "companyInput": {
                        "title": "Company Input (URLs, Names, or IDs)",
                        "type": "array",
                        "description": "List of company names (e.g., 'Google'), LinkedIn company URLs (e.g., 'https://www.linkedin.com/company/google/'), or company IDs (e.g., '1441'). Supports bulk input.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "keywords": {
                        "title": "Keywords",
                        "type": "string",
                        "description": "Job title or keywords to search for (e.g., 'Software Engineer', 'Developer'). Leave empty to get all jobs.",
                        "default": "Software Engineer"
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "Job location filter (e.g., 'United States', 'New York, NY').",
                        "default": "United States"
                    },
                    "maxJobs": {
                        "title": "Maximum Jobs",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of jobs to scrape. Default is 200.",
                        "default": 20
                    },
                    "sortOrder": {
                        "title": "Sort Order",
                        "enum": [
                            "",
                            "relevance",
                            "date"
                        ],
                        "type": "string",
                        "description": "Sort order for results (optional).",
                        "default": ""
                    },
                    "maxComments": {
                        "title": "Max Comments",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum comments to retrieve (optional, for future use).",
                        "default": 0
                    },
                    "publishedAt": {
                        "title": "Published At",
                        "enum": [
                            "",
                            "r86400",
                            "r604800",
                            "r2592000"
                        ],
                        "type": "string",
                        "description": "Filter by publication date. Options: 'r86400' (last 24 hours), 'r604800' (last week), 'r2592000' (last month).",
                        "default": ""
                    },
                    "workType": {
                        "title": "Work Type",
                        "enum": [
                            "",
                            "1",
                            "2",
                            "3"
                        ],
                        "type": "string",
                        "description": "Filter by work type. Options: '1' (on-site), '2' (remote), '3' (hybrid).",
                        "default": ""
                    },
                    "contractType": {
                        "title": "Contract Type",
                        "enum": [
                            "",
                            "F",
                            "P",
                            "C",
                            "T",
                            "I",
                            "V"
                        ],
                        "type": "string",
                        "description": "Filter by contract type. Options: 'F' (full-time), 'P' (part-time), 'C' (contract), 'T' (temporary), 'I' (internship), 'V' (volunteer).",
                        "default": ""
                    },
                    "experienceLevel": {
                        "title": "Experience Level",
                        "enum": [
                            "",
                            "1",
                            "2",
                            "3",
                            "4",
                            "5"
                        ],
                        "type": "string",
                        "description": "Filter by experience level. Options: '1' (internship), '2' (entry), '3' (associate), '4' (mid-senior), '5' (director).",
                        "default": ""
                    },
                    "geoId": {
                        "title": "Geographic ID",
                        "type": "string",
                        "description": "Geographic ID for more specific location filtering (optional).",
                        "default": ""
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Choose which proxies to use. By default, uses no proxy. If LinkedIn rejects or blocks the request, falls back to datacenter proxy, then residential proxy with 3 retries."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
