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

Scrape LinkedIn Learning course catalog - search by keyword or skill category and return courses with title, instructor, duration, skill level, skills taught, and more. No login required.

- **URL**: https://apify.com/crawlerbros/linkedin-learning-courses-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Automation, Developer tools, Jobs
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## LinkedIn Learning Courses Scraper

Search the [LinkedIn Learning](https://www.linkedin.com/learning/) course catalog by keyword and extract structured data about courses, learning paths, and videos — **no login or subscription required**.

### What it scrapes

- **Course title** and direct URL
- **Instructor name**
- **Duration** (seconds + human-readable, e.g. "2h 15m")
- **Difficulty level** (Beginner / Intermediate / Advanced)
- **Skills taught** (array of skill names)
- **Description** (course overview text)
- **Asset type** (Course / Learning Path / Video)
- **Scraped timestamp**

### Input

| Field | Type | Required | Default | Description |
|---|---|---|---|---|
| `searchQuery` | string | Yes | `"Python machine learning"` | Keyword or skill to search for |
| `maxResults` | integer | No | 50 | Maximum courses to return (1–500) |
| `difficultyLevel` | enum | No | All levels | Filter by BEGINNER / INTERMEDIATE / ADVANCED |
| `assetType` | enum | No | COURSE | COURSE, LEARNING_PATH, or VIDEO |
| `sortBy` | enum | No | RELEVANCE | RELEVANCE or RECENCY |
| `proxyConfiguration` | object | No | — | Optional Apify proxy settings |

#### Example input

```json
{
  "searchQuery": "Python machine learning",
  "maxResults": 50,
  "difficultyLevel": "BEGINNER",
  "assetType": "COURSE",
  "sortBy": "RELEVANCE"
}
````

### Output

Each scraped record looks like:

```json
{
  "courseId": "123456",
  "courseUrl": "https://www.linkedin.com/learning/python-for-data-science/",
  "title": "Python for Data Science",
  "instructorName": "Joe Smith",
  "durationSeconds": 7200,
  "durationFormatted": "2h",
  "difficultyLevel": "BEGINNER",
  "skills": ["Python", "Data Science", "Pandas"],
  "description": "Learn Python for data science workflows including data manipulation and visualization.",
  "assetType": "COURSE",
  "scrapedAt": "2024-01-15T12:00:00+00:00"
}
```

#### Output fields

| Field | Type | Description |
|---|---|---|
| `courseId` | string | Unique course identifier extracted from the LinkedIn URN |
| `courseUrl` | string | Direct URL to the course on LinkedIn Learning |
| `title` | string | Full course title |
| `instructorName` | string | Primary instructor or content creator |
| `durationSeconds` | integer | Total course duration in seconds |
| `durationFormatted` | string | Human-readable duration (e.g. "2h 15m", "45m") |
| `difficultyLevel` | string | BEGINNER, INTERMEDIATE, or ADVANCED |
| `skills` | array | List of skill names the course teaches |
| `description` | string | Course overview / description |
| `assetType` | string | COURSE, LEARNING\_PATH, or VIDEO |
| `scrapedAt` | string | ISO 8601 timestamp when the record was scraped |

> Fields that cannot be populated for a given course are omitted (no null values).

### Use cases

- **Skill gap analysis** — find what topics and technologies are covered by popular LinkedIn Learning courses
- **Content research** — survey what instructors and courses exist in a domain
- **Learning recommendation systems** — build datasets of course metadata for recommendation engines
- **Competitive intelligence** — monitor the LinkedIn Learning catalog for a skill category

### Limitations

- LinkedIn Learning does not expose enrollment counts or ratings in the public search API; those fields are not included
- Course descriptions and skill tags depend on how the course was catalogued by LinkedIn
- Results may vary slightly by geographic region
- `maxResults` is capped at 500 per run

### FAQs

**Does this require a LinkedIn account or login?**
No. The scraper uses LinkedIn Learning's public search endpoint which does not require authentication.

**Does it need a subscription to LinkedIn Learning?**
No. Course catalog metadata is publicly accessible without a subscription.

**Why are some courses missing descriptions or instructor names?**
Some newer or partner-contributed courses may have incomplete metadata on LinkedIn's end. The scraper only outputs fields that are actually populated.

**Can I filter by topic or category?**
Use the `searchQuery` field with specific topic keywords (e.g. "project management", "data analysis", "React.js"). Combine with `difficultyLevel` for more targeted results.

**What is a Learning Path?**
A Learning Path is a curated sequence of courses on LinkedIn Learning. Set `assetType` to `LEARNING_PATH` to search specifically for these.

**How many results can I get?**
Up to 500 courses per run. For broader research, run multiple searches with different keywords and deduplicate by `courseId`.

### Explore the rest of the LinkedIn suite

Need a different LinkedIn surface? Pair this actor with any of the others in the LinkedIn Suite — all published under the same publisher and built to share the same cookie format and output conventions.

| Actor | What it scrapes |
|---|---|
| [LinkedIn Comments Scraper](https://apify.com/crawlerbros/linkedin-comments-scraper) | All comments + reply threads on a post |
| [LinkedIn Company Employees Scraper](https://apify.com/crawlerbros/linkedin-company-employees-scraper) | Employee list for any company (by URN) |
| [LinkedIn Company Info Scraper](https://apify.com/crawlerbros/linkedin-company-info-scraper) | Company About page (size, HQ, industry, specialties) |
| [LinkedIn Company Posts Scraper](https://apify.com/crawlerbros/linkedin-company-posts-scraper) | Posts published from a company page |
| [LinkedIn Events Scraper](https://apify.com/crawlerbros/linkedin-events-scraper) | Events by keyword/URL with full event detail |
| [LinkedIn Hashtag Posts Scraper](https://apify.com/crawlerbros/linkedin-hashtag-posts-scraper) | Posts ranked under a `#hashtag` |
| [LinkedIn Jobs Scraper](https://apify.com/crawlerbros/linkedin-jobs-scraper) | Job listings via the public jobs-guest API |
| [LinkedIn Jobs Scraper Ultra](https://apify.com/crawlerbros/linkedin-jobs-scraper-ultra) | Same as jobs-scraper + full detail enrichment |
| [LinkedIn People Search Scraper](https://apify.com/crawlerbros/linkedin-people-search-scraper) | People search with every LinkedIn facet (role, company, school, location, etc.) |
| [LinkedIn Post Reactions Scraper](https://apify.com/crawlerbros/linkedin-post-reactions-scraper) | Reactors on a post (name, headline, reaction type) |
| [LinkedIn Post Scraper](https://apify.com/crawlerbros/linkedin-post-scraper) | Full post (text, media, engagement counts, author) |
| [LinkedIn Post Search Scraper](https://apify.com/crawlerbros/linkedin-post-search-scraper) | Posts matching a keyword (with date/author/network filters) |
| [LinkedIn Profile Posts Scraper](https://apify.com/crawlerbros/linkedin-profile-posts-scraper) | All posts/reposts/articles for one profile |
| [LinkedIn Profile Scraper](https://apify.com/crawlerbros/linkedin-profile-scraper) | Public profile fields (name, headline, positions, education, skills) |
| [LinkedIn Profile Scraper Pro](https://apify.com/crawlerbros/linkedin-profile-scraper-pro) | Profile fields + extras (recommendations, organizations, languages) |
| [LinkedIn Profile Scraper Pro Ultra](https://apify.com/crawlerbros/linkedin-profile-scraper-pro-ultra) | Pro + premium fields (contact info, followers list when allowed) |
| [LinkedIn Profile Scraper Ultra](https://apify.com/crawlerbros/linkedin-profile-scraper-ultra) | Profile + the full upstream dash-120 surface |
| [LinkedIn Profile Search by Name](https://apify.com/crawlerbros/linkedin-profile-search-by-name) | Search profiles by person name (great for matching CSVs of names) |
| [LinkedIn Schools Alumni Scraper](https://apify.com/crawlerbros/linkedin-schools-alumni-scraper) | Alumni list for any LinkedIn school page |
| [LinkedIn Top Content Scraper](https://apify.com/crawlerbros/linkedin-top-content-scraper) | Trending / top-engagement posts by topic |
| [LinkedIn User Activity Scraper](https://apify.com/crawlerbros/linkedin-user-activity-scraper) | Reactions + comments + posts feed for one profile |

All actors share the same `cookie` input format (plain `li_at` OR full cookies JSON array) and the same omit-empty output convention.

# Actor input Schema

## `searchQuery` (type: `string`):

Keyword or skill to search for (e.g. 'Python machine learning', 'project management', 'data analysis').

## `maxResults` (type: `integer`):

Maximum number of courses to return.

## `difficultyLevel` (type: `string`):

Filter by course difficulty level. Leave empty to return all levels.

## `assetType` (type: `string`):

Type of learning content to search for.

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

How to sort the results.

## `topic` (type: `string`):

Narrow results to a specific learning topic (e.g., 'Cloud Computing', 'Web Development'). Combined with the search query.

## `language` (type: `string`):

Filter by course language. Also selects the matching LinkedIn Learning locale.

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

Optional proxy settings. Not required for most queries.

## Actor input object example

```json
{
  "searchQuery": "Python machine learning",
  "maxResults": 50,
  "difficultyLevel": "",
  "assetType": "COURSE",
  "sortBy": "RELEVANCE",
  "language": "en",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `courses` (type: `string`):

Dataset containing all scraped LinkedIn Learning courses.

# 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 = {
    "searchQuery": "Python machine learning",
    "maxResults": 50,
    "difficultyLevel": "",
    "assetType": "COURSE",
    "sortBy": "RELEVANCE",
    "language": "en",
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/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 = {
    "searchQuery": "Python machine learning",
    "maxResults": 50,
    "difficultyLevel": "",
    "assetType": "COURSE",
    "sortBy": "RELEVANCE",
    "language": "en",
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/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 '{
  "searchQuery": "Python machine learning",
  "maxResults": 50,
  "difficultyLevel": "",
  "assetType": "COURSE",
  "sortBy": "RELEVANCE",
  "language": "en",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call crawlerbros/linkedin-learning-courses-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "LinkedIn Learning Courses Scraper",
        "description": "Scrape LinkedIn Learning course catalog - search by keyword or skill category and return courses with title, instructor, duration, skill level, skills taught, and more. No login required.",
        "version": "1.8",
        "x-build-id": "zo9YyWXYlzaavBkNW"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~linkedin-learning-courses-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-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/crawlerbros~linkedin-learning-courses-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-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/crawlerbros~linkedin-learning-courses-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-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": [
                    "searchQuery"
                ],
                "properties": {
                    "searchQuery": {
                        "title": "Search query",
                        "type": "string",
                        "description": "Keyword or skill to search for (e.g. 'Python machine learning', 'project management', 'data analysis').",
                        "default": "Python machine learning"
                    },
                    "maxResults": {
                        "title": "Max results",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum number of courses to return.",
                        "default": 50
                    },
                    "difficultyLevel": {
                        "title": "Difficulty level",
                        "enum": [
                            "",
                            "BEGINNER",
                            "INTERMEDIATE",
                            "ADVANCED"
                        ],
                        "type": "string",
                        "description": "Filter by course difficulty level. Leave empty to return all levels.",
                        "default": ""
                    },
                    "assetType": {
                        "title": "Asset type",
                        "enum": [
                            "COURSE",
                            "LEARNING_PATH",
                            "VIDEO"
                        ],
                        "type": "string",
                        "description": "Type of learning content to search for.",
                        "default": "COURSE"
                    },
                    "sortBy": {
                        "title": "Sort by",
                        "enum": [
                            "RELEVANCE",
                            "RECENCY"
                        ],
                        "type": "string",
                        "description": "How to sort the results.",
                        "default": "RELEVANCE"
                    },
                    "topic": {
                        "title": "Topic",
                        "type": "string",
                        "description": "Narrow results to a specific learning topic (e.g., 'Cloud Computing', 'Web Development'). Combined with the search query."
                    },
                    "language": {
                        "title": "Course Language",
                        "enum": [
                            "en",
                            "es",
                            "fr",
                            "de",
                            "pt"
                        ],
                        "type": "string",
                        "description": "Filter by course language. Also selects the matching LinkedIn Learning locale.",
                        "default": "en"
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional proxy settings. Not required for most queries."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
