LinkedIn Post Comments Scraper With Commenter Profile Details
Pricing
$19.99/month + usage
LinkedIn Post Comments Scraper With Commenter Profile Details
LinkedIn Post Comments Scraper With Commenter Profile Details Extract comment text, author names, profile links, timestamps, and engagement data from public posts. Perfect for audience insights, competitor research, lead generation, and campaign analysis. Turn LinkedIn conversations into data 🚀
Pricing
$19.99/month + usage
Rating
0.0
(0)
Developer
ScrapeLabs
Maintained by CommunityActor stats
0
Bookmarked
8
Total users
2
Monthly active users
18 days ago
Last modified
Share
LinkedIn Comments Scraper — Extract Comments & Commenter Profiles
LinkedIn Post Comments Scraper With Commenter Profile Details reads the comment thread under any LinkedIn post and returns two things per row: the comment itself, and the commenter's public LinkedIn profile — exact follower count, current employer, company page, location, about text and languages. Every response is typed, normalized JSON, not scraped HTML — no selectors to maintain, no login required by default. After reading this, you'll know exactly which fields ship, how the two comment engines differ, what gets billed, and how to wire the output into a lead list, a research pipeline or an agent tool.
What is LinkedIn Post Comments Scraper With Commenter Profile Details?
It's an Apify Actor that reads a public LinkedIn post's comment thread and, for every unique commenter, opens their public profile exactly once per run to attach identity and firmographic data to their comment(s). It targets LinkedIn post URLs (/feed/update/…, /posts/…, bare activity URNs or numeric IDs) and public profile pages (/in/<slug>). No LinkedIn account or login is required for the default engine — it reads what LinkedIn already serves an anonymous visitor. Supplying an optional li_at session cookie switches the comment engine to an authenticated one for deeper comment coverage; profile enrichment itself works the same either way.
- 💬 Scrape comments — text, exact UTC timestamp, reaction count, permalink
- 🧑💼 Scrape commenter profiles — follower count, current company, company page, location, about text, languages, deduplicated once per person per run
- ↩️ Optionally scrape reply threads nested under each comment (cookie path only)
- 📤 Export as JSON, CSV, Excel or XML directly from the Apify dataset
- 🧩 No proxy management, no HTML parsing on your end — every row is already typed JSON
What data does LinkedIn Post Comments Scraper With Commenter Profile Details collect?
The dataset spans three related entities pulled from the same LinkedIn post: the comment thread, the commenter's public profile, and — when a li_at cookie is supplied — the reply threads nested beneath each comment.
| Data Type | Key Fields | JSON Field Names |
|---|---|---|
| Comments | text, timestamp, reaction count, permalink | text, posted_at.timestamp, commentCreatedAt, stats.total_reactions, comment_url, comment_id |
| Commenter profiles | follower count, current employer, company page, location, about, languages | commenterFollowerCount, commenterCurrentCompany, commenterCompanyLinkedInUrl, commenterCompanyLocation, commenterCountry, commenterLocality, commenterAbout, commenterLanguages |
| Replies (cookie path only) | nested reply text, reply author, reply reactions | replies[].text, replies[].author.name, replies[].stats.total_reactions |
Need more LinkedIn data?
If your workflow needs the post itself — caption, media, share and like counts — or a target's public profile page in isolation rather than as a comment enrichment, API Empire's LinkedIn Actor collection covers those as separate, dedicated scrapers. Pair this Actor's commenter list with a standalone profile or company Actor when you need fields beyond what a comment thread exposes.
Why not build a LinkedIn comment scraper yourself?
LinkedIn doesn't publish a self-serve API that returns a post's comment thread or a member's public profile fields to third-party developers — its official developer platforms are partner-gated and built for LinkedIn-verified marketing and talent products, not for reading arbitrary public post comments. Building this yourself means reverse-engineering two separate surfaces: the anonymous public post page (an application/ld+json block cross-referenced against a server-rendered comment DOM, because neither surface alone carries every field) and, for depth beyond LinkedIn's guest ceiling, the authenticated Voyager GraphQL API, which needs a live session cookie, a CSRF token pulled out of a JSESSIONID cookie, and a query ID that LinkedIn rotates inside its bundled JavaScript and has to be rediscovered at runtime. Both surfaces return HTTP 200 login-wall pages instead of a clean 4xx when they refuse you, and both throttle with a non-standard HTTP 999 status that has to be treated as a rate limit, not a parsing failure.
This Actor already carries that logic: it walks a direct → datacenter → residential proxy ladder, detects wall pages by checking for the actual comment container rather than trusting the HTTP status, and retries throttled profile lookups on a freshly rotated exit IP at a deliberately serial concurrency of one — profile requests are the surface LinkedIn throttles hardest, and that throttle only clears below that concurrency.
Build your own scraper if you need a data shape this Actor doesn't cover, or want full control over the HTTP layer. Use this Actor if you want comments and commenter profiles as stable JSON without owning the wall-detection and throttle-recovery logic yourself.
🧑💼 Why do developers and teams scrape LinkedIn comments?
Different reasons pull people to a post's comment thread rather than the post itself — the comment thread is where the audience, not just the author, is visible.
For AI engineers and agent builders
An agent monitoring competitor announcement posts pulls text, commenterCurrentCompany and commenterFollowerCount for every comment, filters for commenterCompanyLinkedInUrl matches against a target-account list, and routes qualified rows straight into a CRM tool call — no HTML parsing step between the scrape and the LLM context window. Because commenterEnrichmentStatus reports the exact reason (ok, throttled_999, no_profile_url) whenever a profile field is null, an agent can decide to retry a lookup or move on without guessing whether the null means "missing" or "not fetched yet."
For sales teams and marketers
Sales and growth teams scrape comments on their own launch post, or a competitor's, to build a same-day outreach list: commenterName, commenterProfileUrl and commenterCurrentCompany identify who engaged, commenterFollowerCount sorts for reach, and uniqueCommentersOnly collapses someone who commented on several posts in the same batch down to a single row before the list ever reaches a CRM import.
For researchers and analysts
Researchers use commentCreatedAt — an exact UTC timestamp, not an estimate — together with the commentAge filter to study how engagement on a topic post develops over a defined window, and commenterCountry / commenterLocality to map where a conversation is geographically concentrated, using only what is already visible to a logged-out visitor rather than gated profile data.
For developers building data products
Teams building a monitoring or enrichment product schedule this Actor against a rotating list of postUrls, run it with enrichCommenters on and maxProfileLookups capped as a cost ceiling, and pipe the dataset through the Apify API into their own pipeline. sourceEngine and commenterEnrichmentStatus on every row give a product enough signal to show data confidence to its own users without exposing LinkedIn's internal error codes.
How to scrape LinkedIn post comments (step by step)
- Open LinkedIn Post Comments Scraper With Commenter Profile Details on the Apify Store and click Try for free (or Run, if it's already in your account).
- Paste one or more post URLs, URNs or bare numeric activity IDs into postUrls — this is the only input the run actually needs.
- Set Comments per post, and turn Attach commenter profile details off if you only want a plain comment export; leave the li_at cookie field empty to stay logged-out.
- Click Start and watch the run log — it reports comments read against the post's real total, and, if enrichment is on, how many unique profiles were opened versus served from the in-run cache.
- Open the Dataset tab and export as JSON, CSV, Excel or XML, or pull it through the Apify API into your own pipeline.
What to do when LinkedIn changes its structure
The Actor is maintained against LinkedIn's current markup, JSON-LD schema and Voyager query IDs, and the output field names documented in this README stay stable across maintenance updates — an existing integration keeps reading the same keys after a fix ships.
⬇️ Input
All ten parameters below are read directly from .actor/actor.json's input schema. None are marked required — the schema allows an empty run — but the Actor itself checks for at least one entry in postUrls at runtime and exits with a warning (no rows, no charge) if none is supplied.
| Parameter | Required | Type | Description | Example Value |
|---|---|---|---|---|
postUrls | No | array of strings | One or more LinkedIn post URLs, urn:li:activity:… URNs, or bare numeric activity IDs. Each post is read separately. | ["https://www.linkedin.com/feed/update/urn:li:activity:7289521182721093633/"] |
commentsPerPost | No | integer — min 1, max 500, default 10 | How many top-level comments to read from each post. Counts comments only — commenter profile lookups are extra and never charged against this number. | 25 |
enrichCommenters | No | boolean — default true | Opens each unique commenter's public profile once and attaches follower count, current company, company page, company location, country, city, about text and languages. Turn off for a plain comment export. | true |
uniqueCommentersOnly | No | boolean — default false | Keep only the first comment from each person across the whole run, for a de-duplicated people list. | false |
maxProfileLookups | No | integer — min 0, default 0 | Cap on how many unique profiles to open in one run. 0 = no cap. Rows past the cap still return the comment, with profile fields marked lookup_budget_reached. | 0 |
commentAge | No | string, select — any, 24h, week, month, 3months, 6months, year; default any | Drop comments older than the chosen window. Every comment carries an exact UTC timestamp, so this filter is precise. | "month" |
includeReplies | No | boolean — default false | Nests replies inside each comment row. Cookie path only — LinkedIn does not render reply threads to logged-out visitors. | false |
authorDetailLevel | No | string, select — short, full; default "short" | full adds the comment author's avatar and headline. Cookie path only — see the pitfall note below. | "short" |
liAtCookie | No | string, marked secret (isSecret: true) | Your LinkedIn li_at session cookie. Leave empty to run logged-out — the default, and what this Actor is built for. Supplying it switches the comment engine to the authenticated one and lifts the guest comment ceiling. | "" |
proxyConfiguration | No | object, proxy editor — prefilled { "useApifyProxy": false } | Optional starting proxy tier or custom Apify Proxy group. The Actor already escalates direct → datacenter → residential on its own and rotates the exit IP when LinkedIn throttles a request. | { "useApifyProxy": false } |
Example JSON input (every parameter shown):
Common pitfall: setting authorDetailLevel to full without also supplying liAtCookie. On the default logged-out engine this parameter has no effect — LinkedIn never exposes headline text or extra avatar detail to a guest, so the comment author's headline stays null and profile_picture is unchanged either way. full only changes anything once a li_at cookie switches the run to the authenticated Voyager engine.
⬆️ Output
Every run writes to an Apify dataset — typed, normalized JSON with a consistent field set per row type — exportable as JSON, CSV, Excel, XML or an HTML table straight from the Dataset tab. One row is produced per comment (or per unique person, with One row per person on); a failed or empty post produces one accounting row instead of a silent gap. The dataset's default view surfaces 22 of these columns as a flat table; the fields below are the complete row shape written by the Actor's row-builder, including the nested objects the view collapses.
Scraped comment — default logged-out engine
On the guest engine, is_edited and is_pinned are always null (the public page carries no such markers — never a fabricated false), headline is always null, and stats.reactions is always an empty object, regardless of authorDetailLevel.
Scraped comment — authenticated engine (liAtCookie supplied, replies included)
Replies do not generate their own charged event or dataset row — they're nested inside the parent comment's already-billed row_result row, at no extra cost.
Uncharged accounting row — failed post
errorReason takes one of: invalid_input (entry wasn't a parseable URL, URN or activity ID), http_999 (throttled after retries on rotated IPs), login_required (guest wall), empty_body / no_comment_container (200 response without a usable comment container), no_comments (post fetched, but LinkedIn served zero comments), or fetch_failed (a network-level exception). Only this row type carries isError and errorMessage — successful comment rows never include either key.
Billing note: the Actor charges exactly one Pay-Per-Event event, row_result, and only pushes it for rows built from a comment that actually loaded — the code path that pushes each comment batch is the only call site that passes charged_event_name="row_result". Every accounting row above is pushed through a separate call that omits charged_event_name entirely, so it is never billed. To pull only the billed rows out of an exported dataset, filter on the absence of isError (or isError != true); to pull only the free accounting rows, filter on isError == true.
Commenter enrichment is not a second charged event. It's bundled into the same row_result charge as the comment it's attached to. If a profile lookup fails or is throttled (commenterEnrichmentStatus anything other than ok), the comment row is still pushed and still charged — you get a partial row (comment fields populated, profile fields null) rather than a discount or a separate failed-fetch charge. commenterEnrichmentStatus is the field to check when deciding whether to re-run a lookup.
How does LinkedIn Comments Scraper compare to other LinkedIn scrapers?
| Feature | This Actor | Generic alternative |
|---|---|---|
| Output format | Nested typed JSON with an explicit null-reason status per row (commenterEnrichmentStatus) | Flat rows with a masked or approximate field, e.g. a single commenterPosition string with no null-reason field (kuldip_parmar's listing, checked on the Apify Store 2026-07-25) |
| Entity coverage per row | Comment and commenter profile bundled in one row, one profile fetch per unique person per run | Comment-only rows; enrichment beyond a static position string is not documented (kuldip_parmar's listing, checked 2026-07-25) |
| Credential requirement | Optional; runs fully logged-out by default | A li_at + JSESSIONID cookie pair is required for every run (agent-x's listing, checked 2026-07-25) |
| Input flexibility | Post URL, urn:li:activity:… URN, or bare numeric activity ID | Full post URL only, one per run (kuldip_parmar's listing documents a single postUrl string, checked 2026-07-25) |
| Anti-bot handling | Documented proxy ladder plus content-based wall detection and serial-concurrency throttle recovery (see Why not build this yourself) | Not documented in any of the three competitor listings reviewed (checked on the Apify Store 2026-07-25) |
If you're building an AI agent or RAG pipeline, the output format row is the decision-maker — parsing a flat, masked field inside an agent loop is a reliability failure mode, not a feature. Every claim about a named competitor above comes from that Actor's own live Apify Store listing as read on the date shown, not from a benchmark run.
How many comments can you scrape with this Actor?
commentsPerPost caps out at 500 per post (schema minimum 1, default 10), and the Actor re-enforces that ceiling in code even if a raw API call tries to pass something higher. There is no schema limit on how many postUrls you can supply in one run — each is fetched as a separate item. On the default logged-out engine, LinkedIn itself serves roughly the first 9–10 top-level comments to an anonymous visitor regardless of what commentsPerPost is set to; every row reports commentsAvailable against commentsTotal so you can see the real per-post coverage rather than assume it. Supplying a li_at cookie switches to the authenticated engine, which paginates in batches of 10 until commentsPerPost or the post's actual comment count is reached. maxProfileLookups is a separate, independent cap — 0 by default, meaning uncapped — on how many unique commenter profiles get opened in the run, useful as a cost ceiling when postUrls is long.
⚙️ Integrate LinkedIn Comments Scraper and automate your workflow
LinkedIn Post Comments Scraper With Commenter Profile Details works with any language or tool that can send an HTTP request — it runs on the Apify platform, so every run is reachable through the Apify API and the official Apify client libraries.
REST API integration
Works in Python, Node.js, Go, Ruby, cURL — the Apify API is language-agnostic; swap the client library and the call shape stays the same.
Automation platforms (n8n, Make, LangChain)
Apify publishes an official n8n node — add an Apify node, choose Run Actor, point it at this Actor, and map the dataset output into a downstream node such as a CRM upsert or a Slack alert.
In Make, Apify's module exposes Run Actor and get dataset items as a scenario step; feed postUrls from an upstream module (an RSS watcher, a spreadsheet row) and fan the resulting rows into a Google Sheets or Airtable module.
The langchain-apify integration exposes Apify Actors as LangChain tools (ApifyActorsTool / ApifyWrapper.call_actor), so an agent can invoke this Actor mid-chain and receive the dataset rows as documents — no manual scrape-then-parse step between the run and the agent's context.
Is it legal to scrape LinkedIn comments?
Scraping publicly accessible web data is generally lawful — in the US, hiQ Labs v. LinkedIn held that data visible without logging in falls outside the Computer Fraud and Abuse Act — but that ruling doesn't remove your own compliance obligations once you store or reuse the data. LinkedIn Post Comments Scraper With Commenter Profile Details returns only what a logged-out visitor can already see on a public post page and a public profile page: no login-gated content, no private messages, no connections-only fields. Comment text tied to a name, and profile fields like follower count, employer and location, are personal data under GDPR and CCPA, so anyone storing or reusing this output needs a lawful basis for processing it — legitimate interest is the common basis cited for public B2B outreach data, but purpose limitation and a deletion path still apply. Always review LinkedIn's own Terms of Service before scraping at scale, and consult legal counsel for commercial use cases involving bulk personal data.
❓ Frequently asked questions
Does this Actor work without a LinkedIn account?
Yes — logged-out is the default, and, per the Actor's own input description, what it's built for. No li_at cookie is required; leaving it empty just caps comment depth at what LinkedIn serves an anonymous visitor per post. Profile enrichment works identically with or without a cookie.
How often is the scraped data updated?
Every run performs a live fetch against LinkedIn at the moment it executes — comments, reaction counts and profile fields are never cached or served from a previous run. Re-run the Actor to get current data.
What happens if a post has no comments, was deleted, or is login-gated?
The Actor pushes one uncharged accounting row per failed or empty post instead of a silent gap. errorReason is set to no_comments, login_required, invalid_input, http_999 or fetch_failed depending on the exact cause, isError is true, and every comment and profile field is null.
Can I scrape private or connections-only LinkedIn content?
No. Only content visible to a logged-out visitor — or, with a cookie supplied, to that account's own session — is returned. Private posts, connections-only comments, and any contact detail LinkedIn gates behind a connection request are out of scope by design.
Does profile enrichment cost extra on top of the comment charge?
No. The Actor charges a single row_result event per comment row, and commenter profile enrichment is bundled into that same charge rather than billed separately. A failed or throttled profile lookup (commenterEnrichmentStatus other than ok) still returns and still charges the comment row, with the profile fields left null — it doesn't trigger a second charge or a discount.
Does this Actor work for AI agent workflows and LLM pipelines?
Yes — every response is typed, normalized JSON with stable field names and no HTML to parse, so it's callable as an HTTP endpoint by any agent framework (see Integrate above) and can be piped directly into an LLM context window, indexed into a vector store, or routed through an agent tool.
How does this Actor handle LinkedIn's anti-bot system?
It walks a direct → datacenter → residential proxy ladder, escalating automatically when LinkedIn returns a wall page or the non-standard HTTP 999 throttle status. Wall pages are detected by checking whether the response actually contains a comment container, not by trusting the HTTP status code alone. Profile lookups — the surface LinkedIn throttles hardest — retry on a freshly rotated exit IP at a deliberately serial concurrency of one, since that throttle only clears below that concurrency.
How does this Actor compare to other LinkedIn comment scrapers?
See the comparison table above. The main observable differences, checked on the Apify Store 2026-07-25, are that this Actor bundles commenter profile enrichment into the same row instead of requiring a second lookup, accepts a post URL, URN or bare activity ID rather than a URL only, and runs logged-out by default rather than requiring a session cookie pair.
Does this Actor return data in a format LLMs can use directly?
Yes. Typed, normalized JSON with stable field names — no HTML, no CSS selectors, no parsing step before passing a row to an LLM, indexing it into a vector store, or routing it through an agent tool.
Can I use this Actor without managing proxies?
Yes — proxy escalation (direct → datacenter → residential) runs automatically inside the Actor regardless of what you set in proxyConfiguration; the input field only lets you pin a different starting tier or supply your own proxy group.
What happens when LinkedIn changes its structure or blocks the scraper?
The Actor is maintained against LinkedIn's current markup, JSON-LD schema and Voyager query IDs, and the output field names documented in this README stay stable across maintenance updates — an existing integration keeps reading the same keys on the other end after a fix ships.
💬 Your feedback
Found a bug, or need a field this Actor doesn't return yet? Open an issue on the Actor's Issues tab in Apify Console, or message API Empire directly through the Actor's page. Reports of a broken selector or new LinkedIn wall behavior are exactly what keep this scraper's field names stable for everyone downstream.
