# LinkedIn Comments Scraper - \[✅ No Cookies] (`khadinakbar/linkedin-comments-scraper`) Actor

Extract public LinkedIn post comments and replies with structured author, text, reaction, reply, provider, and run summary fields. No LinkedIn cookies required.

- **URL**: https://apify.com/khadinakbar/linkedin-comments-scraper.md
- **Developed by:** [Khadin Akbar](https://apify.com/khadinakbar) (community)
- **Categories:** Social media, Lead generation, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $10.00 / 1,000 comment scrapeds

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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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 Comments Scraper - No Cookies

Extract public comments and optional replies from LinkedIn post URLs, activity IDs, or LinkedIn URNs. The Actor is designed for AI agents, social listening workflows, lead discovery, content research, and engagement analysis.

This Actor uses managed public-data providers. It does not ask users for LinkedIn cookies, account credentials, or browser sessions.

### What it extracts

- Parent post URL, ID, text, author name, and publish time when available
- Top-level comments
- Optional nested replies
- Comment/reply author name, headline, profile URL, profile image, and author URN when available
- Comment text, timestamp, URL, reaction counts, reply counts, and reaction breakdowns when available
- Run summaries in `OUTPUT` and `RUN_SUMMARY` for automation and canary checks

### Input

Paste LinkedIn post URLs into `startUrls`, or use `postUrls` for line-separated URLs, numeric activity IDs, or `urn:li:activity` values.

```json
{
  "startUrls": [
    {
      "url": "https://www.linkedin.com/feed/update/urn:li:activity:7312345678901234567/"
    }
  ],
  "maxComments": 100,
  "includeReplies": true,
  "maxRepliesPerComment": 25,
  "metadataOnly": false
}
````

### Output

Each saved comment or reply is one dataset row.

```json
{
  "recordType": "comment",
  "postUrl": "https://www.linkedin.com/feed/update/urn:li:activity:7312345678901234567/",
  "postId": "7312345678901234567",
  "text": "Great launch. Curious how you are measuring adoption.",
  "authorName": "Jane Smith",
  "authorHeadline": "Revenue Operations Lead",
  "authorProfileUrl": "https://www.linkedin.com/in/jane-smith/",
  "reactionCount": 12,
  "replyCount": 2,
  "source": "scrapecreators",
  "scrapedAt": "2026-06-08T12:00:00.000Z"
}
```

When `metadataOnly` is enabled, the Actor saves one `recordType: "post"` row per input post and does not charge per comment.

### Pricing

Pay per event:

- `$0.01` per saved comment
- `$0.01` per saved reply when `includeReplies` is enabled
- Metadata rows, summaries, and validation exits are free

This is premium-priced against current LinkedIn comments actors because it is no-cookie, provider-backed, MCP-friendly, returns normalized rows plus machine-readable run summaries, and preserves 70%+ gross margin against worst-case ScrapeCreators/SociaVault provider costs.

### Configuration

The Actor owner should configure at least one provider key as an Apify secret:

- `SCRAPECREATORS_API_KEY`
- `SOCIAVAULT_API_KEY`

ScrapeCreators is tried first by default. SociaVault is used as fallback when configured.

### Notes and boundaries

- Public LinkedIn data only.
- No LinkedIn credentials or cookies are required.
- Private/login-only comments are not promised.
- Provider payloads can change; the normalizer scans common comment envelopes and records provider status codes in `RUN_SUMMARY`.
- This Actor is independent and is not affiliated with, endorsed by, or sponsored by LinkedIn Corporation.

# Actor input Schema

## `startUrls` (type: `array`):

LinkedIn post URLs to scrape. Activity IDs and URNs are also accepted through the Post URLs field.

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

Optional line-separated list of LinkedIn post URLs, numeric activity IDs, or urn:li:activity values.

## `maxComments` (type: `integer`):

Maximum number of comment and reply rows to save across all posts.

## `includeReplies` (type: `boolean`):

Include nested replies when the provider payload contains them.

## `maxRepliesPerComment` (type: `integer`):

Caps nested replies per top-level comment.

## `metadataOnly` (type: `boolean`):

Save one post summary row per input instead of comment rows. Useful for cheap comment-count checks.

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

Choose which managed public-data provider to try first.

## `includeRawData` (type: `boolean`):

Attach raw comment objects to each dataset row for debugging. This increases dataset size.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.linkedin.com/feed/update/urn:li:activity:7312345678901234567/"
    }
  ],
  "postUrls": [],
  "maxComments": 100,
  "includeReplies": true,
  "maxRepliesPerComment": 25,
  "metadataOnly": false,
  "providerOrder": "scrapecreators-first",
  "includeRawData": false
}
```

# Actor output Schema

## `comments` (type: `string`):

Structured dataset records for scraped public LinkedIn comments and replies.

## `commentsCsv` (type: `string`):

CSV export of the same LinkedIn comment and reply records.

## `runSummary` (type: `string`):

Machine-readable telemetry with comment counts, providers used, provider status codes, costs, and stop reason.

## `outputSummary` (type: `string`):

Compact agent-friendly summary with comments scraped, posts processed, providers used, and stop reason.

# 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 = {
    "startUrls": [
        {
            "url": "https://www.linkedin.com/feed/update/urn:li:activity:7312345678901234567/"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("khadinakbar/linkedin-comments-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 = { "startUrls": [{ "url": "https://www.linkedin.com/feed/update/urn:li:activity:7312345678901234567/" }] }

# Run the Actor and wait for it to finish
run = client.actor("khadinakbar/linkedin-comments-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "startUrls": [
    {
      "url": "https://www.linkedin.com/feed/update/urn:li:activity:7312345678901234567/"
    }
  ]
}' |
apify call khadinakbar/linkedin-comments-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=khadinakbar/linkedin-comments-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "LinkedIn Comments Scraper - [✅ No Cookies]",
        "description": "Extract public LinkedIn post comments and replies with structured author, text, reaction, reply, provider, and run summary fields. No LinkedIn cookies required.",
        "version": "0.1",
        "x-build-id": "RBQcqrxQayewWtKkb"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/khadinakbar~linkedin-comments-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-khadinakbar-linkedin-comments-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/khadinakbar~linkedin-comments-scraper/runs": {
            "post": {
                "operationId": "runs-sync-khadinakbar-linkedin-comments-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/khadinakbar~linkedin-comments-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-khadinakbar-linkedin-comments-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "startUrls": {
                        "title": "LinkedIn post URLs",
                        "type": "array",
                        "description": "LinkedIn post URLs to scrape. Activity IDs and URNs are also accepted through the Post URLs field.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "postUrls": {
                        "title": "Post URLs, activity IDs, or URNs",
                        "type": "array",
                        "description": "Optional line-separated list of LinkedIn post URLs, numeric activity IDs, or urn:li:activity values.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxComments": {
                        "title": "Maximum comments",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum number of comment and reply rows to save across all posts.",
                        "default": 100
                    },
                    "includeReplies": {
                        "title": "Include replies",
                        "type": "boolean",
                        "description": "Include nested replies when the provider payload contains them.",
                        "default": true
                    },
                    "maxRepliesPerComment": {
                        "title": "Maximum replies per comment",
                        "minimum": 0,
                        "maximum": 250,
                        "type": "integer",
                        "description": "Caps nested replies per top-level comment.",
                        "default": 25
                    },
                    "metadataOnly": {
                        "title": "Metadata only",
                        "type": "boolean",
                        "description": "Save one post summary row per input instead of comment rows. Useful for cheap comment-count checks.",
                        "default": false
                    },
                    "providerOrder": {
                        "title": "Provider order",
                        "enum": [
                            "scrapecreators-first",
                            "sociavault-first",
                            "scrapecreators-only",
                            "sociavault-only"
                        ],
                        "type": "string",
                        "description": "Choose which managed public-data provider to try first.",
                        "default": "scrapecreators-first"
                    },
                    "includeRawData": {
                        "title": "Include raw provider data",
                        "type": "boolean",
                        "description": "Attach raw comment objects to each dataset row for debugging. This increases dataset size.",
                        "default": false
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
