# Linkedin Post Reactions Scraper (`api-ninja/linkedin-post-reactions-scraper`) Actor

Collect normalized LinkedIn reactor profiles from public post URLs

- **URL**: https://apify.com/api-ninja/linkedin-post-reactions-scraper.md
- **Developed by:** [API ninja](https://apify.com/api-ninja) (community)
- **Stats:** 17 total users, 17 monthly users, 96.3% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
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?

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

### What does LinkedIn Post Reactions Scraper do?

**LinkedIn Post Reactions Scraper extracts the people who reacted to public [LinkedIn](https://www.linkedin.com/) posts.** Add one or more post URLs, choose the reaction types you need, and receive a clean dataset with reactor names, headlines, profile photos, profile links, connection degrees, and reactions.

You do not need cookies, a LinkedIn account, or scraping code. The Actor resolves each post URL, paginates through its reactions, and keeps the complete source response in `rawData` for advanced use. Run it on Apify to gain API access, scheduling, monitoring, cloud storage, and integrations with tools such as Google Sheets, Make, Zapier, and webhooks.

Main features:

- 🔗 Process one or many LinkedIn post URLs in one run
- 🎭 Collect Like, Celebrate, Love, Insightful, Support, and Funny reactions
- ♾️ Set a result limit or collect every available reactor
- 📄 Automatically paginate each reaction type until it is exhausted
- 👤 Receive normalized profile data ready for analysis or CRM workflows
- 📦 Export results as JSON, CSV, Excel, HTML, XML, and other formats
- 🧰 Preserve the complete original record in `rawData`
- 🔁 Retry temporary or malformed upstream responses automatically

### Why use LinkedIn Post Reactions Scraper?

People who react to a post have already shown interest in its author, company, topic, or offer. This makes LinkedIn reaction data useful for:

- **Lead research** — discover professionals engaging with relevant industry content.
- **Audience analysis** — understand who responds to your posts or a competitor's posts.
- **Community building** — find active members of a professional niche.
- **Campaign research** — compare engagement across announcements and content themes.
- **Influencer discovery** — identify professionals interacting with important voices.
- **Recruiting research** — explore people interested in a company, role, or technology.
- **Data enrichment** — send names, headlines, profile URLs, and reactions into your workflow.

Instead of manually opening reaction dialogs and copying profiles, you receive structured data that can be filtered, downloaded, scheduled, or retrieved through the Apify API.

### How to scrape LinkedIn post reactions

1. Open the Actor in Apify Console and click **Try for free**.
2. Copy one or more public LinkedIn post URLs.
3. Paste the URLs into **LinkedIn post URLs**, one URL per row.
4. Select the reaction types you want. All six types are enabled by default.
5. Enter **Reactors per post**, or enable **Parse all reactors**.
6. Click **Start** and wait for the run to finish.
7. Open the **Output** tab to browse, filter, or export the results.

#### How reaction pagination and limits work

`maxReactors` is one shared limit for each post, not a separate limit for each reaction type. Reaction types are processed in the selected order, and each type is paginated until the API returns an empty list before the Actor moves to the next type.

For example, with a limit of 1,000 and all reaction types selected:

1. The Actor collects every available Like reactor.
2. If Like produces 900 records and is then exhausted, 100 result slots remain.
3. The Actor begins Celebrate and stops as soon as the total reaches 1,000.
4. Later reaction types are not requested because the post limit has been reached.

This means a common reaction such as Like can fill the whole limit. Select only the reaction categories you need, or enable **Parse all reactors**, when you require complete coverage of every type.

### Input

The Input tab contains four settings:

| Field           | Type    | Description                                                                       |
| --------------- | ------- | --------------------------------------------------------------------------------- |
| `postUrls`      | Array   | Public LinkedIn post URLs to process.                                             |
| `reactionTypes` | Array   | Reaction categories to collect. All types are selected by default.                |
| `maxReactors`   | Integer | Maximum total records per post across all selected types.                         |
| `parseAll`      | Boolean | Ignore the limit and paginate every selected type until it returns an empty list. |

Example input:

```json
{
    "postUrls": [
        {
            "url": "https://www.linkedin.com/posts/example_company-update-activity-1234567890"
        }
    ],
    "reactionTypes": ["LIKE", "PRAISE", "EMPATHY"],
    "maxReactors": 500,
    "parseAll": false
}
```

The internal reaction codes correspond to these LinkedIn labels:

| Input value     | LinkedIn reaction |
| --------------- | ----------------- |
| `LIKE`          | Like              |
| `PRAISE`        | Celebrate         |
| `EMPATHY`       | Love              |
| `INTEREST`      | Insightful        |
| `APPRECIATION`  | Support           |
| `ENTERTAINMENT` | Funny             |

### Output

The Actor saves one normalized dataset item per reactor. The main table focuses on useful profile and post information; technical identifiers and the complete original object remain available in dataset records and API responses.

Example output:

```json
{
    "reactorName": "Yasir Abbas",
    "reactorHeadline": "Helping MSSPs build AI-native security platforms",
    "reactorConnectionDegree": "3rd+",
    "reactorProfileUrl": "https://www.linkedin.com/in/ACoAAAExample",
    "reactorImageUrl": "https://media.licdn.com/dms/image/example/profile-displayphoto.jpg",
    "reactorProfileId": "ACoAAAExample",
    "reactorUrn": "urn:li:fsd_profile:ACoAAAExample",
    "reactionType": "LIKE",
    "reactionUrn": "urn:li:fsd_reaction:example",
    "postUrl": "https://www.linkedin.com/posts/example_company-update-activity-1234567890",
    "postId": "urn:li:activity:1234567890",
    "followingState": null,
    "timeOffset": null,
    "legacyReactionUrn": "urn:li:fs_reaction:example",
    "legacyActorUrn": "urn:li:fs_miniProfile:ACoAAAExample",
    "rawData": {
        "actorUrn": "urn:li:fsd_profile:ACoAAAExample",
        "reactionType": "LIKE",
        "reactorLockup": {
            "title": {
                "text": "Yasir Abbas"
            }
        }
    }
}
```

You can download the dataset in various formats such as JSON, HTML, CSV, or Excel. You can also retrieve it programmatically through the [Apify Dataset API](https://docs.apify.com/api/v2#/reference/datasets).

### Data table

| Field                        | Description                                                  |
| ---------------------------- | ------------------------------------------------------------ |
| `reactorName`                | Reactor's displayed name.                                    |
| `reactorHeadline`            | Professional headline or profile description.                |
| `reactorConnectionDegree`    | Connection label such as `1st`, `2nd`, or `3rd+`.            |
| `reactorProfileUrl`          | Clickable LinkedIn profile URL.                              |
| `reactorImageUrl`            | Highest-resolution available profile photo.                  |
| `reactorProfileId`           | LinkedIn profile identifier extracted from the profile URN.  |
| `reactionType`               | Like, Celebrate, Love, Insightful, Support, or Funny code.   |
| `postUrl`                    | Original input post URL.                                     |
| `postId`                     | Resolved LinkedIn activity URN used to retrieve reactors.    |
| `reactorUrn` / `reactionUrn` | Technical LinkedIn entity identifiers.                       |
| `rawData`                    | Complete unmodified reactor object from the source response. |

Technical fields are kept out of the main overview so it stays readable, but remain available in downloads and API results.

### How much does it cost to scrape LinkedIn post reactions?

The exact run price depends on the Actor pricing shown in the **Pricing** tab and on platform usage. Cost mainly grows with:

- The number of post URLs
- The number and order of selected reaction types
- The reactor limit or use of **Parse all reactors**
- The number of pagination requests and temporary retries
- Dataset storage and data transfer

The most reliable estimate is to run one representative public post with a limit of 100, review the run cost, and scale that estimate to your workload. Posts with fewer available reactors generally need fewer requests.

Apify offers a [Free plan](https://apify.com/pricing) with monthly usage credits and no credit card required, which is suitable for testing and small runs. Limits and prices can change, so consult the Actor's **Pricing** tab and Apify's pricing page for current amounts before a large job.

### Tips and advanced options

#### Collect a specific reaction category

Because types are processed sequentially, Like may consume the whole limit on popular posts. Select only Celebrate, Love, Insightful, Support, or Funny when that category is your target. For complete coverage, enable **Parse all reactors**.

#### Start small before scraping a viral post

Use one URL and 100 reactors to verify the output. Increase the limit after confirming that the post is accessible and the fields meet your needs. Parsing all reactions on a viral post can take much longer.

#### Schedule recurring audience research

Use [Apify schedules](https://docs.apify.com/platform/schedules) to run the Actor regularly. Connect the resulting dataset to a webhook, Make, Zapier, Google Sheets, or your own data pipeline.

#### Access results through the API

Developers can start runs and retrieve datasets with the Apify API, JavaScript client, Python client, or CLI. A typical API request uses the same JSON input shown above. Find your API token under **Settings → Integrations** in Apify Console and never expose it in client-side code or public repositories.

### Related LinkedIn Actors

Combine this Actor with other LinkedIn data tools to build a broader research workflow:

- **LinkedIn Company Posts Scraper** — collect company content before analyzing its reactors.
- **LinkedIn Profile Posts Scraper** — collect posts published by a selected profile.
- **LinkedIn Jobs Scraper** — extract structured LinkedIn job listings.

### FAQ, disclaimers, and support

#### Can I scrape multiple LinkedIn posts at once?

Yes. Add multiple URLs to `postUrls`. The result limit is applied independently to each post.

#### Why did the Actor return only one reaction type?

Reaction types are processed sequentially. If the first selected type fills the shared per-post limit, the Actor stops without querying later types. Select a specific type, increase the limit, or use **Parse all reactors** when you need other categories.

#### Why are some profile fields missing?

LinkedIn does not expose every field for every reactor. Private, restricted, deleted, or incomplete profiles may have missing names, headlines, photos, connection labels, or URLs. The Actor returns the fields made available by the source.

#### Can I use the results through an API?

Yes. Every run and dataset is accessible through the [Apify API](https://docs.apify.com/api/v2). You can also trigger runs from JavaScript, Python, the Apify CLI, Make, Zapier, webhooks, and other integrations.

#### Is it legal to scrape LinkedIn reactions?

Scraping publicly available data may be lawful in some circumstances, but requirements vary by jurisdiction and use case. You are responsible for complying with LinkedIn's terms, privacy laws, data-protection rules, and other applicable regulations. Do not use the Actor to collect restricted data, spam people, discriminate, or violate individual rights. When in doubt, obtain professional legal advice.

#### What are the known limitations?

- Only data available for public, accessible posts can be returned.
- Deleted, private, restricted, or unsupported post URLs may fail.
- Upstream LinkedIn or data-provider changes can temporarily affect availability.
- A reactor profile may contain only partial information.
- Very large posts require more requests and take longer to finish.

#### Where can I get help?

If a run fails, open its log and confirm that the post is public and still available. Share the run ID and a reproducible example through the Actor's **Issues** tab; do not publish credentials or private data. Custom LinkedIn data extraction and workflow integrations are also available on request.

# Actor input Schema

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

Add one or more public LinkedIn post URLs. Each URL is resolved to its internal post ID before reactors are collected.

## `reactionTypes` (type: `array`):

Choose which LinkedIn reaction categories to collect. All reaction types are selected by default.

## `maxReactors` (type: `integer`):

Maximum total reactor records to save for each post across all selected reaction types. Ignored when Parse all reactors is enabled.

## `parseAll` (type: `boolean`):

Keep requesting pages for every post and selected reaction type until the API returns an empty reactors list.

## Actor input object example

```json
{
  "postUrls": [
    "https://www.linkedin.com/posts/google_last-month-grow-with-google-took-our-make-activity-7503150276024045568-_Qu8?utm_source=social_share_send&utm_medium=member_desktop_web&rcm=ACoAAB1kQ2MBs0WTeYdJt4DMlyQvQKI034yxsnA"
  ],
  "reactionTypes": [
    "LIKE",
    "PRAISE",
    "EMPATHY",
    "INTEREST",
    "APPRECIATION",
    "ENTERTAINMENT"
  ],
  "maxReactors": 100,
  "parseAll": false
}
```

# Actor output Schema

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

No description

# 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/google_last-month-grow-with-google-took-our-make-activity-7503150276024045568-_Qu8?utm_source=social_share_send&utm_medium=member_desktop_web&rcm=ACoAAB1kQ2MBs0WTeYdJt4DMlyQvQKI034yxsnA"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("api-ninja/linkedin-post-reactions-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/google_last-month-grow-with-google-took-our-make-activity-7503150276024045568-_Qu8?utm_source=social_share_send&utm_medium=member_desktop_web&rcm=ACoAAB1kQ2MBs0WTeYdJt4DMlyQvQKI034yxsnA"] }

# Run the Actor and wait for it to finish
run = client.actor("api-ninja/linkedin-post-reactions-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/google_last-month-grow-with-google-took-our-make-activity-7503150276024045568-_Qu8?utm_source=social_share_send&utm_medium=member_desktop_web&rcm=ACoAAB1kQ2MBs0WTeYdJt4DMlyQvQKI034yxsnA"
  ]
}' |
apify call api-ninja/linkedin-post-reactions-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,api-ninja/linkedin-post-reactions-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/JMDa3sLBmdlGCJS2e/builds/TkZo2w8qVKMAU6Hi0/openapi.json