# LinkedIn Post Engagers Email Finder (`khadinakbar/linkedin-post-engagers-email-finder`) Actor

Find work emails for LinkedIn post commenters. Use when a post URL should become outreach-ready leads. For profile-URL-only lookup use linkedin-email-finder. One row per commenter: name, profile, company, MX-validated email. $0.008/engager + $0.04/email found.

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

## Pricing

from $40.00 / 1,000 work email 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/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 Engagers Email Finder

Turn a public LinkedIn post URL into outreach-ready commenter leads. Paste one or more post URLs and get one dataset row per visible commenter: name, profile URL, comment text, current company, and an MX-validated work email when one can be derived. Unmatched commenters still return as rows with an honest `emailStatus` so you can tell a completed empty lookup from a provider outage. No LinkedIn login or cookies.

Designed for B2B sales, recruiting, and ABM teams who already have a high-intent post and need emails for the people who actually commented. This is the email-finding companion to [LinkedIn Post Engagers Scraper](https://apify.com/khadinakbar/linkedin-post-engagers-scraper), which stops at names and comments. When you already have `/in/` URLs instead of a post, start with [LinkedIn Email Finder](https://apify.com/khadinakbar/linkedin-email-finder).

### What you get

| Output | What it answers |
|---|---|
| `engagerName` + `engagerProfileUrl` | **Who** commented on the post |
| `commentText` + `postUrl` | **What they said** and which post they engaged with |
| `currentCompanyName` + `companyDomain` | **Where they work** from the public profile |
| `email` + `emailStatus` + `emailConfidence` | **How to reach them**, or why no email was returned |
| `OUTPUT` / `RUN_SUMMARY` outcomes | **Provenance** — complete, empty, invalid input, or upstream outage |

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

- **Sales development reps** — turn comments on a competitor or industry post into a sequenced outreach list.
- **Recruiters** — contact people who already showed interest in a hiring or industry conversation.
- **ABM / demand-gen teams** — build a warm account list from a thought-leadership post instead of a cold directory.
- **AI agents** — one tool call with `postUrls` returns structured commenter rows plus optional emails, so the agent can enrich, skip, or route without guessing.

### Best fit for this Actor

- Strongest starting condition: a public LinkedIn post URL with visible comments.
- Useful output: one row per commenter, billed `$0.008` for the engager and `$0.04` only when an email is returned.
- Use this Actor when the starting object is a LinkedIn post URL and the job is commenter emails.
- Liker and reactor identities are outside this Actor's contract on public no-login data. For names and comments only, start with [LinkedIn Post Engagers Scraper](https://apify.com/khadinakbar/linkedin-post-engagers-scraper). When you already have profile URLs, then use [LinkedIn Email Finder](https://apify.com/khadinakbar/linkedin-email-finder).

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `postUrls` | array (required) | 1 example post | Up to 50 LinkedIn post, feed-update, or pulse URLs |
| `maxEngagersPerPost` | integer | 10 | Cap on commenters saved and billed per post |
| `includeUnverified` | boolean | true | Return MX-valid pattern emails when SMTP cannot confirm |
| `providerOrder` | enum | `scrapecreators-first` | Public-data provider priority; fallback fires automatically |
| `maxConcurrency` | integer | 2 | Posts processed in parallel (1–5) |

#### Quick start input

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

That input selects a single public post and one commenter so the run stays inside the five-minute quality window and still returns a real row.

#### Example input — a few posts, larger commenter cap

```json
{
    "postUrls": [
        "https://www.linkedin.com/feed/update/urn:li:activity:7468770468041502720/",
        "https://www.linkedin.com/posts/microsoft_activity-7468770468041502720_"
    ],
    "maxEngagersPerPost": 10,
    "includeUnverified": true,
    "providerOrder": "scrapecreators-first",
    "maxConcurrency": 2
}
```

Duplicate post URLs are deduplicated automatically. Profile or company URLs are skipped as invalid input.

### What data you receive

One dataset item is one commenter. Email-found rows carry a work address; commenter-only rows document that the lookup finished without a billable email.

```json
{
    "engagerName": "Jane Doe",
    "engagerProfileUrl": "https://www.linkedin.com/in/example",
    "engagementType": "commenter",
    "commentText": "Great insights on AI adoption.",
    "postUrl": "https://www.linkedin.com/feed/update/urn:li:activity:7468770468041502720/",
    "currentCompanyName": "Acme",
    "companyDomain": "acme.com",
    "email": "jane.doe@acme.com",
    "emailStatus": "mx_valid_unverified",
    "emailConfidence": 54,
    "emailSource": "derived",
    "emailFound": true,
    "smtpVerified": false,
    "provider": "scrapecreators",
    "scrapedAt": "2026-08-21T00:00:00.000Z"
}
```

Commenter without an email:

```json
{
    "engagerName": "Alex Rivera",
    "engagerProfileUrl": "https://www.linkedin.com/in/example-two",
    "engagementType": "commenter",
    "postUrl": "https://www.linkedin.com/feed/update/urn:li:activity:7468770468041502720/",
    "emailStatus": "company_domain_unresolved",
    "emailFound": false,
    "provider": "scrapecreators",
    "scrapedAt": "2026-08-21T00:00:00.000Z"
}
```

Every terminal run also writes `OUTPUT` and `RUN_SUMMARY` with a named `outcome`, per-post results, provider diagnostics, and billing counters.

### Workflow story: from a viral post to a sequenced outreach list

An SDR sees a competitor CEO post that attracted a wave of comments from directors at target accounts. She pastes the post URL here with `maxEngagersPerPost` at 20. The Actor pulls the public commenters, resolves each profile's current company website domain, and derives an MX-validated work email. Fourteen rows come back with `emailFound=true`; six remain commenters with `company_domain_unresolved` or `no_profile`. She filters `emailFound=true`, drops the comment text into her first-touch snippet, and skips paying `$0.04` on the six rows that had no email. Event cost is 20 × `$0.008` plus 14 × `$0.04`.

### Use through the API

```bash
curl -X POST "https://api.apify.com/v2/acts/khadinakbar~linkedin-post-engagers-email-finder/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "postUrls": ["https://www.linkedin.com/feed/update/urn:li:activity:7468770468041502720/"],
    "maxEngagersPerPost": 1,
    "includeUnverified": 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`. The same Actor is exposed through Apify MCP as `apify--linkedin-post-engagers-email-finder`.

### Use with AI agents through Apify MCP

> Given this LinkedIn post URL, extract the people who commented and find a work email for each one. Return name, profile URL, comment, company, and email. Keep only dataset rows where emailFound is true. Cap the run at 10 commenters.

Inspect the terminal `outcome`, read the dataset, keep `engagerProfileUrl` as the source identifier, and treat `emailStatus` as provenance rather than a deliverability promise. Connect through [Apify MCP](https://mcp.apify.com).

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

Then read results with `get-actor-output`, keep `emailFound=true` rows for outreach, and pass remaining profile URLs to [LinkedIn Email Finder](https://apify.com/khadinakbar/linkedin-email-finder) only if you want a second pass from the `/in/` URL.

### Pricing

This Actor uses Pay per event plus Apify platform usage. Open the live Pricing tab for current event details, and use Apify's run cost controls to keep the workflow aligned with your budget.

| Event | Price | Charged when |
|---|---|---|
| Actor start | $0.00005 | Once per run (scaled by memory) |
| `engager-found` | $0.008 | One commenter row saved |
| `email-found` | $0.04 | Additional, only when an email is returned |

Invalid input and empty posts are not billed as `engager-found`. Commenters without an email are billed only for `engager-found`.

| Run | Commenters | Emails found | Event cost (approx.) |
|---|---|---|---|
| 1 post, 1 row with email found | 1 | 1 | ~$0.048 |
| 1 post, 10 rows, 6 emails | 10 | 6 | ~$0.32 |
| 3 posts, 20 rows, 12 emails | 20 | 12 | ~$0.64 |

A bounded 1-row quality run costs about $0.048 in events. A 10-row list with 6 emails found costs about $0.32 in events.

Your run log prints the exact cost cap before any charge fires. Platform usage is billed on top at Apify's rates — the live [Pricing tab](https://apify.com/khadinakbar/linkedin-post-engagers-email-finder/pricing) is the current source of truth.

### Best results

- Start with a post that already has public comments. Empty posts finish `VALID_EMPTY` with no engager charges.
- Keep `maxEngagersPerPost` at 10 unless you need a larger list; each commenter can trigger a profile and company lookup.
- Leave `includeUnverified` on. Apify blocks outbound SMTP port 25, so most real-world emails are `mx_valid_unverified` rather than mailbox-confirmed.
- Pair commenter-only rows with [LinkedIn Email Finder](https://apify.com/khadinakbar/linkedin-email-finder) when you later obtain a company domain by hand.
- Validate returned addresses with [Email Address Validator](https://apify.com/khadinakbar/email-address-validator) before a large send.

### Limits, reliability, and troubleshooting

- Public no-login data exposes **commenters**, not liker or reactor identities. Reaction counts still appear on the post.
- Emails are **derived** from name + company domain (or copied from a public about section). LinkedIn does not publish a private inbox through these providers.
- SMTP mailbox confirmation almost never fires on Apify. Treat `mx_valid_unverified` as MX-valid, not as a deliverability guarantee.
- Provider HTTP 429 or 5xx with zero rows maps to `UPSTREAM_FAILED`. Retry later rather than converting that into a hollow success.
- Provide a real post URL, not a profile or company page. Invalid shapes finish `INVALID_INPUT` with zero charges.

### Builder's note

I built this after shipping LinkedIn Post Engagers Scraper and LinkedIn Email Finder as separate tools and watching users chain them by hand. In my testing of ScrapeCreators and SociaVault, commenter identities are public and liker identities are not. I learned that neither provider returns LinkedIn emails, so the working path is the same derive-and-MX-validate engine already proven on LinkedIn Email Finder, plus a public-about regex for the rare profile that already shows an address. That is why this Actor bills the commenter row separately from the email, and why `emailStatus` stays in the dataset even when `email` is empty.

### Responsible use

Use this Actor on public LinkedIn posts you are authorized to process for legitimate sales, recruiting, research, or verification. It reads **public post comments and public LinkedIn profile pages only**. It does not log into LinkedIn, does not use your cookies, and is not a private people-graph or data-broker dump. Follow GDPR, CCPA, CAN-SPAM, LinkedIn's terms, and any local law that applies to your outreach. Honor opt-out and do-not-contact requests.

This tool is provided for lawful public-data collection. You are responsible for how you use the output.

# Actor input Schema

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

LinkedIn post URLs whose commenters should be turned into email leads. Accepts activity URLs (https://www.linkedin.com/feed/update/urn:li:activity:7468770468041502720/), posts URLs, and pulse article URLs. Up to 50 URLs per run. NOT profile, company, or search URLs — use linkedin-email-finder for profile URLs.

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

Maximum commenter rows to save and attempt email finding for, per post URL. Default 10 keeps the quality sample and typical sales list inside a predictable budget. This does not invent likers or extra comments; it only caps the public commenters the provider already returned.

## `includeUnverified` (type: `boolean`):

When true (default), the highest-probability work-email pattern is returned after MX validation even if outbound SMTP (port 25) is blocked on Apify. When false, only mailbox-confirmed valid emails or emails published on the public profile are written to the email field. Leave true unless you need SMTP-only output.

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

Which public-data provider to try first for each post and profile. Both providers return the same commenter shape; the fallback fires automatically when the primary fails or returns no commenters 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; 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": 1,
  "includeUnverified": true,
  "providerOrder": "scrapecreators-first",
  "maxConcurrency": 2
}
```

# Actor output Schema

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

Dataset items containing commenter name, profile URL, comment text, company, and MX-validated work email when found.

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

Run summary including outcome, engagersSaved, emailsFound, provider diagnostics, 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": 1,
    "includeUnverified": true,
    "maxConcurrency": 2
};

// Run the Actor and wait for it to finish
const run = await client.actor("khadinakbar/linkedin-post-engagers-email-finder").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": 1,
    "includeUnverified": True,
    "maxConcurrency": 2,
}

# Run the Actor and wait for it to finish
run = client.actor("khadinakbar/linkedin-post-engagers-email-finder").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": 1,
  "includeUnverified": true,
  "maxConcurrency": 2
}' |
apify call khadinakbar/linkedin-post-engagers-email-finder --silent --output-dataset

```

## MCP server setup

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

```

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/QSim4hNHxKhl9HDZY/builds/Nv4qKCiDmeDhp0Kqs/openapi.json