# LinkedIn Leads Scraper: Post Engagers, Comments & Reactions (`george.the.developer/linkedin-post-engagers-scraper`) Actor

LinkedIn leads from post engagers: scrape everyone who commented or reacted to any LinkedIn post, dedupe them, filter by job-title keywords, and get one lead per match with the engagement signal (comment text, reaction type). Lead generation without login. Filtered-out engagers are never charged.

- **URL**: https://apify.com/george.the.developer/linkedin-post-engagers-scraper.md
- **Developed by:** [George Kioko](https://apify.com/george.the.developer) (community)
- **Categories:** Lead generation, Marketing
- **Stats:** 2 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.

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 Leads Scraper: Post Engagers, Comments & Reactions

Scrape LinkedIn leads from post engagement: this LinkedIn leads scraper collects everyone
who commented on or reacted to any LinkedIn post, dedupes them, keeps only the people
matching your ideal-customer filters, and hands you one row per lead with the exact
engagement signal (their comment text, their reaction type) to personalize your outreach.
LinkedIn lead generation from real intent — everyone who engages with a post in your niche
is raising their hand about that topic.

You are charged **only for leads that match your filters**. Engagers your ICP rules filter
out, duplicates and people on your suppression list cost you nothing on the lead side.

### How it works

```
        LinkedIn post URLs (yours or any influencer's)
                          │
                          ▼
     commenters + reactions collected via proven
     engagement scrapers, run under YOUR account
                          │
                          ▼
        dedupe across posts + your suppression list
     (someone who commented AND reacted = one lead,
              the comment row wins — it has text)
                          │
                          ▼
        ICP filter on headline keywords (free data)
              │ match                │ no match
              ▼                      ▼
     charged `lead` row        dropped, never
       ($0.005 each)              charged
                          │
                          ▼
        free `post-summary` row per post
   (engagers found, unique, matched, charged)
```

No cookies, no login, no LinkedIn account of yours involved.

### What data does it extract?

**`lead`** — one per ICP-matched engager:

| Field | Example |
|---|---|
| `name` | `Jane Doe` |
| `headline` | `Head of Growth Marketing at Acme` |
| `profileUrl` | `https://www.linkedin.com/in/jane-doe` |
| `engagementType` | `comment` |
| `commentText` | `We tried exactly this last quarter — the attribution part is the hard bit.` |
| `reactionType` | `INSIGHTFUL` (reaction rows) |
| `engagedAt` | `2026-08-10T05:31:58Z` |
| `postUrl` | the post they engaged with |
| `billable` | `true` |

**`post-summary`** — one per post, always free: `engagersFound`, `uniquePeople`,
`duplicates`, `suppressed`, `icpMatched`, `charged`.

Anything that goes wrong (a post that returns nothing, an upstream failure) becomes a free
`usage` row that says exactly what happened — never a charge.

### Use cases

1. **Signal-based outbound** — instead of cold lists, mail people who just engaged with your
   topic. The `commentText` field is your personalized opening line.
2. **Competitor audience capture** — run it on a competitor's product announcements; everyone
   reacting is in-market.
3. **Influencer audience mining** — monitor the 5–10 creators your buyers follow and turn
   every new post's engagers into a deduped lead stream (pair with the Apify scheduler).
4. **Event & launch follow-up** — posts about a conference or launch collect exactly the
   people you want at the top of your funnel.

### How to use it

1. Paste one or more LinkedIn post URLs (`https://www.linkedin.com/posts/...` or
   `/feed/update/...`).
2. Set your ICP: `titleIncludeKeywords` (e.g. `founder`, `marketing`, `growth`),
   `titleExcludeKeywords` (e.g. `student`, `intern`), and optionally a `suppressionList`
   of profile URLs already in your CRM.
3. Run it. Export JSON/CSV/Excel, or wire the dataset into Clay, Instantly, HeyReach, n8n
   or your own pipeline via the API.

### Pricing — the honest version

- **$0.01 actor start** + **$0.005 per ICP-matched lead**. A 1,000-engager post with a 20%
  match rate costs about **$1.01** on the lead side.
- The raw engagement scrape runs under your account through established engagement scrapers
  (~$2 per 1,000 engagers, billed by them). That part is billed for **all** engagers scraped,
  regardless of match rate — the ICP filter saves you money on leads, not on the scrape.
  Use `maxEngagersPerPost` to cap it.
- Duplicates, suppressed profiles and non-matching engagers are **never** charged by this
  actor. Runs that produce nothing produce no lead charges.

### FAQ

**Where do emails come from?** They don't — v1 deliberately ships without email enrichment.
You get clean profile URLs plus the engagement signal; pipe them into your existing
enrichment stack (Clay, Apollo, waterfall tools). Email enrichment with bring-your-own
verification is on the roadmap.

**Is this legal?** It collects only publicly visible engagement data via established
scrapers, with no login and no cookies. What you do with the leads is subject to your local
outreach laws — that part is on you.

**Why do I also see charges from another scraper?** That's the underlying engagement scrape
running under your account (see Pricing). This actor's own charges are only the start fee
and matched leads.

**Someone engaged twice — do I pay twice?** No. Comments are processed first, reactions
second; the same person across both (or across multiple posts in one run) is one lead.

**Can I keep it running on new posts automatically?** Yes — put the actor on an Apify
schedule and keep your suppression list topped up with already-contacted profiles; only new
matches cost you anything.

**How do I scrape LinkedIn post commenters?** Paste the post URL, keep `includeComments`
on, run. Every commenter comes back with name, headline, profile URL and their comment text.

**How do I extract people who liked a LinkedIn post?** Same run — `includeReactions`
collects everyone who reacted (like, celebrate, insightful, love) with the reaction type
on each row.

**Does this work for LinkedIn lead generation without Sales Navigator?** Yes. It reads
public post engagement — no Sales Navigator, no LinkedIn account, no browser extension.

**Can I export LinkedIn post engagers to CSV or Excel?** Yes — every run's dataset exports
as CSV, Excel, JSON or XML from the Apify Console or API, ready for Clay, Instantly,
HeyReach, n8n or your CRM.

# Actor input Schema

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

Posts whose engagers (commenters + reactions) you want as leads. Paste the post URL from your browser, e.g. https://www.linkedin.com/posts/username\_slug-activity-1234567890-abcd

## `includeComments` (type: `boolean`):

Scrape people who commented on the post. Comments carry the strongest intent signal (their text is included on the lead row).

## `includeReactions` (type: `boolean`):

Scrape people who reacted (like, celebrate, insightful, ...).

## `titleIncludeKeywords` (type: `array`):

Keep only engagers whose headline contains at least one of these, e.g. founder, marketing, growth. Empty = keep all. Case-insensitive.

## `titleExcludeKeywords` (type: `array`):

Drop engagers whose headline contains any of these, e.g. student, intern, freelancer. Case-insensitive.

## `suppressionList` (type: `array`):

LinkedIn profile URLs to skip (people already in your CRM or sequences). They are never emitted and never charged.

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

Upper bound passed to the engagement scrapers. This bounds what the scrapers bill your account for the raw scrape (~$2 per 1,000 engagers).

## `maxLeadsTotal` (type: `integer`):

Hard cap on ICP-matched leads emitted and charged this run.

## `debug` (type: `boolean`):

Verbose logs for troubleshooting.

## Actor input object example

```json
{
  "postUrls": [
    "https://www.linkedin.com/posts/satyanadella_microsoft-activity-7240000000000000000-aaaa"
  ],
  "includeComments": true,
  "includeReactions": true,
  "titleIncludeKeywords": [],
  "titleExcludeKeywords": [],
  "suppressionList": [],
  "maxEngagersPerPost": 1000,
  "maxLeadsTotal": 500,
  "debug": false
}
```

# Actor output Schema

## `leads` (type: `string`):

One row per ICP-matched engager with name, headline, profile URL and the engagement signal (comment text or reaction type), plus one free post-summary row per post with the funnel counts. recordType discriminates the row kind.

# 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/posts/satyanadella_microsoft-activity-7240000000000000000-aaaa"
    ],
    "titleIncludeKeywords": [],
    "titleExcludeKeywords": [],
    "suppressionList": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("george.the.developer/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/posts/satyanadella_microsoft-activity-7240000000000000000-aaaa"],
    "titleIncludeKeywords": [],
    "titleExcludeKeywords": [],
    "suppressionList": [],
}

# Run the Actor and wait for it to finish
run = client.actor("george.the.developer/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/posts/satyanadella_microsoft-activity-7240000000000000000-aaaa"
  ],
  "titleIncludeKeywords": [],
  "titleExcludeKeywords": [],
  "suppressionList": []
}' |
apify call george.the.developer/linkedin-post-engagers-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,george.the.developer/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/zb7LwJmthpmZCuIVe/builds/ReSZlJ03PZnKRBOMM/openapi.json