# Linkedin Video Downloader (`agentx/linkedin-video-downloader`) Actor

Process one publicly accessible LinkedIn post containing video for structured metadata and an optional stored video file.

- **URL**: https://apify.com/agentx/linkedin-video-downloader.md
- **Developed by:** [AgentX](https://apify.com/agentx) (community)
- **Categories:** Videos, Lead generation, Automation
- **Stats:** 1 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
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 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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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 Video Downloader prepares one accessible LinkedIn post containing video as normalized metadata and can optionally store the available media file in Apify.

- Two public inputs cover one LinkedIn post URL and an optional download preference.
- Four quality values provide metadata-only, low, medium, and high processing modes.
- Successful records follow a 39-field Dataset contract with thumbnail-first display.
- Comment retrieval is not exposed; the reserved `comments` array is normally empty.

**[Run one LinkedIn post test](https://apify.com/agentx/linkedin-video-downloader)**

**[View the Apify API](https://apify.com/agentx/linkedin-video-downloader/api)**

Publish the Actor, replace the illustrative post URL, and test metadata before file delivery.

### Why Choose This API

Linkedin Video Downloader defines a small processing contract for one public LinkedIn post with video. Available source values are mapped to stable fields for video identity, author, publication time, thumbnail, duration, engagement counters, dimensions, audio labels, and run provenance.

Metadata mode avoids transferring media. A low, medium, or high selection requests an available rendition and can store the file. Source encodes determine the actual result; a preference is not a guaranteed resolution.

The contract is different from LinkedIn profile, company, jobs, events, course, feed, search, or comment extraction. Although the local yt-dlp list contains LinkedIn, events, and learning extractors, this Actor documents only one post URL. That narrow claim still requires representative live validation.

### Quick Start Guide

The same illustrative post is used throughout:

```json
{
  "video_url": "https://www.linkedin.com/posts/leidos_ifpc-increment-2-launch-video-activity-7358191055076294656-42wv",
  "video_quality": "metadata"
}
```

Replace the placeholder with a current public post you are authorized to process. Open it in a private browser window; a post visible only when signed in does not satisfy the public contract. Submit metadata mode and verify ID, author, thumbnail, and title or description.

Only request a file after the returned identity matches. A rendered HTML page or succeeded run is not enough if the expected video record is absent. Use separate runs for multiple posts.

### Input Parameters

| Parameter | Type | Required | Purpose |
|---|---|---:|---|
| `video_url` | string | Yes | One accessible LinkedIn post URL containing video. |
| `video_quality` | string | No | `metadata`, `low`, `medium`, or `high`; metadata skips storage. |

The URL field has the matching placeholder prefill and example. The optional quality field has no prefill or example; when omitted, the runtime uses metadata mode.

No profile, company, course, event, job, feed, query, date, login, cookie, country, batch, or comment option exists. Additional input properties are rejected.

### Output Data Schema

The Dataset exposes 39 possible fields:

| Area | Fields |
|---|---|
| Video identity | `thumbnail`, `id`, `platform`, `title`, `description`, `duration`, `published_at` |
| Publisher | `author`, `author_id`, `author_url` |
| Labels and counters | `categories`, `tags`, `view_count`, `like_count`, `shares_count`, `dislike_count`, `comment_count` |
| Technical media | `width`, `height`, `fps`, `audio_title`, `audio_artist`, `video` |
| Reserved and provenance | `comments`, `processed_at`, `processor` |

An abbreviated shape for the same placeholder is:

```json
{
  "id": "0000000000000000000",
  "platform": "LinkedIn",
  "title": "Example LinkedIn video post",
  "author": "Example publisher",
  "thumbnail": "https://example.com/linkedin-thumbnail.jpg",
  "comments": [],
  "video": ""
}
```

This is a schema illustration, not observed output. LinkedIn may expose only a subset of fields to guests, so nulls are expected. Metadata mode returns no stored file. The public input does not retrieve post comments.

Source-dependent fields also present in every item:

| Field | Meaning |
|---|---|
| `source_url` | Canonical page URL of the item on its own platform |
| `media_type` | Kind of media the source reports, such as video or audio |
| `live_status` | Whether the item is a recording, currently live, or a finished stream |
| `availability` | Source visibility, such as public, unlisted, or needs\_auth |
| `age_limit` | Minimum viewer age the source enforces; zero means no restriction |
| `language` | Primary language of the item as reported by the source |
| `followers` | Follower or subscriber count of the author at processing time |
| `is_verified` | Whether the author's account carries a verified badge |
| `saves_count` | Times viewers saved the item, on sources that expose it |
| `file_ext` | Container extension of the selected media, such as mp4 or webm |
| `file_size` | Size of the selected media in bytes, exact or approximate |
| `subtitles` | Language codes of published subtitle tracks; auto-captions excluded |
| `chapters` | Chapter markers with title and start and end time in seconds |

### Integration Examples

The intended reference is `agentx/linkedin-video-downloader`.use the same scenario over HTTP:

```bash
curl -X POST "https://api.apify.com/v2/acts/agentx~linkedin-video-downloader/runs?token=$APIFY_TOKEN" \
 -H "Content-Type: application/json" \
 -d '{"video_url":"https://www.linkedin.com/posts/leidos_ifpc-increment-2-launch-video-activity-7358191055076294656-42wv","video_quality":"metadata"}'
```

The matching hosted MCP configuration is:

```json
{
  "mcpServers": {
    "apify-linkedin-video": {
      "url": "https://mcp.apify.com?tools=agentx/linkedin-video-downloader",
      "headers": {
        "Authorization": "Bearer <APIFY_TOKEN>"
      }
    }
  },
  "exampleToolArguments": {
    "video_url": "https://www.linkedin.com/posts/leidos_ifpc-increment-2-launch-video-activity-7358191055076294656-42wv",
    "video_quality": "metadata"
  }
}
```

Publication is required for discovery. Protect the token and follow the [Apify MCP documentation](https://docs.apify.com/integrations/mcp).

### Pricing & Cost Calculator

Local metadata declares these events, not a verified Store offer:

| Event | Billing unit | Local price |
|---|---|---:|
| `actor_usage` | Metered runtime, proxy, and storage usage | $0.00001 |
| `metadata` | One successfully processed metadata result | $0.13 |
| `download` | One successfully processed result with stored video | $0.30 |

The smallest metadata result declares $0.13 plus metered usage. A download result declares $0.30 plus metered usage.

### Use Cases & Applications

Communications teams can preserve an authorized company announcement video with source identity and processing time. Researchers can document one public professional-media post. Developers can send the Dataset item to a webhook or catalog. AI teams can pass a permitted stored file to a separate transcription service.

Repeated metadata runs can observe currently exposed counters, but the Actor does not calculate changes or deduplicate. Keep the source URL and media ID with every result. A previously accessible post can later require login or be removed.

### Limits & Troubleshooting

LinkedIn frequently varies guest access. Sign-in walls, deleted posts, member privacy, company controls, geography, rate limits, or platform changes can prevent extraction. The Actor exposes no LinkedIn credential or cookie input.

If no item appears, replace open the exact post in a private window, confirm that it contains video, and retry metadata mode. Do not submit a profile, company, course, event, or feed URL.

If a download run has no `video`, inspect logs and storage, then retest metadata. Before release, run public video, text-only, login-gated, removed, malformed, and download cases. Check all 26 output keys and the intended media identity.

### FAQ

#### Can it scrape a LinkedIn profile or company?

No. Use a dedicated AgentX lookup Actor for those entities.

#### Does it process LinkedIn Learning courses or events?

No. Those local extractors are not part of this public post contract.

#### Can it retrieve post comments?

No comment input exists; the reserved list is normally empty.

#### Can it bypass a sign-in wall?

No login or cookie field is exposed.

#### Does high guarantee a resolution?

No. The post’s available renditions determine the result.

#### Why are fields null?

The guest-visible source did not expose them. Null is not zero.

#### Can it run on a schedule?

Yes, but access and post availability can change.

#### Which LinkedIn post URLs can be processed?

Use a public `linkedin.com/posts/<slug>-<activity-id>-<code>` permalink whose primary attachment is a native video. Posts behind a sign-in wall, LinkedIn Learning lessons, and event pages sit outside this contract, and no credential input exists to reach them.

### Legal & Responsible Use

Process only posts you are authorized to access, download, and retain. Public visibility does not grant reuse rights. The caller is responsible for LinkedIn terms, copyright, privacy, law, and retention policy.

### Related Tools

- [LinkedIn Company Lookup](https://apify.com/agentx/linkedin-company-lookup) handles company information.
- [LinkedIn Profile Lookup](https://apify.com/agentx/linkedin-profile-lookup) handles person profile information.
- [LinkedIn Jobs Scraper](https://apify.com/agentx/linkedin-jobs-scraper) handles job listings.
- [All Video Scraper](https://apify.com/agentx/all-video-scraper) accepts supported URLs from multiple video hosts.

### Support & Community

- [AgentX community](https://t.me/Apify_Actor)
- [Contact the AgentX team](https://t.me/AiAgentApi)
- [Apify Actor dashboard](https://apify.com/agentx/linkedin-video-downloader)
- [Apify API reference](https://apify.com/agentx/linkedin-video-downloader/api)
- [Apify MCP documentation](https://docs.apify.com/integrations/mcp)

Include the stable ID, redacted post URL, access condition, input, and run ID in support requests.

**[Run one LinkedIn post test](https://apify.com/agentx/linkedin-video-downloader)**

**[View the Apify API](https://apify.com/agentx/linkedin-video-downloader/api)**

# Actor input Schema

## `video_url` (type: `string`):

Publicly accessible LinkedIn post URL containing video.

## `video_quality` (type: `string`):

Preferred download quality, or metadata-only mode without a video file.

## Actor input object example

```json
{
  "video_url": "https://www.linkedin.com/posts/leidos_ifpc-increment-2-launch-video-activity-7358191055076294656-42wv"
}
```

# Actor output Schema

## `results` (type: `string`):

All video details and optional download links with full engagement stats and comments

# 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 = {
    "video_url": "https://www.linkedin.com/posts/leidos_ifpc-increment-2-launch-video-activity-7358191055076294656-42wv"
};

// Run the Actor and wait for it to finish
const run = await client.actor("agentx/linkedin-video-downloader").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 = { "video_url": "https://www.linkedin.com/posts/leidos_ifpc-increment-2-launch-video-activity-7358191055076294656-42wv" }

# Run the Actor and wait for it to finish
run = client.actor("agentx/linkedin-video-downloader").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 '{
  "video_url": "https://www.linkedin.com/posts/leidos_ifpc-increment-2-launch-video-activity-7358191055076294656-42wv"
}' |
apify call agentx/linkedin-video-downloader --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/XCtHOsxG5iPDMff4h/builds/9E0vr1GDO3hxbeZ2V/openapi.json
