# LinkedIn Post Engagers Scraper (`khadinakbar/linkedin-post-engagers-scraper`) Actor

Extract LinkedIn post engagers from public post URLs: commenter names, profile URLs, comment text, post reaction and comment stats, with optional engager enrichment (current company, location, followers). Provider-backed via ScrapeCreators and SociaVault; no user cookies required.

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

## Pricing

from $6.00 / 1,000 engager founds

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/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 Post Engagers Scraper

Extract the people engaging with public LinkedIn posts. Paste one or more LinkedIn post URLs and get one clean dataset row per engager: name, profile URL, their comment, and the post's reaction and comment stats. Turn on enrichment and every engager row also carries their current company, company URL, location, follower count, and an about preview — lead-list-ready without any LinkedIn login or cookies.

Designed for B2B outreach teams, recruiters, and account-based marketers who need prospecting lists from people who visibly interact with competitor, industry, or thought-leadership posts. Commenters are the highest-intent engagers on LinkedIn: they wrote something, which makes them warmer leads than passive likers. Pair it with [LinkedIn Email Finder](https://apify.com/khadinakbar/linkedin-email-finder) to turn the `engagerProfileUrl` values into verified outreach contacts.

### When to use this Actor

- Build prospect lists from people commenting on competitor or industry posts
- Find decision-makers engaging with your target accounts' announcements
- Recruit candidates who participate in professional conversations
- Feed CRM or AI outreach workflows with engagement context — the comment text and post preview power personalization

### Best fit & sibling routing

- For the posts themselves (full text, media, author stats), start with [LinkedIn Posts Scraper](https://apify.com/khadinakbar/linkedin-posts-scraper), then pass its post URLs to this Actor for the people layer.
- For full comment threads with replies as the primary entity, use [LinkedIn Post Comments & Engagements Scraper](https://apify.com/khadinakbar/linkedin-post-comments-engagements-scraper) — this Actor is optimized for people-rows, while that one goes deep on thread structure.
- For reaction count summaries per post, use [LinkedIn Post Reactions Scraper](https://apify.com/khadinakbar/linkedin-post-reactions-scraper) when post-level reaction metrics are the goal.
- Reactor (liker) identity lists sit outside this Actor's scope: public no-login data exposes commenters with identity and reactions as counts, so this Actor ships an honest commenters contract built entirely on public data.

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `postUrls` | array (required) | 1 example URL | Up to 100 LinkedIn post/activity/pulse URLs per run |
| `maxEngagersPerPost` | integer | 100 | Cap engager rows saved per post (output + cost cap) |
| `enrichProfiles` | boolean | false | Add company, location, followers, about to each engager ($0.012/row extra) |
| `providerOrder` | enum | `scrapecreators-first` | Data provider priority; fallback fires automatically |
| `maxConcurrency` | integer | 2 | Posts processed in parallel (1–5) |

#### Example input

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

### Output

One dataset row per engager. Fields:

| Field | Always present | Description |
|---|---|---|
| `engagerName` | ✅ | Public name of the engager |
| `engagerProfileUrl` | when exposed | Public LinkedIn profile URL |
| `engagementType` | ✅ | `commenter` |
| `commentText` | when exposed | Full comment text |
| `commentPosition` | ✅ | Position within the visible comment list |
| `postUrl`, `postId` | ✅ | Source post attribution |
| `postAuthorName`, `postAuthorUrl`, `postPublishedAt` | when exposed | Post author context |
| `postReactionCount`, `postCommentCount` | when exposed | Post-level engagement stats |
| `postTextPreview` | when exposed | First 280 chars of the post (outreach context) |
| `enriched` | ✅ | Whether profile enrichment succeeded |
| `currentCompanyName`, `currentCompanyUrl`, `engagerLocation`, `followerCount`, `aboutPreview` | enriched rows | Public profile enrichment fields |
| `provider`, `scrapedAt` | ✅ | Provenance and freshness |

#### Example output row (real field shape from a live run)

```json
{
    "engagerName": "Bhaskar Gangipamula",
    "engagerProfileUrl": "https://www.linkedin.com/in/bhaskargangi",
    "engagementType": "commenter",
    "commentText": "Looking at AI adoption county by county is where the real story is...",
    "commentPosition": 1,
    "postUrl": "https://www.linkedin.com/feed/update/urn:li:activity:7468770468041502720/",
    "postId": "7468770468041502720",
    "postAuthorName": "Microsoft",
    "postReactionCount": 379,
    "postCommentCount": 25,
    "postTextPreview": "Our newest AI Diffusion Report is out...",
    "enriched": true,
    "currentCompanyName": "Quadrant Technologies",
    "currentCompanyUrl": "https://www.linkedin.com/company/quadranttechnologies-1",
    "engagerLocation": "Greater Seattle Area",
    "followerCount": 14662,
    "aboutPreview": "Currently building Quadrant Technologies, a globally recognized IT services company...",
    "provider": "scrapecreators",
    "enrichmentProvider": "scrapecreators",
    "scrapedAt": "2026-08-17T00:00:00.000Z"
}
```

Every terminal run also writes `OUTPUT` and `RUN_SUMMARY` records with `outcome` (`COMPLETE` / `PARTIAL` / `VALID_EMPTY` / `INVALID_INPUT` / `UPSTREAM_FAILED` / `CONFIG_ERROR`), per-post results, provider diagnostics, and billing counters.

### Workflow story: from a competitor's post to a prospect list

A growth lead at a BI vendor starts with a competitor's launch post URL. She pastes it into this Actor with `enrichProfiles: true`. The run starts, each post URL is fetched through the provider chain, and one row per commenter lands in the dataset. She then filters rows by `currentCompanyName` against her 50-account target list — eight commenters work at three target accounts. Next she exports the dataset to Sheets, then passes the warmest `engagerProfileUrl` values to LinkedIn Email Finder to verify contact details, and feeds the final list into her sequencer. Total elapsed time: under five minutes, total event cost under $0.20.

### Pricing — Pay per event + platform usage

| Event | Price | Charged when |
|---|---|---|
| Actor start | $0.00005 | Once per run (scaled by memory) |
| `engager-found` | $0.006 | One engager row saved to the dataset |
| `engager-enriched` | $0.012 | Additional, only when a row was successfully enriched |

That is $6 per 1,000 engager rows, or $18 per 1,000 rows when enriched. A typical single post with ~9 visible commenters costs about $0.054 (unenriched) or $0.16 (enriched); a 10-post enriched batch tops out near $1.60 for 100 engager rows. Your run log prints the exact cost cap before any charge fires, and only saved rows are billed. Platform usage (compute/proxy) is billed on top at Apify's rates — the live [Pricing tab](https://apify.com/khadinakbar/linkedin-post-engagers-scraper/pricing) is the current source of truth for effective prices on your plan.

### API example

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

Results land in the run's default dataset: `https://api.apify.com/v2/datasets/{datasetId}/items?clean=true`. Paginate large batches with `offset`/`limit` on that endpoint.

### AI-agent / MCP usage

This Actor is MCP-ready: one tool call with `postUrls` returns structured engager rows.

> "Given these LinkedIn post URLs, list everyone who commented, with their profile URL, current company, and location, so I can build an outreach list."

Agents should expect: dataset rows via `get-actor-output` with clean pagination; `outcome`/`RUN_SUMMARY` readback for scope and provenance (`provider`, `scrapedAt` on every row); unavailable or deleted posts reported per-URL in diagnostics; empty comment sections as a clean `VALID_EMPTY` outcome with zero fabricated rows; and a printed cost cap before any charge fires.

### Best results guidance

- Pick posts with 20–200 comments: enough signal, still fully visible to public data.
- For outreach lists, run with `enrichProfiles: true` and filter rows by `currentCompanyName` against your target-account list.
- Deduplicate across runs by `engagerProfileUrl`; a person engaging with several of your posts is your warmest lead.
- Batch up to 100 post URLs per run; keep `maxConcurrency` at 2 unless you raise it after watching provider pacing in the log.

### Scope, data boundary & recovery

- **Commenters are the engager type with identity in public data.** Reactions are returned as post-level counts; reactor identities sit behind LinkedIn login and stay outside this Actor's public-data scope.
- **Top visible comments per post.** The data provider returns roughly the top 10 visible commenters per post; busier posts are capped at what public data exposes (flagged per post in the run summary).
- **Public-page enrichment only.** Company, location, followers, and about come from public profile pages; emails and private network data stay outside the contract.
- **Per-URL resilience.** Provider hiccups are retried with backoff, then routed to the second provider; a run with at least one working URL finishes as `PARTIAL` with diagnostics, a run where every URL is unavailable ends `UPSTREAM_FAILED`, and only saved rows are billed.
- **Input validation.** Missing or non-post URLs exit fast as `INVALID_INPUT` with an actionable message.

### Evidence & freshness

- Field shape verified against live provider payloads for real posts during the August 2026 build: commenter rows with full identity, post reaction counts, and enrichment fields (current company, location, follower count, about) all confirmed on real profiles.
- Competitor positioning checked against the live Apify Store API during my 2026 niche research: the engagers niche is one of the highest-demand LinkedIn categories on the Store, dominated by raw unenriched row dumps — this Actor differentiates on enriched, high-intent commenter leads and an honest public-data-only scope.
- Every row carries `provider` and `scrapedAt`; release acceptance evidence for the shipped build is recorded in the actor's private build audit before publication.

### Builder's note

I built this after probing both ScrapeCreators and SociaVault live against real posts: I found both expose commenter identities and reaction counts, while reactor identities stay behind login — so I shipped an honest commenters contract with dual-provider fallback. In my testing, raw commenter rows (name + URL) answered "who", but outreach teams kept asking "where do they work" — that is why enrichment (company, location, followers) is a first-class option rather than an afterthought.

### Integrations

Rows are plain JSON — pipe the dataset into Google Sheets, Airtable, a CRM, or an email-finder step. Natural chain: this Actor, then pass `engagerProfileUrl` values to [LinkedIn Email Finder](https://apify.com/khadinakbar/linkedin-email-finder) (profile URL → verified email) to complete the contact step, and monitor new engagement by scheduling re-runs of the same post URLs weekly.

### 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`):

LinkedIn post URLs to extract engagers from. Accepts activity URLs (https://www.linkedin.com/feed/update/urn:li:activity:7468770468041502720/), posts URLs (https://www.linkedin.com/posts/microsoft\_activity-7468770468041502720\_...), and pulse article URLs. Up to 100 URLs per run. NOT profile or company URLs — use a profile or company posts scraper for those.

## `maxEngagersPerPost` (type: `integer`):

Maximum number of engager rows to save per post URL. Default 100 saves every engager the data provider exposes (typically the top ~10 visible commenters per post). This does not create data that is not publicly exposed; it only caps output volume and cost.

## `enrichProfiles` (type: `boolean`):

When enabled, each engager's public LinkedIn profile is fetched to add current company, company URL, location, follower count, and an about preview to every row. Enrichment costs an additional $0.012 per enriched engager on top of the $0.006 engager charge. Leave disabled when you only need names, profile URLs, and comments.

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

Which public-data provider to try first for each post. Both providers return the same engager shape; the fallback provider is used automatically when the primary fails or returns no engagers for a post that has comments. Keep the default unless you have a reason to prefer SociaVault.

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

How many post URLs to process in parallel. Default 2 balances speed against provider rate limits. Raise to 5 for large batches of post URLs; lower to 1 if you see provider rate-limit errors in the run log.

## Actor input object example

```json
{
  "postUrls": [
    "https://www.linkedin.com/feed/update/urn:li:activity:7468770468041502720/"
  ],
  "maxEngagersPerPost": 100,
  "enrichProfiles": false,
  "providerOrder": "scrapecreators-first",
  "maxConcurrency": 2
}
```

# Actor output Schema

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

Dataset items containing engager name, profile URL, comment text, post engagement stats, and optional company/location enrichment.

## `summary` (type: `string`):

Run summary including outcome, engagersSaved, enrichedEngagers, provider status codes, per-post outcomes, warnings, and billing counters.

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

Machine-readable RUN\_SUMMARY record mirroring OUTPUT for integrations that read RUN\_SUMMARY directly.

# 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/"
    ],
    "maxEngagersPerPost": 100,
    "enrichProfiles": false,
    "maxConcurrency": 2
};

// Run the Actor and wait for it to finish
const run = await client.actor("khadinakbar/linkedin-post-engagers-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/"],
    "maxEngagersPerPost": 100,
    "enrichProfiles": False,
    "maxConcurrency": 2,
}

# Run the Actor and wait for it to finish
run = client.actor("khadinakbar/linkedin-post-engagers-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/"
  ],
  "maxEngagersPerPost": 100,
  "enrichProfiles": false,
  "maxConcurrency": 2
}' |
apify call khadinakbar/linkedin-post-engagers-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,khadinakbar/linkedin-post-engagers-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/a12iVMaYGtQ8Mam7O/builds/YFsHs7iutHMX2wafo/openapi.json