# LinkedIn Reactions Scraper (`coregent/linkedin-reactions-scraper`) Actor Extract the people and organizations who reacted to public LinkedIn posts. Get reaction type, name, headline, profile URL, LinkedIn IDs and source-post context. Filter by Like, Celebrate, Support, Love, Insightful or Funny. No LinkedIn login or cookies required. - **URL**: https://apify.com/coregent/linkedin-reactions-scraper.md - **Developed by:** [Delowar Munna](https://apify.com/coregent) (community) - **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks - **User rating**: No ratings yet ## Pricing $1.00 / 1,000 reaction results 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/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 Reactions Scraper ![LinkedIn Reactions Scraper](https://raw.githubusercontent.com/coregentdevspace/linkedin-reactions-scraper-assets/main/thumbnail-linkedin-reactions-scraper.png) Extract the **people and organizations who reacted to public LinkedIn posts**: everyone who liked, celebrated, supported, loved, found insightful or laughed at a post. Paste one or more post URLs and get **one clean row per reaction** with the reaction type, the reactor's name, headline, profile URL, LinkedIn ID and the source post. Export as JSON, CSV or Excel. Reactions are the biggest engagement audience on LinkedIn: many more people react than comment. Use them for warm-lead discovery, competitor audience research, event and launch follow-up, executive audience analysis and CRM enrichment. **No LinkedIn login, cookies or browser extension required.** ### What you get Each reaction row (`rowType: "reaction"`): | Field | Description | | --------------------------------------------- | ---------------------------------------------------------------------------------------------------- | | `reactionType`, `reactionLabel` | Normalised type (`LIKE`, `PRAISE`, `EMPATHY`, `APPRECIATION`, `INTEREST`, `ENTERTAINMENT`) and LinkedIn's label | | `reactor.entityType` | `PERSON`, `ORGANIZATION` or `UNKNOWN` | | `reactor.name`, `reactor.headline` | Reactor name and headline (for companies, the line LinkedIn shows under the name) | | `reactor.profileUrl` | Profile URL (people) or company page URL (organizations) | | `reactor.linkedinId` | LinkedIn member / company ID - stable, ideal for CRM matching | | `reactor.publicIdentifier` | Vanity slug (`jane-doe`) when LinkedIn exposes one - often `null` for people, see the FAQ | | `reactor.imageUrl`, `reactor.companyPageUrl` | Profile photo or logo; company page URL for organization reactors | | `reactionUrn` | Stable reaction identifier | | `reactionIndex` | Position in LinkedIn's reaction list for that post (source order, **not** a ranking) | | `post` | `postId`, `postUrn`, `postUrl` of the source post | | `input`, `inputIndex`, `fetchedAt` | What you supplied, its position in your list, and the fetch time | Plus one free **post summary** row per input post (`rowType: "post_summary"`): its `status`, `coverageStatus`, LinkedIn's reported reaction total (and the per-type breakdown when LinkedIn shows one) next to what was extracted, and a `reason` whenever something stopped early. These rows are never charged. **Never estimated.** A value LinkedIn does not expose for a reactor is `null` - not an empty string and not a guess. #### Reaction types | Value | LinkedIn label | | --------------- | -------------- | | `LIKE` | Like | | `PRAISE` | Celebrate | | `EMPATHY` | Love | | `APPRECIATION` | Support | | `INTEREST` | Insightful | | `ENTERTAINMENT` | Funny | ### How it works 1. Each post URL or URN is normalised (tracking parameters and comment links are reduced to the post, `lnkd.in` short links are followed) and duplicates are removed. 2. The actor reads the post's **public page** to confirm it exists and to record LinkedIn's reported reaction total. Posts with no reactions finish here, free. 3. Reactors are collected page by page from the post's reaction list, through a provider running on our own infrastructure - never through your account. 4. Each reaction is normalised, deduplicated and saved as soon as its page arrives, so the first rows appear within seconds. ### Input examples **One post, default limit (500 reactions):** ```json { "postUrls": ["https://www.linkedin.com/feed/update/urn:li:activity:7514290662138068992/"], "maxReactorsPerPost": 500 } ``` **Only Insightful, Love and Celebrate:** ```json { "postUrls": ["https://www.linkedin.com/posts/example_activity-7408723748973056001-AbCd"], "reactionTypes": ["INTEREST", "EMPATHY", "PRAISE"], "maxReactorsPerPost": 1000 } ``` **Every reaction on a post:** ```json { "postUrls": ["urn:li:activity:7514290662138068992"], "parseAll": true } ``` **Multi-post lead research, one row per person across posts:** ```json { "postUrls": [ "https://www.linkedin.com/posts/example1_activity-7408723748973056001-AbCd", "https://www.linkedin.com/posts/example2_activity-7408723748973056002-EfGh", "urn:li:ugcPost:7408723748973056003" ], "reactionTypes": ["INTEREST", "PRAISE"], "maxReactorsPerPost": 500, "deduplicateAcrossPosts": true } ``` ### Output One row per unique reaction, plus one free summary row per input post. Unavailable values are `null`, never guessed. Every reaction row has the same columns, so CSV and Excel exports stay stable. The dataset has three tabs: **Reactions**, **Reactor identity** and **Post status**. ![LinkedIn Reactions Scraper: Reactions table view](https://raw.githubusercontent.com/coregentdevspace/linkedin-reactions-scraper-assets/main/linkedin-reactions-scraper-output-reactions-table-view.png) The records below come from a real run with the default input. It returned 500 reactions (the default per-post limit) from a post that LinkedIn reports at 7,424 reactions. Long LinkedIn image URLs are shortened with `…`. ```json { "postUrls": ["https://www.linkedin.com/feed/update/urn:li:activity:7514290662138068992/"], "maxReactorsPerPost": 500 } ``` #### Full record: an Insightful reaction ```json { "rowType": "reaction", "post": { "postId": "7514290662138068992", "postUrn": "urn:li:activity:7514290662138068992", "postUrl": "https://www.linkedin.com/feed/update/urn:li:activity:7514290662138068992/" }, "reactionUrn": "urn:li:fsd_reaction:(urn:li:fsd_profile:ACoAAF715mcB4mYzmf6e6NL9JfpTY2aaoQKlxjw,urn:li:activity:7514290662138068992,0)", "reactionType": "INTEREST", "reactionLabel": "Insightful", "reactionIndex": 138, "reactor": { "entityType": "PERSON", "name": "Wize Stax", "headline": "Online publication helping businesses identify operational leaks and choose the right software systems so they save time, protect revenue, and run more smoothly | Founder of WIZESTAX", "profileUrl": "https://www.linkedin.com/in/ACoAAF715mcB4mYzmf6e6NL9JfpTY2aaoQKlxjw/", "publicIdentifier": null, "linkedinId": "ACoAAF715mcB4mYzmf6e6NL9JfpTY2aaoQKlxjw", "imageUrl": "https://media.licdn.com/dms/image/v2/D4E03AQFNxNcb3nvVMg/profile-displayphoto-crop_800_800/…", "companyPageUrl": null }, "input": "https://www.linkedin.com/feed/update/urn:li:activity:7514290662138068992/", "inputIndex": 0, "fetchedAt": "2026-10-16T15:44:20.944Z" } ``` #### Reactions tab: the same reaction ```json { "reactor": { "imageUrl": "https://media.licdn.com/dms/image/v2/D4E03AQFNxNcb3nvVMg/profile-displayphoto-crop_800_800/…", "name": "Wize Stax", "headline": "Online publication helping businesses identify operational leaks and choose the right software systems so they save time, protect revenue, and run more smoothly | Founder of WIZESTAX", "entityType": "PERSON", "profileUrl": "https://www.linkedin.com/in/ACoAAF715mcB4mYzmf6e6NL9JfpTY2aaoQKlxjw/" }, "reactionLabel": "Insightful", "post": { "postUrl": "https://www.linkedin.com/feed/update/urn:li:activity:7514290662138068992/" }, "reactionIndex": 138, "rowType": "reaction" } ``` #### Reactor identity tab: IDs for CRM matching ```json { "reactor": { "name": "Wize Stax", "entityType": "PERSON", "linkedinId": "ACoAAF715mcB4mYzmf6e6NL9JfpTY2aaoQKlxjw", "publicIdentifier": null, "profileUrl": "https://www.linkedin.com/in/ACoAAF715mcB4mYzmf6e6NL9JfpTY2aaoQKlxjw/", "companyPageUrl": null }, "reactionType": "INTEREST", "reactionUrn": "urn:li:fsd_reaction:(urn:li:fsd_profile:ACoAAF715mcB4mYzmf6e6NL9JfpTY2aaoQKlxjw,urn:li:activity:7514290662138068992,0)", "post": { "postId": "7514290662138068992", "postUrn": "urn:li:activity:7514290662138068992" }, "input": "https://www.linkedin.com/feed/update/urn:li:activity:7514290662138068992/", "fetchedAt": "2026-10-16T15:44:20.944Z" } ``` Organization reactors have `"entityType": "ORGANIZATION"`, a numeric `linkedinId`, `publicIdentifier` set to the company slug, and `companyPageUrl` filled in. Their `headline` is the line LinkedIn shows under the name, such as `"694 followers"`. #### Post status tab: the post's summary row (free) ```json { "input": "https://www.linkedin.com/feed/update/urn:li:activity:7514290662138068992/", "post": { "postUrl": "https://www.linkedin.com/feed/update/urn:li:activity:7514290662138068992/" }, "status": "SUCCESS", "coverageStatus": "LIMIT_REACHED", "reportedReactionsTotal": 7424, "reactionsSaved": 500, "reportedByType": null, "savedByType": { "LIKE": 431, "PRAISE": 6, "EMPATHY": 48, "APPRECIATION": 9, "INTEREST": 5, "ENTERTAINMENT": 1 }, "reason": null, "rowType": "post_summary" } ``` `reportedByType` holds LinkedIn's own count for each reaction type when the public post page shows one, and is `null` otherwise. `LIMIT_REACHED` means the run stopped at the 500-reaction limit; turn on **Scrape all reactions** to collect the rest. ### Post status and coverage Every input post gets a summary row. `status` says what happened: | Status | Meaning | | -------------------------- | ------------------------------------------------------------------------------------------ | | `SUCCESS` | Reactions collected as requested | | `PARTIAL_RESULT` | Some reactions collected, then stopped early - the `reason` says why | | `NO_REACTIONS` | The post has no reactions (of the selected types / reactor kinds) | | `INVALID_POST_URL` | Not a supported post URL (profile, company or article URL, malformed value) | | `POST_RESOLUTION_FAILED` | A short link or URL could not be resolved to a post | | `POST_NOT_FOUND` | The post does not exist or was deleted | | `POST_UNAVAILABLE` | The post is not publicly accessible | | `RATE_LIMITED`, `BLOCKED`, `TEMPORARY_LINKEDIN_ERROR`, `PROVIDER_ERROR` | Temporary problems - the post is added to `RETRY_INPUT` | | `SKIPPED_SPENDING_LIMIT` | Not processed because your run's spending limit was reached | `coverageStatus` says how complete a post is: `FULL_SELECTED_TYPES` (every available reaction of the selected types), `LIMIT_REACHED` (stopped at your per-post limit), `PARTIAL_RESULT`, `NO_REACTIONS` or `POST_UNAVAILABLE`. The **Run summary** (key-value store record `RUN_SUMMARY`) has run totals, the per-type breakdown, field availability rates and duplicates skipped. The record `RETRY_INPUT` holds a ready-to-run input with only the posts worth retrying. ### FAQ **Which LinkedIn post URL formats work?** - `https://www.linkedin.com/feed/update/urn:li:activity:` - `https://www.linkedin.com/posts/_-activity--` - `https://www.linkedin.com/posts/_-ugcPost--` - `urn:li:activity:`, `urn:li:share:`, `urn:li:ugcPost:` - `https://lnkd.in/` short links - Comment links (`?commentUrn=...`) and country domains (`uk.linkedin.com`) are reduced to the post. **Do I need a LinkedIn login or cookies?** No. You never supply credentials, cookies or a browser extension, and nothing runs through your LinkedIn account. **Can I select only Insightful, Love, etc.?** Yes - set **Reaction types**. Leave it empty for all six. LinkedIn returns a post's reactions as one mixed list, so filtering happens as the list is read. On a post where your chosen type is rare (say Funny on a post with thousands of Likes), the actor stops after a run of pages with no match and marks the post `PARTIAL_RESULT`, rather than reading the whole list for a handful of rows. **Can I scrape multiple posts?** Yes, up to 1,000 per run. Posts are processed in parallel and each gets its own summary row. One failing post never fails the run. **Can I scrape all reactors?** Turn on **Scrape all reactions**. Safety caps on pages and runtime per post still apply; a post they stop is marked `PARTIAL_RESULT`. **How does the result limit work?** **Max reactions per post** caps the reaction rows per post across all selected types together. It does not limit the number of posts. **Can one reaction type use up the whole limit?** Yes. The limit is shared, and reactions come in LinkedIn's list order, so a common type such as Like can fill it before rarer types appear. To get rarer types, select them explicitly or raise the limit. **Are names, headlines and profile URLs included?** Yes, wherever LinkedIn shows them. Every reactor also has a `linkedinId`. LinkedIn's reaction list usually links to people by member ID (`/in/ACoAA...`) rather than their vanity URL. Those links open the right profile, but `publicIdentifier` is then `null`. To get the vanity slug, run the profile URL through a profile scraper. **Are companies and organizations supported?** Yes. Organization reactors have `reactor.entityType = "ORGANIZATION"` and a `companyPageUrl`. Turn off **Include organizations** or **Include people** to keep only one kind. **Is reaction order meaningful?** No. `reactionIndex` is the position in LinkedIn's reaction list, not a measure of importance. **Why can the extracted count differ from LinkedIn's visible total?** The total moves as people react and un-react between LinkedIn's count and the extraction. Your type, reactor-kind and limit settings also reduce it, and very large posts may hit the per-post safety caps. Each post's summary row shows LinkedIn's reported total next to the extracted count, so the gap is always visible. **How does pricing work?** Pay per result: you pay for each **unique reaction row** saved to the dataset. Post lookups, pagination, retries, duplicates, filtered-out reactions, failed or reaction-less posts, post summary rows and the run summary are free. This README deliberately quotes no figures - see the **Pricing** tab for current rates, which can differ by Apify plan. Runs stop cleanly at your spending limit. **Can I schedule runs?** Yes. Use Apify Schedules to re-run the same posts, for example daily during a launch week. **Can I use the API or MCP?** Yes. The actor works through the Apify API, the client SDKs, webhooks, integrations (Zapier, Make, n8n) and the Apify MCP server. **How do I enrich reactors afterwards?** Feed the `reactor.profileUrl` values into a LinkedIn profile scraper for full profiles and companies, then a work-email finder. Companion actors: - [LinkedIn Post Comments Scraper](https://apify.com/coregent/linkedin-post-comments-scraper) - the comment side of the same posts - [LinkedIn People Search & Profile Scraper](https://apify.com/coregent/linkedin-people-search-profile-scraper) - full reactor profiles - [LinkedIn Email Scraper](https://apify.com/coregent/linkedin-email-scraper) - work emails for reactors ### Limitations - Only **public** posts. Private, members-only and deleted posts get a `POST_UNAVAILABLE` / `POST_NOT_FOUND` summary row, free. - Reaction types are filtered client-side (see the FAQ), so very narrow selections on very large posts can end `PARTIAL_RESULT`. - LinkedIn's reaction list may not expose every reactor on very large posts. Each post's summary row shows how far extraction got against LinkedIn's total. - Connection degree and full profiles are not included - this actor returns who reacted, not their full profile. #### 🚦 Proxy policy The proxy is used only for the public LinkedIn post pages the actor reads for post checks and reaction totals. **Apify Datacenter** proxy (default) or **no proxy** both work. **Apify Residential proxy is not supported.** The actor fails at startup if `apifyProxyGroups` includes `RESIDENTIAL`. Reason: in pay-per-event actors, residential bandwidth is billed to the developer, not the run user, so a single bandwidth-heavy run could cost more than it earns. If you genuinely need residential routing, supply your own residential provider via the proxy editor's **Custom proxy URLs** field - that traffic goes through your provider, not Apify, and is unaffected: ``` http://user:pass@proxy.iproyal.com:12321 http://user:pass@proxy.brightdata.com:22225 http://user:pass@proxy.oxylabs.io:7777 ``` ### Compliance and privacy This is an unofficial tool, not affiliated with or endorsed by LinkedIn. It collects only public post engagement data. Reaction data changes over time. Names, headlines and profile links are still personal data, so you are responsible for processing them lawfully (for example under GDPR or CCPA) and for respecting LinkedIn's terms. Which reactors are visible depends on what LinkedIn exposes publicly. The actor does not access private content, automate accounts, send messages or infer sensitive attributes. # Actor input Schema ## `postUrls` (type: `array`): Public LinkedIn posts to collect reactors from, one per line. Supported forms: - `https://www.linkedin.com/feed/update/urn:li:activity:` - `https://www.linkedin.com/posts/_-activity--` - `https://www.linkedin.com/posts/_-ugcPost--` - `urn:li:activity:`, `urn:li:share:`, `urn:li:ugcPost:` - `https://lnkd.in/` short links Tracking parameters are stripped, comment links are normalised to their parent post and duplicates are removed (first one wins). Profile, company and article URLs are reported as `INVALID_POST_URL` and never charged. Up to 1,000 posts per run. ## `reactionTypes` (type: `array`): Only return these reaction types. Leave empty for all six. Filtering is applied to LinkedIn's full reaction list, so selecting only a rare type (for example Funny on a post dominated by Likes) can stop early - the post is then marked `PARTIAL_RESULT` in its summary row. ## `maxReactorsPerPost` (type: `integer`): Maximum number of reaction rows returned per post, across all selected reaction types together. Common types such as Like can fill the limit before rarer ones appear. Ignored when "Scrape all reactions" is on. ## `parseAll` (type: `boolean`): Ignore the per-post limit and page through every available reaction of the selected types. Safety caps on pages and runtime per post still apply, and a post they stop is marked `PARTIAL_RESULT`. ## `includePersonReactors` (type: `boolean`): Return reactions from people (LinkedIn members). ## `includeOrganizationReactors` (type: `boolean`): Return reactions made by company or organization pages (`reactor.entityType = ORGANIZATION`). ## `includeProfileImage` (type: `boolean`): Return the reactor's profile photo or company logo URL (LinkedIn image links expire after a while). ## `deduplicateAcrossPosts` (type: `boolean`): Return each person or organization only once per run, on the first post where they appear. Off by default, because reacting to several of your posts is useful engagement signal. ## `includeRawData` (type: `boolean`): Add a `raw` field with the unprocessed source record for each reaction. Useful for debugging; makes the dataset larger. ## `maxConcurrency` (type: `integer`): How many posts are processed at the same time. Pages of one post are always fetched in order. ## `proxyConfiguration` (type: `object`): Proxy for the public LinkedIn post pages the actor reads for post checks and reaction totals. Apify Datacenter proxy (default) or no proxy both work. Apify Residential proxy is not supported - supply your own residential provider via Custom proxy URLs if you need one. ## Actor input object example ```json { "postUrls": [ "https://www.linkedin.com/feed/update/urn:li:activity:7514290662138068992/" ], "reactionTypes": [], "maxReactorsPerPost": 500, "parseAll": false, "includePersonReactors": true, "includeOrganizationReactors": true, "includeProfileImage": true, "deduplicateAcrossPosts": false, "includeRawData": false, "maxConcurrency": 5, "proxyConfiguration": { "useApifyProxy": true } } ``` # Actor output Schema ## `overview` (type: `string`): One row per reaction: reaction type, reactor name, headline, profile URL and source post. ## `reactors` (type: `string`): LinkedIn IDs, public identifiers and profile / company URLs per reaction. ## `posts` (type: `string`): Per-post status, coverage and LinkedIn's reported reaction totals vs extracted. ## `runSummary` (type: `string`): Run metrics: posts by status, reaction-type breakdown, field availability, duplicates and upstream economics. # 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 '' with your token const client = new ApifyClient({ token: '', }); // Prepare Actor input const input = { "postUrls": [ "https://www.linkedin.com/feed/update/urn:li:activity:7514290662138068992/" ], "reactionTypes": [], "maxReactorsPerPost": 500, "proxyConfiguration": { "useApifyProxy": true } }; // Run the Actor and wait for it to finish const run = await client.actor("coregent/linkedin-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 '' with your token. client = ApifyClient("") # Prepare the Actor input run_input = { "postUrls": ["https://www.linkedin.com/feed/update/urn:li:activity:7514290662138068992/"], "reactionTypes": [], "maxReactorsPerPost": 500, "proxyConfiguration": { "useApifyProxy": True }, } # Run the Actor and wait for it to finish run = client.actor("coregent/linkedin-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/feed/update/urn:li:activity:7514290662138068992/" ], "reactionTypes": [], "maxReactorsPerPost": 500, "proxyConfiguration": { "useApifyProxy": true } }' | apify call coregent/linkedin-reactions-scraper --silent --output-dataset ``` ## MCP server setup ```json { "mcpServers": { "apify": { "type": "http", "url": "https://mcp.apify.com/?tools=fetch-actor-details,coregent/linkedin-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 ` 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/CnnmVasgoBd7FGhwx/builds/SWWbfhtmvVksrFrA3/openapi.json