# LinkedIn Learning Courses Scraper (`apt_marble/linkedin-learning-courses-scraper`) Actor

Extract LinkedIn Learning course data at scale: titles, instructors, durations, ratings, learner counts, difficulty levels and skills. Search by keyword with filters, get structured JSON/CSV in seconds. No login or cookies required.

- **URL**: https://apify.com/apt\_marble/linkedin-learning-courses-scraper.md
- **Developed by:** [Hamza](https://apify.com/apt_marble) (community)
- **Categories:** Social media, Jobs, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$2.50 / 1,000 course scrapeds

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 Learning Courses Scraper 🎓

Search the **LinkedIn Learning course catalog by keyword** with the same filters the platform offers — content type, difficulty level, course length, software and sort order. Get back clean, structured JSON with course descriptions, instructors, exact course length, ratings, difficulty and skills covered. No login or cookies required.

Built for **L&D platforms** benchmarking their libraries, **ed-tech market researchers** sizing demand by topic, and **course creators** doing competitive analysis before recording a single lesson.

### ✨ What you get

One record per unique course:

| Field | Description |
|---|---|
| `title` / `courseUrl` / `slug` | The course and its canonical LinkedIn Learning URL |
| `entityType` | `COURSE`, `LEARNING_PATH` or `VIDEO` |
| `instructorText` / `instructors` | The byline plus structured instructors with their job titles |
| `parentCourseTitle` | For video results: the course the video belongs to |
| `workloadIso` / `workloadText` / `durationText` | Course length as ISO-8601 (`PT2H50M54S`) and human-readable (`2h 50m`) |
| `description` | The course description |
| `provider` | Content provider (e.g. `LinkedIn Learning`) |
| `rating` / `ratingCount` | Average learner rating (out of 5) and number of ratings |
| `viewersCount` / `learnersCount` | Catalog viewers and historical enrollment where shown |
| `releasedAt` | Release date (`YYYY-MM-DD`) |
| `difficulty` | `Beginner` / `Intermediate` / `Advanced` |
| `skills` | Skills/topics the course covers |
| `language` / `thumbnailUrl` | Course language and artwork |
| `keyword` / `position` / `searchUrl` / `scrapedAt` | Provenance |

### ⚙️ Options

- **Keywords** — any number of topics, skills or tools; each gets its own result quota.
- **Content type** — full courses (default), curated learning paths, or individual videos.
- **Filters** — exactly like the linkedin.com/learning filter panel: difficulty level, course length brackets, software names, and sort (relevance / popularity / recency).
- **Scrape full course details** — opens each course page for the description, instructors, exact length, rating, difficulty, skills, learner count and release date. Turn it off for a faster list-level run.
- **Expand coverage** — the public course search has **no pagination**: every query returns one page of up to ~50 results. This option honestly works around that by re-running each keyword under the other two sort orders and deduplicating, typically surfacing 1.5–2x more unique courses per keyword.

### 🚀 Example

Input:

```json
{
    "keywords": ["python", "data analysis"],
    "entityType": "COURSE",
    "difficultyLevel": ["BEGINNER", "INTERMEDIATE"],
    "durations": ["BETWEEN_1_TO_2_HOURS", "BETWEEN_2_TO_3_HOURS"],
    "sortBy": "POPULARITY",
    "expandCoverage": true,
    "maxCoursesPerKeyword": 50,
    "enrichDetails": true
}
````

One record from the output:

```json
{
    "keyword": "python",
    "slug": "advanced-python-23931756",
    "courseUrl": "https://www.linkedin.com/learning/advanced-python-23931756",
    "title": "Advanced Python",
    "entityType": "COURSE",
    "instructorText": "Joe Marini",
    "instructors": [
        {
            "name": "Joe Marini",
            "jobTitle": "2X Exit Founder | Developer Relations and Partnerships Ecosystem Advocate | Technology Education Instructor with 10M Learners"
        }
    ],
    "durationText": "2h 50m",
    "workloadIso": "PT2H50M54S",
    "workloadText": "2h 50m",
    "description": "Take your Python skills to the next level in this hands-on, interactive course with coding challenges in CoderPad.",
    "provider": "LinkedIn Learning",
    "rating": 4.7,
    "ratingCount": 157,
    "viewersCount": 73836,
    "learnersCount": 12741,
    "releasedAt": "2024-12-09",
    "difficulty": "Advanced",
    "skills": ["Python (Programming Language)"],
    "language": "en",
    "thumbnailUrl": "https://media.licdn.com/dms/image/v2/D4D0DAQGl3s1fBLp7kg/learning-public-crop_675_1200/…",
    "position": 2,
    "searchUrl": "https://www.linkedin.com/learning/search?keywords=python",
    "scrapedAt": "2026-07-24T18:40:11.000Z"
}
```

### 💡 Use cases

- **Competitive analysis for course creators** — before producing a course, see every existing title on the topic, who teaches it, how long it is, how it is rated and when it was last refreshed.
- **Ed-tech market research** — map catalog depth, difficulty mix and release cadence per skill area; spot topics with old, low-rated coverage (content gaps).
- **L\&D benchmarking** — compare your internal library against the LinkedIn Learning catalog per skill, difficulty and duration bracket.
- **Skills intelligence** — track which tools and skills get fresh course investment quarter over quarter.
- **Content curation** — build ranked shortlists of top-rated, recent courses per topic for learning paths and newsletters.

### ❓ FAQ

**Do I need a LinkedIn account or cookies?**
No. The actor only reads the public, logged-out course catalog.

**Why do I get at most ~50 results per keyword?**
That is everything LinkedIn Learning's public search returns for a query — it serves a single page with no pagination for visitors. The **Expand coverage** option re-runs each keyword under the other sort orders and dedupes, which typically surfaces 1.5–2x more unique courses. For broad topics, the most effective strategy is several narrower keywords (e.g. `"excel pivot tables"`, `"excel formulas"`, `"excel vba"` instead of just `"excel"`).

**What does "Scrape full course details" add?**
The list page only shows title, byline, length, viewers and release date. Enrichment opens each course page and adds the description, structured instructors with job titles, exact ISO length, rating and rating count, difficulty, skills, learner enrollment and language.

**Are results deduplicated?**
Yes — by course slug, across all keywords and sort variants in a run. You are never billed twice for the same course.

**Can I scrape learning paths or single videos?**
Yes — set **Content type** to `LEARNING_PATH` or `VIDEO`. Note that detail enrichment is richest for courses; video and learning-path pages expose less structured data, so some fields may be `null`.

# Actor input Schema

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

One or more topic, skill or tool searches (e.g. "python", "project management", "excel"). Each keyword gets its own result quota.

## `entityType` (type: `string`):

What kind of catalog entries to search for: full courses, curated learning paths, or individual videos.

## `maxCoursesPerKeyword` (type: `integer`):

How many unique results to collect for each keyword. A single guest results page tops out around 40-50 — switch on "Expand coverage" to surface more.

## `enrichDetails` (type: `boolean`):

Opens each course page to capture the description, instructors with their job titles, exact course length, rating and rating count, difficulty level, skills covered, learner count and release date. Turn off for a faster, lighter run with list-level data only.

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

How the catalog ranks the results.

## `expandCoverage` (type: `boolean`):

The public course search has no pagination — every query returns a single page of up to ~50 results, no matter what. When enabled, each keyword is additionally re-run under the other two sort orders (relevance / popularity / recency) and the results are deduplicated, which is the honest way to surface more of the catalog for a keyword (typically 1.5-2x more unique results at up to 3x the search requests).

## `difficultyLevel` (type: `array`):

Restrict to one or more difficulty levels.

## `durations` (type: `array`):

Restrict to one or more length brackets.

## `softwareNames` (type: `array`):

Restrict to courses about specific software, e.g. "Microsoft Excel", "Figma", "Python". Use the exact names the linkedin.com/learning filter panel shows.

## `proxyCountry` (type: `string`):

Two-letter country code for the request IP. Supported: us, gb (or uk), ca, au, de, fr, es, it, nl, ie, in, sg — any other code falls back to "us" with a warning in the log.

## `maxConcurrency` (type: `integer`):

How many course pages to enrich in parallel (capped at 3 to stay polite).

## Actor input object example

```json
{
  "keywords": [
    "python"
  ],
  "entityType": "COURSE",
  "maxCoursesPerKeyword": 50,
  "enrichDetails": true,
  "sortBy": "POPULARITY",
  "expandCoverage": false,
  "difficultyLevel": [],
  "durations": [],
  "softwareNames": [],
  "proxyCountry": "us",
  "maxConcurrency": 3
}
```

# Actor output Schema

## `dataset` (type: `string`):

No description

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "keywords": [
        "python"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("apt_marble/linkedin-learning-courses-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": ["python"] }

# Run the Actor and wait for it to finish
run = client.actor("apt_marble/linkedin-learning-courses-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": [
    "python"
  ]
}' |
apify call apt_marble/linkedin-learning-courses-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "LinkedIn Learning Courses Scraper",
        "description": "Extract LinkedIn Learning course data at scale: titles, instructors, durations, ratings, learner counts, difficulty levels and skills. Search by keyword with filters, get structured JSON/CSV in seconds. No login or cookies required.",
        "version": "0.0",
        "x-build-id": "swSyBBVpqYMfbFFzh"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/apt_marble~linkedin-learning-courses-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-apt_marble-linkedin-learning-courses-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/apt_marble~linkedin-learning-courses-scraper/runs": {
            "post": {
                "operationId": "runs-sync-apt_marble-linkedin-learning-courses-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/apt_marble~linkedin-learning-courses-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-apt_marble-linkedin-learning-courses-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "keywords"
                ],
                "properties": {
                    "keywords": {
                        "title": "Keywords",
                        "type": "array",
                        "description": "One or more topic, skill or tool searches (e.g. \"python\", \"project management\", \"excel\"). Each keyword gets its own result quota.",
                        "default": [
                            "python"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "entityType": {
                        "title": "Content type",
                        "enum": [
                            "COURSE",
                            "LEARNING_PATH",
                            "VIDEO"
                        ],
                        "type": "string",
                        "description": "What kind of catalog entries to search for: full courses, curated learning paths, or individual videos.",
                        "default": "COURSE"
                    },
                    "maxCoursesPerKeyword": {
                        "title": "Maximum results per keyword",
                        "minimum": 0,
                        "type": "integer",
                        "description": "How many unique results to collect for each keyword. A single guest results page tops out around 40-50 — switch on \"Expand coverage\" to surface more.",
                        "default": 50
                    },
                    "enrichDetails": {
                        "title": "Scrape full course details",
                        "type": "boolean",
                        "description": "Opens each course page to capture the description, instructors with their job titles, exact course length, rating and rating count, difficulty level, skills covered, learner count and release date. Turn off for a faster, lighter run with list-level data only.",
                        "default": true
                    },
                    "sortBy": {
                        "title": "Sort by",
                        "enum": [
                            "RELEVANCE",
                            "POPULARITY",
                            "RECENCY"
                        ],
                        "type": "string",
                        "description": "How the catalog ranks the results.",
                        "default": "POPULARITY"
                    },
                    "expandCoverage": {
                        "title": "Expand coverage (re-run each keyword under every sort order)",
                        "type": "boolean",
                        "description": "The public course search has no pagination — every query returns a single page of up to ~50 results, no matter what. When enabled, each keyword is additionally re-run under the other two sort orders (relevance / popularity / recency) and the results are deduplicated, which is the honest way to surface more of the catalog for a keyword (typically 1.5-2x more unique results at up to 3x the search requests).",
                        "default": false
                    },
                    "difficultyLevel": {
                        "title": "Difficulty level",
                        "type": "array",
                        "description": "Restrict to one or more difficulty levels.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "BEGINNER",
                                "INTERMEDIATE",
                                "ADVANCED"
                            ],
                            "enumTitles": [
                                "Beginner",
                                "Intermediate",
                                "Advanced"
                            ]
                        },
                        "default": []
                    },
                    "durations": {
                        "title": "Course length",
                        "type": "array",
                        "description": "Restrict to one or more length brackets.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "BETWEEN_0_TO_10_MIN",
                                "BETWEEN_10_TO_30_MIN",
                                "BETWEEN_30_TO_60_MIN",
                                "BETWEEN_1_TO_2_HOURS",
                                "BETWEEN_2_TO_3_HOURS",
                                "MORE_THAN_3_HOURS"
                            ],
                            "enumTitles": [
                                "Under 10 minutes",
                                "10-30 minutes",
                                "30-60 minutes",
                                "1-2 hours",
                                "2-3 hours",
                                "Over 3 hours"
                            ]
                        },
                        "default": []
                    },
                    "softwareNames": {
                        "title": "Software / tools",
                        "type": "array",
                        "description": "Restrict to courses about specific software, e.g. \"Microsoft Excel\", \"Figma\", \"Python\". Use the exact names the linkedin.com/learning filter panel shows.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "proxyCountry": {
                        "title": "IP country (advanced)",
                        "type": "string",
                        "description": "Two-letter country code for the request IP. Supported: us, gb (or uk), ca, au, de, fr, es, it, nl, ie, in, sg — any other code falls back to \"us\" with a warning in the log.",
                        "default": "us"
                    },
                    "maxConcurrency": {
                        "title": "Concurrency (advanced)",
                        "minimum": 1,
                        "maximum": 3,
                        "type": "integer",
                        "description": "How many course pages to enrich in parallel (capped at 3 to stay polite).",
                        "default": 3
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```