# Linkedin Courses Scraper (`rainminer/linkedin-learning-scraper`) Actor

Extract public LinkedIn Learning course data from search results, topic pages, and course URLs. Collect LinkedIn course titles, instructors, descriptions, durations, levels, release dates, viewer counts, topics, lesson metadata, and course links.

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

## Pricing

from $1.49 / 1,000 courses

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

LinkedIn Learning Scraper extracts publicly available course data from [LinkedIn Learning](https://www.linkedin.com/learning/). Use it to collect course metadata from keyword searches, filtered search URLs, topic pages, or individual course URLs.

The Actor is useful for course catalog research, skills analysis, training-market monitoring, learning path discovery, and exporting LinkedIn Learning course results to JSON, CSV, Excel, or HTML through Apify datasets.

### What can LinkedIn Learning Scraper do?

- Scrape public LinkedIn Learning search results by keyword.
- Apply public filters such as level, content type, duration, software name, and sort order.
- Scrape LinkedIn Learning topic, browse, search, and direct course URLs.
- Enrich search results from course detail pages when public course metadata is available.
- Collect titles, course URLs, instructors, descriptions, durations, levels, release dates, viewer counts, topics, images, and lesson metadata.
- Limit the number of courses per search query or start URL with `maxItems`.

### What LinkedIn Learning data can you extract?

| Field | Description |
| --- | --- |
| `title` | Course title |
| `courseUrl` | Canonical LinkedIn Learning course URL |
| `description` | Public course description |
| `duration`, `durationSeconds` | Course duration as text and seconds |
| `level` | Skill level when visible, such as Beginner or Advanced |
| `releasedAt` | Public release date |
| `viewerCount` | Public historical viewer/enrollment count when available |
| `instructorNames` | Instructor names |
| `instructors` | Instructor profile metadata when available |
| `topics`, `topicNames` | Public topic/category data |
| `lessons` | Public lesson names, URLs, and durations when available |
| `imageUrl`, `thumbnailUrl` | Course image URLs |
| `searchUrl` | Search or topic URL that produced the course |

### How to scrape LinkedIn Learning courses

1. Add one or more keywords to `searchQueries`, or paste LinkedIn Learning search, topic, browse, or course URLs into `startUrls`.
2. Choose filters such as `difficultyLevel`, `durationV2`, `softwareNames`, `entityType`, and `sortBy`.
3. Set `maxItems` to control how many course records are saved per search query or URL.
4. Run the Actor and download the dataset from Apify Console or consume it through the Apify API.

Example input:

```json
{
  "searchQueries": ["python"],
  "sortBy": "POPULARITY",
  "difficultyLevel": "BEGINNER",
  "entityType": "COURSE",
  "durationV2": "MORE_THAN_3_HOURS",
  "softwareNames": ["Python"],
  "maxItems": 10,
  "includeLessons": true,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
````

You can also paste a filtered public URL:

```json
{
  "startUrls": [
    {
      "url": "https://www.linkedin.com/learning/search?keywords=excel&difficultyLevel=BEGINNER&entityType=COURSE"
    }
  ],
  "maxItems": 5
}
```

### Output example

```json
{
  "title": "Python Essential Training",
  "courseUrl": "https://www.linkedin.com/learning/python-essential-training-18764650",
  "searchUrl": "https://www.linkedin.com/learning/search?keywords=python&sortBy=POPULARITY&entityType=COURSE",
  "sourceUrl": "https://www.linkedin.com/learning/python-essential-training-18764650",
  "contentType": "Course",
  "description": "Python is one of the most commonly used dynamic languages...",
  "shortDescription": "Get a comprehensive overview of the Python programming language...",
  "duration": "4h 23m",
  "durationSeconds": 15789,
  "level": "Beginner",
  "releasedAt": "2023-01-25",
  "dateCreated": "2023-01-25",
  "language": "en",
  "viewerCount": 628669,
  "likedCount": 18282,
  "instructorNames": ["Ryan Mitchell"],
  "instructors": [
    {
      "name": "Ryan Mitchell",
      "url": "https://www.linkedin.com/in/remitchell",
      "jobTitle": "LinkedIn Learning Instructor",
      "description": "LinkedIn Learning Instructor",
      "imageUrl": "https://media.licdn.com/..."
    }
  ],
  "topics": [
    {
      "name": "Python (Programming Language)",
      "url": "https://www.linkedin.com/learning/topics/python"
    }
  ],
  "topicNames": ["Python (Programming Language)"],
  "lessonCount": 72,
  "lessons": [
    {
      "title": "What is Python?",
      "url": "https://www.linkedin.com/learning/python-essential-training-18764650/what-is-python",
      "duration": "2m 10s",
      "durationSeconds": 130
    }
  ],
  "imageUrl": "https://media.licdn.com/...",
  "thumbnailUrl": "https://media.licdn.com/...",
  "provider": "LinkedIn Learning",
  "url": "https://www.linkedin.com/learning/python-essential-training-18764650"
}
```

### Pricing and performance

This Actor uses lightweight HTTP requests and Cheerio parsing instead of a browser, so small course research jobs should run quickly and cheaply. Proxy usage is disabled by default. If LinkedIn Learning returns blocked or sign-in pages from your environment, enable Apify Proxy in the input.

Public LinkedIn Learning result pages may expose only a limited set of results to logged-out visitors. For larger coverage, use multiple focused keywords, topic URLs, or direct course URLs.

### FAQ

#### Does this Actor scrape private LinkedIn Learning data?

No. It only extracts data that LinkedIn Learning exposes publicly to logged-out visitors. It does not log in, bypass paywalls, or access private member data.

#### Can I use filters?

Yes. The Actor supports public LinkedIn Learning search filters including `sortBy`, `difficultyLevel`, `entityType`, `durationV2`, and `softwareNames`. You can also paste a LinkedIn Learning search URL that already contains filters.

#### Can I scrape several searches in one run?

Yes. Add multiple values to `searchQueries` or multiple URLs to `startUrls`. The `maxItems` limit is applied separately to each search query or URL.

#### Is scraping LinkedIn Learning legal?

This Actor extracts public course information. You are responsible for using the data lawfully and respecting applicable privacy, database, copyright, and platform rules. If you are unsure whether your use case is permitted, consult your legal team.

### Image Credit

Image credit: [LinkedIn Learning](https://www.linkedin.com/learning/)

# Actor input Schema

## `searchQueries` (type: `array`):

Keywords to search on LinkedIn Learning, such as Python, leadership, Excel, or data analysis.

## `startUrls` (type: `array`):

LinkedIn Learning search, topic, browse, or course URLs. Existing URL filters are preserved.

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

Public LinkedIn Learning search sort option applied to search queries.

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

Optional public LinkedIn Learning level filter.

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

Type of LinkedIn Learning result to collect. Course is recommended for course data.

## `durationV2` (type: `string`):

Optional public LinkedIn Learning duration filter.

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

Optional software filter values, for example Python, Microsoft Excel, SQL, pandas, or ChatGPT.

## `maxItems` (type: `integer`):

Maximum number of course records to save per search query or start URL.

## `includeLessons` (type: `boolean`):

Include public lesson names, URLs, and durations when available on course pages.

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

Proxy settings for the crawler. Disabled by default because public pages usually work without proxies.

## Actor input object example

```json
{
  "searchQueries": [
    "python"
  ],
  "startUrls": [
    {
      "url": "https://www.linkedin.com/learning/search?keywords=python"
    }
  ],
  "sortBy": "RELEVANCE",
  "entityType": "COURSE",
  "maxItems": 10,
  "includeLessons": true,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `overview` (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 = {
    "searchQueries": [
        "python"
    ],
    "startUrls": [
        {
            "url": "https://www.linkedin.com/learning/search?keywords=python"
        }
    ],
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("rainminer/linkedin-learning-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 = {
    "searchQueries": ["python"],
    "startUrls": [{ "url": "https://www.linkedin.com/learning/search?keywords=python" }],
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("rainminer/linkedin-learning-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 '{
  "searchQueries": [
    "python"
  ],
  "startUrls": [
    {
      "url": "https://www.linkedin.com/learning/search?keywords=python"
    }
  ],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call rainminer/linkedin-learning-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Linkedin Courses Scraper",
        "description": "Extract public LinkedIn Learning course data from search results, topic pages, and course URLs. Collect LinkedIn course titles, instructors, descriptions, durations, levels, release dates, viewer counts, topics, lesson metadata, and course links.",
        "version": "1.0",
        "x-build-id": "70QlKFHOJBDq9tfMz"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/rainminer~linkedin-learning-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-rainminer-linkedin-learning-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/rainminer~linkedin-learning-scraper/runs": {
            "post": {
                "operationId": "runs-sync-rainminer-linkedin-learning-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/rainminer~linkedin-learning-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-rainminer-linkedin-learning-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": {
                    "searchQueries": {
                        "title": "Search queries",
                        "type": "array",
                        "description": "Keywords to search on LinkedIn Learning, such as Python, leadership, Excel, or data analysis.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "LinkedIn Learning search, topic, browse, or course URLs. Existing URL filters are preserved.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "sortBy": {
                        "title": "Sort by",
                        "enum": [
                            "RELEVANCE",
                            "POPULARITY",
                            "RECENCY"
                        ],
                        "type": "string",
                        "description": "Public LinkedIn Learning search sort option applied to search queries.",
                        "default": "RELEVANCE"
                    },
                    "difficultyLevel": {
                        "title": "Level",
                        "enum": [
                            "BEGINNER",
                            "INTERMEDIATE",
                            "ADVANCED"
                        ],
                        "type": "string",
                        "description": "Optional public LinkedIn Learning level filter."
                    },
                    "entityType": {
                        "title": "Content type",
                        "enum": [
                            "COURSE",
                            "VIDEO",
                            "LEARNING_PATH"
                        ],
                        "type": "string",
                        "description": "Type of LinkedIn Learning result to collect. Course is recommended for course data.",
                        "default": "COURSE"
                    },
                    "durationV2": {
                        "title": "Duration",
                        "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"
                        ],
                        "type": "string",
                        "description": "Optional public LinkedIn Learning duration filter."
                    },
                    "softwareNames": {
                        "title": "Software names",
                        "type": "array",
                        "description": "Optional software filter values, for example Python, Microsoft Excel, SQL, pandas, or ChatGPT.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "Max courses per search or URL",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum number of course records to save per search query or start URL.",
                        "default": 10
                    },
                    "includeLessons": {
                        "title": "Include lesson metadata",
                        "type": "boolean",
                        "description": "Include public lesson names, URLs, and durations when available on course pages.",
                        "default": true
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Proxy settings for the crawler. Disabled by default because public pages usually work without proxies."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
