# LinkedIn Post Details Scraper (`khadinakbar/linkedin-post-details-scraper`) Actor

Get a public LinkedIn post by URL: full text, author, media, reaction and comment counts, optional transcript and comments preview. Provider-backed via ScrapeCreators and SociaVault; no user cookies required. Charged $0.008 per post.

- **URL**: https://apify.com/khadinakbar/linkedin-post-details-scraper.md
- **Developed by:** [Khadin Akbar](https://apify.com/khadinakbar) (community)
- **Categories:** Social media, Automation, MCP servers
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $8.00 / 1,000 linkedin post scrapeds

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#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 Post Details Scraper

Get **full public details for a LinkedIn post URL** — text, author, media, **reaction and comment counts**, optional video transcript, and a comments preview. Paste one post URL (or a short list) and get **one clean dataset row per post**. No LinkedIn login. No cookies.

Built for AI agents and content pipelines: a known URL in, structured JSON out, predictable $0.008 per saved post.

> Honest reaction contract: public no-login data exposes **aggregate reaction counts** (`reactionCount` / `likeCount`), not who reacted and not a LIKE vs CELEBRATE vs INSIGHTFUL split. Reactor identities stay behind LinkedIn login. For commenter identities use [LinkedIn Post Engagers Scraper](https://apify.com/khadinakbar/linkedin-post-engagers-scraper).

### What you get

| Field | What it answers |
|---|---|
| `text`, `title`, `headline` | **What** was posted (full body; article title when it is a Pulse post) |
| `authorName`, `authorUrl`, `authorFollowers` | **Who** posted it |
| `reactionCount`, `likeCount`, `commentCount`, `shareCount` | **How** the post is performing publicly |
| `mediaUrl`, `mediaUrls`, `thumbnailUrl`, `transcript` | **Media** — video/image URLs plus transcript when LinkedIn exposes one |
| `commentsPreview[]` | **Top visible comments** attached to the same row (not a full thread export) |
| `postUrl`, `postId`, `postKind`, `publishedAt`, `provider`, `scrapedAt` | **Provenance** — which post, when, from which provider |

### Who it is for (and why it matters)

- **Content and social teams** — archive a specific LinkedIn post with engagement counts instead of screenshots.
- **Competitive intelligence** — capture a rival's announcement post, reactions, and visible comments in one record.
- **Researchers and journalists** — pull a citable public post body, timestamp, and author without a LinkedIn account.
- **AI agents** — resolve a LinkedIn URL the user pasted into a tool call into structured JSON (`apify--linkedin-post-details-scraper`).

### When to use this Actor

- You already have a LinkedIn post, feed-update, or Pulse article URL and need the full public record.
- You need reaction **counts** plus post text in the same row.
- You want a cookieless, MCP-ready get-post tool rather than a search or feed crawler.

### Best fit & sibling routing

- Keyword / company-feed discovery → [LinkedIn Posts Scraper](https://apify.com/khadinakbar/linkedin-posts-scraper)
- A person's recent posts by profile URL → [LinkedIn Profile Posts Scraper](https://apify.com/khadinakbar/linkedin-profile-posts-scraper)
- People who commented (leads) → [LinkedIn Post Engagers Scraper](https://apify.com/khadinakbar/linkedin-post-engagers-scraper)
- Reaction **count summaries only** → [LinkedIn Post Reactions Scraper](https://apify.com/khadinakbar/linkedin-post-reactions-scraper)
- Full comment threads as the primary entity → [LinkedIn Post Comments & Engagements Scraper](https://apify.com/khadinakbar/linkedin-post-comments-engagements-scraper)

This Actor is the **get-by-URL** sibling: one post in, one detail row out.

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `postUrls` | array (required) | 1 example URL | LinkedIn post / activity / pulse URLs, or a bare activity ID |
| `maxPosts` | integer | 100 | Budget cap on unique URLs processed |
| `includeCommentsPreview` | boolean | true | Attach visible comments on the post row |
| `maxCommentsPreview` | integer | 10 | Cap comments attached per row (0–50) |
| `outputMode` | enum | `full` | `full` or `compact` (shorter agent records) |
| `providerOrder` | enum | `scrapecreators-first` | Managed provider priority |

#### Example input — single post URL

```json
{
    "postUrls": [
        "https://www.linkedin.com/feed/update/urn:li:activity:7468770468041502720/"
    ]
}
```

### Output (one row, abbreviated from a live provider payload)

```json
{
    "postUrl": "https://www.linkedin.com/posts/microsoft_activity-7468770468041502720-mGV1",
    "postId": "7468770468041502720",
    "postKind": "video",
    "text": "Our newest AI Diffusion Report is out...",
    "publishedAt": "2026-06-05T21:07:22.617Z",
    "authorName": "Microsoft",
    "authorUrl": "https://www.linkedin.com/company/microsoft",
    "authorFollowers": 28914925,
    "reactionCount": 379,
    "likeCount": 379,
    "commentCount": 25,
    "provider": "scrapecreators",
    "scrapedAt": "2026-08-21T00:00:00.000Z"
}
```

You can download the dataset as JSON, CSV, Excel, or HTML. Every terminal run also writes `OUTPUT` and `RUN_SUMMARY` with `outcome` (`COMPLETE` / `PARTIAL` / `VALID_EMPTY` / `INVALID_INPUT` / `UPSTREAM_FAILED` / `CONFIG_ERROR`).

### Workflow story: from a pasted post URL to an archive row

A competitive-intel analyst drops a rival's launch post URL into this Actor. The run starts, the managed provider chain fetches the public post, and one row lands with the full text, author, `reactionCount` 379, `commentCount` 25, video URL, and transcript. She exports JSON to her briefing doc, then (optionally) sends the same URL to LinkedIn Post Engagers Scraper when she needs the people who commented. Elapsed time is typically under 15 seconds; event cost is $0.008 plus the tiny start event and platform usage.

### Why AI agents and MCP clients choose this Actor

- **One required input.** `postUrls` is the only required field.
- **Predictable cost.** Only saved posts are billed at $0.008.
- **Structured output.** Stable keys plus a published dataset schema.
- **Honest outcomes.** Invalid URLs → `INVALID_INPUT`. Deleted posts → `VALID_EMPTY`. Provider outage with zero rows → `UPSTREAM_FAILED`.

> "Get the full public details and reaction counts for this LinkedIn post URL."

MCP tool name: `apify--linkedin-post-details-scraper`.

### Pricing — Pay per event + platform usage

| Event | Price | Charged when |
|---|---|---|
| Actor start | $0.00005 | Once per run |
| `post-scraped` | **$0.008** | One post row saved to the dataset |

A one-post run costs about $0.008 in events. Not-found posts are not billed. Platform usage is additional — see the live [Pricing tab](https://apify.com/khadinakbar/linkedin-post-details-scraper/pricing).

### API example

```bash
curl -X POST "https://api.apify.com/v2/acts/khadinakbar~linkedin-post-details-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"postUrls":["https://www.linkedin.com/feed/update/urn:li:activity:7468770468041502720/"]}'
```

### Integrations and chaining

- Archive then leads: this Actor → [LinkedIn Post Engagers Scraper](https://apify.com/khadinakbar/linkedin-post-engagers-scraper)
- Discover then details: [LinkedIn Posts Scraper](https://apify.com/khadinakbar/linkedin-posts-scraper) → feed URLs here

### Best results guidance

- Use a public post URL you can open while logged out.
- Prefer one URL for agent calls; batch up to 100 for archive jobs.
- Deleted or non-post URLs are reported per-URL instead of faking a row.

### Scope, data boundary & recovery

- Public, incognito-visible posts only.
- Reactions are counts, not reactor identities.
- Dual-provider fallback: ScrapeCreators `/v1/linkedin/post` then SociaVault `/v1/scrape/linkedin/post`. Owner secrets, never user API keys.

### Evidence & freshness

Field shape is verified against live ScrapeCreators and SociaVault payloads for public activity and Pulse URLs: aggregate `likeCount`/`reactionCount`, `commentCount`, author, media, optional transcript, and visible comments. Every row carries `provider` and `scrapedAt` (ISO 8601).

### Builder's note

I built this after probing both providers on a real activity URL and a Pulse article. Both return the same public post object — full text, author, media, `likeCount` as the reaction total, comments, and sometimes a transcript — and neither exposes who clicked Like or Celebrate. That is why this Actor is a get-post-details tool with honest reaction counts.

### FAQ

**Does this return who reacted?** No. Public providers return reaction counts.

**Is LinkedIn login required?** No.

**What if the post is deleted?** `VALID_EMPTY` with zero charges when every URL is missing.

### Legal

This Actor retrieves publicly available data. You are responsible for complying with LinkedIn's Terms of Service, applicable data-protection laws (GDPR/CCPA), and Apify's [Exclusion Policy](https://apify.com/terms/exclusion-policy) when using the results.

# Actor input Schema

## `postUrls` (type: `array`):

Public LinkedIn post, feed-update, or pulse article URLs to fetch. Accepts activity URLs (https://www.linkedin.com/feed/update/urn:li:activity:7468770468041502720/), posts URLs, pulse URLs, or a bare activity ID. Up to 100 URLs per run. NOT profile or company URLs — use a profile or company posts scraper for those.

## `maxPosts` (type: `integer`):

Hard cap on how many unique post URLs to fetch in one run, protecting your budget. Defaults to 100 (the absolute max). Extra URLs beyond this cap are skipped and noted in the run summary. Does not invent posts that were not supplied in postUrls.

## `includeCommentsPreview` (type: `boolean`):

When true (default), each post row includes a commentsPreview array of visible public comments (name, profile URL, text). This is a preview of comments attached to the post row, not a full thread export. Turn off to keep records smaller. For one-row-per-commenter leads use linkedin-post-engagers-scraper.

## `maxCommentsPreview` (type: `integer`):

Maximum number of visible comments to attach on each post row when includeCommentsPreview is true. Default is 10. Maximum is 50. This caps output size; it does not create comments that the public provider did not return.

## `includeTranscript` (type: `boolean`):

When true (default), include the provider transcript on video posts when LinkedIn exposes one. Text and image posts leave this field omitted. Turn off to keep records smaller. Not a substitute for a dedicated transcript actor.

## `outputMode` (type: `string`):

How much per-post data to return. 'full' (default) keeps complete text, media URL list, transcript, and comments preview. 'compact' truncates text to 500 characters and drops transcript, extra media URLs, and author image for smaller agent records. Pricing is identical in both modes.

## `providerOrder` (type: `string`):

Which managed public-data provider to try first. 'scrapecreators-first' (default) uses ScrapeCreators then falls back to SociaVault. 'sociavault-first' reverses it. The '-only' values disable fallback. Leave default unless one provider is degraded. NOT a place for API keys — keys are owner secrets.

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

How many post URLs to fetch in parallel. Default is 2. Range is 1–5. Raise only after watching provider pacing in the log. Does not increase the maxPosts cap.

## `includeRawData` (type: `boolean`):

When true, each output row also includes the unmodified provider JSON under rawPost for debugging or accessing fields not yet mapped. Defaults to false to keep records small and agent-friendly. Turn on only when you need fields the normalized schema does not expose yet.

## Actor input object example

```json
{
  "postUrls": [
    "https://www.linkedin.com/feed/update/urn:li:activity:7468770468041502720/"
  ],
  "maxPosts": 10,
  "includeCommentsPreview": true,
  "maxCommentsPreview": 10,
  "includeTranscript": true,
  "outputMode": "full",
  "providerOrder": "scrapecreators-first",
  "maxConcurrency": 2,
  "includeRawData": false
}
```

# Actor output Schema

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

Dataset items containing post text, author, media, reaction and comment counts, optional transcript, and comments preview.

## `outputRecord` (type: `string`):

Compact terminal contract with outcome, itemsPushed, and chargedEventCounts.

## `runSummary` (type: `string`):

Detailed run diagnostics including per-post results, provider status codes, and billing counters.

# 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 = {
    "postUrls": [
        "https://www.linkedin.com/feed/update/urn:li:activity:7468770468041502720/"
    ],
    "maxPosts": 10,
    "maxCommentsPreview": 10,
    "maxConcurrency": 2
};

// Run the Actor and wait for it to finish
const run = await client.actor("khadinakbar/linkedin-post-details-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 = {
    "postUrls": ["https://www.linkedin.com/feed/update/urn:li:activity:7468770468041502720/"],
    "maxPosts": 10,
    "maxCommentsPreview": 10,
    "maxConcurrency": 2,
}

# Run the Actor and wait for it to finish
run = client.actor("khadinakbar/linkedin-post-details-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "postUrls": [
    "https://www.linkedin.com/feed/update/urn:li:activity:7468770468041502720/"
  ],
  "maxPosts": 10,
  "maxCommentsPreview": 10,
  "maxConcurrency": 2
}' |
apify call khadinakbar/linkedin-post-details-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,khadinakbar/linkedin-post-details-scraper"
        }
    }
}

```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/ERWGlOBXrl1MfwNPH/builds/saAO0EbXx7ffXqAHC/openapi.json