# LinkedIn Post Reactor Identity & Reaction Type Scraper (`vexaloom-labs/linkedin-post-reactor-identity-and-reaction-type`) Actor

Scrape the reactors on LinkedIn posts with name, headline, profile URL, and the specific reaction type they left, filterable by reaction type and date using your own LinkedIn session.

- **URL**: https://apify.com/vexaloom-labs/linkedin-post-reactor-identity-and-reaction-type.md
- **Developed by:** [vexaloom-labs](https://apify.com/vexaloom-labs) (community)
- **Categories:** Social media, Lead generation, Automation
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.49 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## LinkedIn Post Reaction Counts & Type Breakdown Scraper

Get a clear picture of how people reacted to any public LinkedIn post — the total reaction count and the exact number of likes, celebrates, loves, support, insightful, funny and super-like reactions. No cookie, login or LinkedIn account is needed.

Paste one or more public post links (or bare post IDs). The actor reads each post's public page and returns one summary row per post. It is built for engagement analysis, content research and campaign reporting where aggregate reaction data is enough.

### What you get

For each public post:

- `postId`, `postUrn` and `postUrl` — the resolved post identity
- `inputPostUrl` — the exact URL or ID you supplied
- `reactionsTotal` — total reactions on the post
- `reactionCounts` — exact counts for `like`, `celebrate`, `love`, `support`, `insightful`, `funny` and `superLike` when LinkedIn's guest reaction layout is available
- `reactionTypesPresent` — the reaction types that actually appear on the post
- `commentsTotal` — comment count when the page exposes it
- `repostsTotal` — repost count when the guest layout exposes it
- `scrapedAt` — when the summary was collected

Reactor names, headlines, profile URLs and per-person reaction types are **not returned**. LinkedIn only shows the reactor list to signed-in members, so this actor deliberately sticks to the public aggregate data instead of asking for your account or cookie.

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `postUrls` | array of strings | – | Public LinkedIn post URLs or bare numeric IDs. Accepts `/posts/` links, `/feed/update/urn:li:...` links, embed links, `lnkd.in` short links and country subdomains. Required, 1–100 items. |
| `reactionTypeFilter` | array of strings | `[]` | Optional post filter: return only posts where at least one selected reaction type has a count above zero. Counts in the row still cover every type. Values: `like`, `celebrate`, `love`, `support`, `insightful`, `funny`, `superLike`. |
| `emitNoResultsMarker` | boolean | `true` | When no public post can be resolved, add one `_status: noResults` marker row instead of returning an empty dataset. |

### Examples

Summarize one post:

```json
{
  "postUrls": [
    "https://www.linkedin.com/posts/microsoft_this-month-the-microsoft-atlanta-team-in-activity-7516505833061474305-T6ou"
  ]
}
```

Summarize several posts and keep only posts with insightful reactions:

```json
{
  "postUrls": [
    "https://www.linkedin.com/feed/update/urn:li:activity:7468769852581806080/",
    "https://www.linkedin.com/feed/update/urn:li:ugcPost:7513744817718218752/",
    "7470420615506575360"
  ],
  "reactionTypeFilter": ["insightful"]
}
```

### How it works

1. The actor resolves each input to the real post URN and verifies the page belongs to that post before using any count. Wrapper IDs are common: a URL can contain an `activity`, `share` or `ugcPost` id that differs from the main post, so the actor verifies the page and keeps the resolved identity. Reaction counts shown on related feed cards are ignored.
2. It reads the public post page. LinkedIn's logged-out page shows the total reaction count on every post.
3. When LinkedIn serves its guest reaction layout, the page also carries exact counts for all reaction types. The actor validates that the type counts add up to the visible total before using them.
4. If that layout is unavailable, the actor returns the total and the reaction types shown on the page, and omits `reactionCounts` rather than inventing numbers.

### Why `reactionCounts` can be missing

LinkedIn sometimes serves a simpler public page that only includes the total count. That is a source limitation, not an error. The row still contains `reactionsTotal`, `reactionTypesPresent` and the post identity. The run status message tells you whether per-type counts were available.

### FAQ

**Do I need a LinkedIn cookie or account?**
No. The actor never asks for a cookie, login or proxy. It reads only public post pages.

**Can I get the names of the people who reacted?**
No. The reactor list is visible only to signed-in LinkedIn members, so reactor names, headlines, profile URLs and per-person reaction types are not part of this actor.

**Which reaction types are counted?**
Like, celebrate, love, support, insightful, funny and super like. The output uses the keys `like`, `celebrate`, `love`, `support`, `insightful`, `funny` and `superLike`.

**Why are some reaction counts zero?**
A zero is a real value when LinkedIn exposes the requested post's own reaction group. On rare feed-style pages where the requested post shows no reaction count at all, LinkedIn can surface a related post's count first; in that case the row can carry a related post's identity and count. Treat zero-engagement or very new posts with caution. If the guest layout is unavailable for a normal post, the whole `reactionCounts` object is omitted instead of showing zeros.

**How many posts can I process in one run?**
Up to 100 per run. Add more URLs or IDs to `postUrls`; duplicates are removed automatically.

**Does it work with company posts, personal posts, shares and ugcPost links?**
Yes. The actor accepts activity, share and ugcPost references, `/posts/` links, embed links, bare IDs, short links and country subdomains, and resolves wrapper IDs to the main post.

**Does the actor return comment authors or comment text?**
No. It returns the post's comment count when available, but not comments or commenters. Those are separate, login-gated surfaces.

**Is this affiliated with LinkedIn?**
No. This is an independent third-party tool that reads public post pages. It is not affiliated with, endorsed by or sponsored by LinkedIn. You are responsible for complying with LinkedIn's terms and applicable data-protection law when using the output.

### Data source and limits

The actor reads public LinkedIn post pages without credentials. It supports public posts only; member-only or deleted posts are skipped with a status message. Reaction counts reflect the data LinkedIn exposes when the run executes and can change over time. Reactor identities are login-gated and are intentionally out of scope.

Known limitation: on some feed-style pages the requested post has no reaction module, and LinkedIn renders a related post's count first. The actor can then attribute that related post's count (and numeric post ID) to the requested post. This affects a small number of zero-engagement or very new posts.

# Actor input Schema

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

Public LinkedIn posts to summarize. Accepts /posts/ links (activity, share or ugcPost), /feed/update/urn:li:... links, embed links, bare numeric IDs, lnkd.in short links and country subdomains.

## `reactionTypeFilter` (type: `array`):

Optional post filter. A post is returned only when at least one selected reaction type has a count above zero. Every returned row still contains all available counts.

## `emitNoResultsMarker` (type: `boolean`):

When no public post can be resolved, add one marker row instead of failing with an empty dataset.

## Actor input object example

```json
{
  "postUrls": [
    "https://www.linkedin.com/posts/microsoft_this-month-the-microsoft-atlanta-team-in-activity-7516505833061474305-T6ou"
  ],
  "reactionTypeFilter": [],
  "emitNoResultsMarker": true
}
```

# Actor output Schema

## `reactions` (type: `string`):

Dataset containing one reaction summary per resolved public post.

# 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/microsoft_this-month-the-microsoft-atlanta-team-in-activity-7516505833061474305-T6ou"
    ],
    "reactionTypeFilter": [],
    "emitNoResultsMarker": true
};

// Run the Actor and wait for it to finish
const run = await client.actor("vexaloom-labs/linkedin-post-reactor-identity-and-reaction-type").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/microsoft_this-month-the-microsoft-atlanta-team-in-activity-7516505833061474305-T6ou"],
    "reactionTypeFilter": [],
    "emitNoResultsMarker": True,
}

# Run the Actor and wait for it to finish
run = client.actor("vexaloom-labs/linkedin-post-reactor-identity-and-reaction-type").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/microsoft_this-month-the-microsoft-atlanta-team-in-activity-7516505833061474305-T6ou"
  ],
  "reactionTypeFilter": [],
  "emitNoResultsMarker": true
}' |
apify call vexaloom-labs/linkedin-post-reactor-identity-and-reaction-type --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,vexaloom-labs/linkedin-post-reactor-identity-and-reaction-type"
        }
    }
}
```

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/NvggfHSdNu8V6APDG/builds/I1DCTvghEDiSJaPvW/openapi.json