# Post Reshares & Reposts Scraper for LinkedIn (No Cookies) (`data_minds/post-reshares-reposts-scraper-for-linkedin-no-cookies`) Actor

Scrape public LinkedIn posts from links or IDs with no login or cookies. Get text, author, reactions, comments, images, video, links and the original post inside reposts. Bulk input, auto proxy fallback. Export JSON, CSV or Excel.

- **URL**: https://apify.com/data_minds/post-reshares-reposts-scraper-for-linkedin-no-cookies.md
- **Developed by:** [Data Minds](https://apify.com/data_minds) (community)
- **Security:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.50 / 1,000 results

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

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

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

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

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

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

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

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

# README

### What is Post Reshares & Reposts Scraper for LinkedIn (No Cookies)?

**Post Reshares & Reposts Scraper for LinkedIn (No Cookies)** is a Reposts Scraper for LinkedIn that turns public post links or post IDs into structured data. For every post you get the text, author, reactions, top comments, media, links and, for a repost, the original post inside it. You never enter a login or cookies. Pay per post from $3.50 per 1,000 on the Gold plan. [🚀 Try it free](https://apify.com/data_minds/post-reshares-reposts-scraper-for-linkedin-no-cookies)

- **Engagement analysis:** compare reactions, comments and engagement rate across posts of the same author.
- **Competitor post tracking:** save what rivals and industry leaders publish on [LinkedIn](https://www.linkedin.com), with the numbers next to it.
- **Sentiment analysis:** collect the top comments of a post with author, text and reaction count.
- **Repost source tracing:** find the original post, author and article behind a repost.
- **Content research:** export hashtags, mentions, shared articles and link destinations for editorial planning.

The Apify platform adds an API, scheduling, webhooks, integrations and export to JSON, CSV, Excel, XML or HTML.

#### What can Post Reshares & Reposts Scraper for LinkedIn (No Cookies) do?

- 🔗 **Read posts in bulk** from post links, `urn:li:activity` IDs or plain numeric post IDs, one per line, with duplicates skipped
- 🔁 **Detect reposts** and save the original post (author, text, images, video, article) as a separate table
- 💬 **Collect top comments** with author, text, time and reaction count
- 📊 **Measure engagement** with reaction counts, comment counts, top reaction types and the engagement rate against the author's followers
- 🎬 **Save media and transcripts** for images, videos, documents and carousels, plus captions text for videos that have captions
- 🔓 **Reveal short-link destinations** by replacing lnkd.in links with the real address when LinkedIn shows it
- 📦 **Get separate tables** for authors, comments, links, media, related posts and reshared posts

### What data can Post Reshares & Reposts Scraper for LinkedIn (No Cookies) extract?

The main table has one row per post. These are all of its fields.

| Data | Fields | What you get |
|---|---|---|
| 🔗 Post identity | `input_url`, `post_url`, `post_id`, `post_urn`, `share_urn` | The link you entered, the public post link and the post identifiers |
| 📝 Post content | `post_type`, `text`, `word_count`, `hashtags`, `mentions`, `links`, `is_edited` | Type (text, image, images, video, article, document or repost), full text, word count, hashtags, mentioned people and companies, links in the text |
| 🕒 Timing | `published_at`, `posted_relative`, `scraped_at` | Publish time in ISO 8601 (UTC), the age as LinkedIn shows it, and the time of the scrape |
| 👤 Author | `author_name`, `author_type`, `author_username`, `author_url`, `author_headline`, `author_followers`, `author_image_url` | Profile, company, school or showcase author with headline, followers and picture link |
| 📊 Engagement | `reactions_count`, `comments_count`, `top_reaction_types`, `engagement_total`, `engagement_rate_pct` | Reactions, comments, most used reaction types, reactions plus comments, and the rate against followers |
| 🔁 Reposts | `is_repost`, `repost_action_text`, `reshared_post` | Repost flag, the header text of the repost and the original post inside it |
| 📷 Media | `image_urls`, `video`, `article`, `document` | Image links, video details, the shared article card and document or carousel details |
| 💬 Comments | `comments`, `comments_returned`, `comments_note` | Top comments, how many are in the row, and a note when fewer are shown than the post has |
| 🧭 Related | `more_from_author`, `related_posts` | Other articles by the author and related posts |
| ✅ Status | `parse_warnings`, `status`, `error` | Fields that were expected but missing, `ok` or the reason a post was not read, and the problem text |

Nested objects use these field names:

| Object | Fields |
|---|---|
| 💬 Each item of `comments` | `comment_id`, `author_name`, `author_url`, `author_type`, `text`, `posted_at`, `posted_relative`, `reactions_count`, `image_url`, `by_post_author` |
| 🔁 `reshared_post` | `post_id`, `post_url`, `published_at`, `posted_relative`, `author_name`, `author_type`, `author_username`, `author_url`, `text`, `image_urls`, `video`, `article` |
| 🎬 `video` | `url`, `thumbnail_url`, `duration`, `width`, `height`, `captions_url`, `transcript` |
| 📰 `article` | `title`, `url`, `source`, `image_url`, and `resolved_url` for short links |
| 📄 `document` | `title`, `page_count`, `cover_image_urls`, `download_manifest_url` |
| 🔗 Each item of `links` | `url`, `text`, `resolved_url` |
| 📌 Each item of `mentions` | `name`, `url` |
| 🧭 Each item of `more_from_author` | `title`, `url`, `author_name`, `posted_relative`, `image_url` |
| 🧭 Each item of `related_posts` | `post_url`, `post_id`, `author_name`, `author_url`, `text`, `posted_relative`, `published_at`, `reactions_count`, `comments_count` |

> **Note:** Some fields are empty when a post does not have them. `author_followers` and `engagement_rate_pct` appear only when the follower count is shown. `video`, `document`, `article` and `reshared_post` exist only for posts of that kind. `more_from_author` and `related_posts` stay empty when `max_related_posts` is `0`.

#### What data can't Post Reshares & Reposts Scraper for LinkedIn (No Cookies) extract?

- ❌ The list of people who reposted a post, and the repost count. You get the repost header and the original post inside a repost.
- ❌ More comments than LinkedIn shows without a login, which is about the first 10 per post.
- ❌ Poll answers. Poll posts are returned like other posts, but their answers are not extracted.
- ❌ Private, deleted or members-only posts. They produce a row with a `status` and an `error` text instead.

Need posts from a whole company page or profile? See [LinkedIn Post Scraper](https://apify.com/data_minds/linkedin-post-scraper) below.

### How to scrape LinkedIn post reposts and engagement

1. Create a free [Apify account](https://console.apify.com/sign-up).
2. Open [Post Reshares & Reposts Scraper for LinkedIn (No Cookies)](https://apify.com/data_minds/post-reshares-reposts-scraper-for-linkedin-no-cookies).
3. Paste public post links or post IDs into `urls`, one per line.
4. Set `max_comments` and `max_related_posts`, or use `0` to skip them.
5. Keep `resolve_short_links` and `include_video_transcript` on if you want real link addresses and video captions.
6. Click **Start** and watch the log, which prints every saved post with its author, reactions and comments.
7. Open the **Output** tab, pick a table and export the data as JSON, CSV, Excel, XML or HTML.

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

The Actor uses pay-per-event pricing: you pay for each post that is read and saved, and Apify platform usage is billed in addition. Rows with a problem status (such as `not_found`) are listed in the dataset but never charged.

| Plan | Price per post | Price per 1,000 posts |
|---|---|---|
| 🆓 Free | $0.0045 | $4.50 |
| 🥉 Bronze | $0.0041 | $4.10 |
| 🥈 Silver | $0.0037 | $3.70 |
| 🥇 Gold | $0.0035 | $3.50 |

The Actor runs with 1024 MB of memory by default, so each run also has one Actor start event of $0.00005 (one event per GB of memory, minimum one).

**Worked example:** 1,000 posts on the Gold plan cost $3.50 plus the $0.00005 start event, with platform usage billed in addition.

**Free plan math:** the $5 monthly credit covers about 1,111 posts at the Free price of $0.0045, before platform usage.

See the full [pricing page](https://apify.com/data_minds/post-reshares-reposts-scraper-for-linkedin-no-cookies/pricing).

#### Is scraping LinkedIn free?

You can try it free: new Apify accounts get a monthly credit that pays for the first posts (about 1,111 at the Free price, before platform usage). After that you pay per post, and higher plans pay less per post.

### Input

Only `urls` is required. Everything else has a default. Open the [input schema](https://apify.com/data_minds/post-reshares-reposts-scraper-for-linkedin-no-cookies/input-schema) to see every option, or start from this input:

```json
{
  "urls": [
    "https://www.linkedin.com/posts/williamhgates_this-book-clears-up-climate-change-bill-activity-7408723748973056001-lp_x",
    "https://www.linkedin.com/posts/linkedin_add-job-preferences-activity-7208418413906464769-P2hn"
  ],
  "max_comments": 5,
  "max_related_posts": 3,
  "resolve_short_links": true,
  "include_video_transcript": true,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

| Field | Type | Required | Default | Description |
|---|---|---|---|---|
| `urls` | array | Yes | two sample posts | Post links (`linkedin.com/posts/...` or `linkedin.com/feed/update/urn:li:activity:...`), `urn:li:activity` IDs or numeric post IDs. One per line, duplicates are skipped. |
| `max_comments` | integer | No | `5` | Top comments to save for each post. `0` saves none. Values above `100` are lowered to `100`. |
| `max_related_posts` | integer | No | `3` | How many of the author's other articles and how many related posts to save for each post. `0` saves none. Values above `50` are lowered to `50`. |
| `resolve_short_links` | boolean | No | `true` | Replace shortened lnkd.in links with the real destination address when LinkedIn shows it. |
| `include_video_transcript` | boolean | No | `true` | For video posts, save the caption text when the post has captions. |
| `proxyConfiguration` | object | No | no proxy | Optional proxy configuration. By default no proxy is used. You can choose Apify Proxy or add your own proxy URLs. |

#### Tricky fields

**`urls`**

- ✅ Good: `https://www.linkedin.com/posts/linkedin_add-job-preferences-activity-7208418413906464769-P2hn`
- ✅ Good: `urn:li:activity:7208418413906464769` or just `7208418413906464769`
- ❌ Bad: a profile, company or article page. These are not posts and produce an `invalid_input` row.

> **Warning:** Only public posts that anyone can open without logging in can be read. Private or members-only posts return a row with `status` `not_found_or_private`.

**`max_comments`**

- ✅ Good: `5` to `10`, because LinkedIn shows about the first 10 comments of a post without a login.
- ❌ Bad: `1000` expecting a full comment export. The row's `comments_note` explains when fewer comments are shown than the post has.

> **Warning:** The old key names `post_urls`, `postUrls`, `maxComments` and `resolveShortLinks` are still accepted. The keys `limit` and `page_number` are ignored with a warning in the log.

### Output

Results appear in the run's **Output** tab and in the default dataset. The main table has one row per post. You can export every table as JSON, CSV, Excel, XML or HTML, or read it through the API. Next to the main table the run writes six more tables: authors, comments, links, media, related posts and reshared posts. A small `RUN_SUMMARY` record in the key-value store lists the counts and timing of the run.

#### JSON example

Illustrative values for the first input link:

```json
{
  "input_url": "https://www.linkedin.com/posts/williamhgates_this-book-clears-up-climate-change-bill-activity-7408723748973056001-lp_x",
  "post_url": "https://www.linkedin.com/feed/update/urn:li:activity:7000000000000000001",
  "post_id": "7000000000000000001",
  "post_urn": "urn:li:activity:7000000000000000001",
  "share_urn": "urn:li:share:7000000000000000002",
  "post_type": "article",
  "is_repost": false,
  "repost_action_text": null,
  "reshared_post": null,
  "is_edited": false,
  "text": "Example post text about a new report.",
  "word_count": 7,
  "hashtags": ["example"],
  "mentions": [{ "name": "Example Company", "url": "https://www.example.com/company" }],
  "links": [{ "url": "https://www.example.com/report", "text": "Read the report", "resolved_url": "https://www.example.com/report" }],
  "published_at": "2026-01-15T09:30:00.000Z",
  "posted_relative": "10mo",
  "author_name": "Example Author",
  "author_type": "profile",
  "author_username": "example-author",
  "author_url": "https://www.example.com/author",
  "author_headline": "Example headline",
  "author_followers": 120000,
  "author_image_url": "https://www.example.com/author.jpg",
  "reactions_count": 2200,
  "comments_count": 490,
  "top_reaction_types": ["LIKE", "APPRECIATION", "EMPATHY"],
  "engagement_total": 2690,
  "engagement_rate_pct": 2.2417,
  "image_urls": [],
  "video": null,
  "article": { "title": "Example report", "url": "https://www.example.com/report", "source": "example.com", "image_url": "https://www.example.com/report.jpg" },
  "document": null,
  "comments": [
    {
      "comment_id": "7000000000000000003",
      "author_name": "Example Commenter",
      "author_url": "https://www.example.com/commenter",
      "author_type": "profile",
      "text": "Example comment.",
      "posted_at": "2026-01-15T10:00:00.000Z",
      "posted_relative": "10mo",
      "reactions_count": 12,
      "image_url": null,
      "by_post_author": false
    }
  ],
  "comments_returned": 1,
  "comments_note": null,
  "more_from_author": [],
  "related_posts": [],
  "parse_warnings": [],
  "status": "ok",
  "error": null,
  "scraped_at": "2026-11-07T08:00:00Z"
}
```

A post that could not be read becomes a short row. It is never charged:

```json
{
  "input_url": "https://www.example.com/not-a-post",
  "post_url": null,
  "post_id": null,
  "status": "invalid_input",
  "error": "not a LinkedIn post URL, urn:li:activity id or post id (profile/company/article URLs are not posts)",
  "scraped_at": "2026-11-07T08:00:00Z"
}
```

The `status` is `ok` or one of `invalid_input`, `not_found`, `not_found_or_private`, `layout_changed`, `network_error`, `blocked` and `error`.

Reshared posts table, one row per repost:

```json
{
  "reposted_by": "Example Author",
  "repost_action_text": "Example Author reposted this",
  "original_post_id": "7000000000000000004",
  "original_post_url": "https://www.linkedin.com/feed/update/urn:li:activity:7000000000000000004",
  "original_published_at": "2026-01-10T08:00:00.000Z",
  "original_author_name": "Example Original Author",
  "original_author_type": "company",
  "original_author_url": "https://www.example.com/original",
  "original_text": "Example original post text.",
  "original_image_urls": [],
  "original_video": null,
  "original_article": null,
  "post_id": "7000000000000000001",
  "post_url": "https://www.linkedin.com/feed/update/urn:li:activity:7000000000000000001",
  "post_author": "Example Author",
  "scraped_at": "2026-11-07T08:00:00Z"
}
```

Comments table, one row per comment:

```json
{
  "comment_id": "7000000000000000003",
  "author_name": "Example Commenter",
  "author_url": "https://www.example.com/commenter",
  "author_type": "profile",
  "text": "Example comment.",
  "posted_at": "2026-01-15T10:00:00.000Z",
  "posted_relative": "10mo",
  "reactions_count": 12,
  "image_url": null,
  "by_post_author": false,
  "post_id": "7000000000000000001",
  "post_url": "https://www.linkedin.com/feed/update/urn:li:activity:7000000000000000001",
  "post_author": "Example Author",
  "scraped_at": "2026-11-07T08:00:00Z"
}
```

Authors table, one row per post author:

```json
{
  "author_name": "Example Author",
  "author_type": "profile",
  "author_username": "example-author",
  "author_url": "https://www.example.com/author",
  "author_headline": "Example headline",
  "author_followers": 120000,
  "author_image_url": "https://www.example.com/author.jpg",
  "post_type": "article",
  "engagement_total": 2690,
  "engagement_rate_pct": 2.2417,
  "post_id": "7000000000000000001",
  "post_url": "https://www.linkedin.com/feed/update/urn:li:activity:7000000000000000001",
  "post_author": "Example Author",
  "scraped_at": "2026-11-07T08:00:00Z"
}
```

Links table, one row per link, article card or mention (`kind` is `link`, `article` or `mention`):

```json
{
  "kind": "link",
  "url": "https://www.example.com/report",
  "resolved_url": "https://www.example.com/report",
  "text": "Read the report",
  "title": null,
  "source": null,
  "post_id": "7000000000000000001",
  "post_url": "https://www.linkedin.com/feed/update/urn:li:activity:7000000000000000001",
  "post_author": "Example Author",
  "scraped_at": "2026-11-07T08:00:00Z"
}
```

Media table, one row per image, video or document (`kind` is `image`, `video` or `document`; video rows add `thumbnail_url`, `duration`, `width`, `height`, `captions_url` and `transcript`, document rows add `title`, `page_count` and `cover_image_urls`):

```json
{
  "kind": "image",
  "url": "https://www.example.com/image.jpg",
  "post_id": "7000000000000000001",
  "post_url": "https://www.linkedin.com/feed/update/urn:li:activity:7000000000000000001",
  "post_author": "Example Author",
  "scraped_at": "2026-11-07T08:00:00Z"
}
```

Related posts table, one row per author article or related post (`kind` is `more_from_author` or `related_post`; related post rows add `related_post_id`, `author_url`, `text`, `published_at`, `reactions_count` and `comments_count`):

```json
{
  "kind": "more_from_author",
  "title": "Example article",
  "url": "https://www.example.com/article",
  "author_name": "Example Author",
  "posted_relative": "1y",
  "image_url": "https://www.example.com/article.jpg",
  "post_id": "7000000000000000001",
  "post_url": "https://www.linkedin.com/feed/update/urn:li:activity:7000000000000000001",
  "post_author": "Example Author",
  "scraped_at": "2026-11-07T08:00:00Z"
}
```

#### Notes and limitations

- Posts are saved one by one in input order, so a long run never ends with an empty table.
- Comments are limited to what LinkedIn shows without a login, about the first 10 per post.
- If `layout_changed` appears, LinkedIn showed a post in a layout the Actor could not read. Report it in the Issues tab.
- If you set a maximum charge per run, the run stops cleanly when the limit is reached and the status message says how many posts were saved.

### Tips and advanced usage

- Set `max_comments` and `max_related_posts` to `0` when you only need post text and counts.
- Turn `resolve_short_links` off if you do not need the real address behind lnkd.in links.
- [Schedule runs](https://docs.apify.com/platform/schedules) to track the same posts over time and compare `reactions_count` and `comments_count` between exports.
- Use the Reshared posts table when you only care about original sources behind reposts.
- Use LinkedIn repost detection (`is_repost`) to filter the main table, and open the shared article card to see which link a post promotes.
- Read LinkedIn hashtags and LinkedIn mentions to see which topics, people and companies a post points to.
- Compare the LinkedIn engagement rate with the LinkedIn author followers count to judge which posts beat the usual reach of their author.
- Find the LinkedIn video transcript and LinkedIn carousel documents in the Media table, one row per file.
- Export LinkedIn posts to Excel from the Output tab when you want to share the results with people who do not use JSON.

### Integrations and API

#### Can I use Post Reshares & Reposts Scraper for LinkedIn (No Cookies) as an API?

Yes. Run it through the [Apify API](https://docs.apify.com/api/v2) or the official `apify-client` packages for Node.js and Python, then read the dataset items. Open the [API tab](https://apify.com/data_minds/post-reshares-reposts-scraper-for-linkedin-no-cookies/api) of the Actor for ready-to-copy code.

#### How to scrape LinkedIn posts with Python

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")

run = client.actor("data_minds/post-reshares-reposts-scraper-for-linkedin-no-cookies").call(run_input={
    "urls": [
        "https://www.linkedin.com/posts/williamhgates_this-book-clears-up-climate-change-bill-activity-7408723748973056001-lp_x",
        "https://www.linkedin.com/posts/linkedin_add-job-preferences-activity-7208418413906464769-P2hn"
    ],
    "max_comments": 5,
    "max_related_posts": 3,
    "resolve_short_links": True,
    "include_video_transcript": True,
    "proxyConfiguration": {"useApifyProxy": False}
})

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["post_url"], item["reactions_count"], item["comments_count"])
```

#### Can I integrate Post Reshares & Reposts Scraper for LinkedIn (No Cookies) with other apps?

Yes. Connect it to Make, Zapier, Google Sheets, Slack and many other tools through Apify integrations, or trigger your own endpoint with [webhooks](https://docs.apify.com/integrations/webhooks) when a run finishes. You can also schedule runs to keep a sheet or dashboard up to date.

#### Can I use Post Reshares & Reposts Scraper for LinkedIn (No Cookies) with AI agents (MCP)?

Yes. Apify Actors can be called by AI agents through the Model Context Protocol. Use the [MCP tab](https://apify.com/data_minds/post-reshares-reposts-scraper-for-linkedin-no-cookies/api/mcp) of this Actor for the connection details, then pass the same input as shown above.

### Other LinkedIn scrapers

| Actor | What it does |
|---|---|
| 📝 [LinkedIn Post Scraper](https://apify.com/data_minds/linkedin-post-scraper) | Scrape public LinkedIn posts from company pages, profiles, post URLs and content searches without cookies or login. |
| 📢 [LinkedIn Ads Library Scraper](https://apify.com/data_minds/linkedin-ads-library-scraper) | Scrape the LinkedIn Ad Library: ad copy, headlines, creatives, CTAs, advertiser and payer, impressions by country, targeting and run dates. |
| 🎯 [LinkedIn Ads Scraper](https://apify.com/data_minds/linkedin-ads-scraper) | Scrape the LinkedIn Ad Library by keyword, company, advertiser, payer or search link, with landing page, run dates and EU/EEA impressions. |
| 👥 [LinkedIn People Search Scraper](https://apify.com/data_minds/linkedin-people-search-scraper) | Find public LinkedIn profiles by keyword, job title, location and company, with work history, education and career metrics. |

### FAQ

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

The Actor reads only public posts that anyone can open without logging in. Whether your use is legal depends on your purpose, local privacy laws such as GDPR and LinkedIn's terms. This is not legal advice. Read Apify's guide on [web scraping legality](https://blog.apify.com/is-web-scraping-legal/) and ask a lawyer if unsure.

#### How does the Reposts Scraper for LinkedIn work?

You paste public post links or post IDs. The Actor reads each post and saves one row per post with its text, author, engagement, comments, media and links. For a repost it also saves the original post inside it. Results appear in the Output tab, in the main table and in six extra tables.

#### Why scrape LinkedIn posts and reposts?

Teams scrape posts to measure engagement, track competitors and thought leaders, analyse comment sentiment, archive content and trace the original source of a repost. Structured rows with counts, dates and author details are easier to compare, chart and feed into dashboards or language models than copied text.

#### Why do I get fewer results or comments than expected?

LinkedIn shows only the first comments of a post without a login, about 10, so asking for more cannot return more. Duplicate links are skipped, and private, deleted or unreadable posts become rows with a `status` and `error`. Those rows are listed but never charged.

#### Does the Actor need a LinkedIn login or cookies?

No. You do not enter a LinkedIn account, password or cookies, and the input has no field for them. The Actor works only with public posts that open without logging in. Posts that need a login, such as private or members-only posts, return a row with a status instead of data.

#### Can I get the list of people who reposted a LinkedIn post?

No. This Actor does not return the people who reposted a post or the repost count. For a repost, it saves the repost header text and the original post inside it, including its author, text, images, video and article, in the main table and the Reshared posts table.

#### How do I find the original post behind a LinkedIn repost?

Paste the repost link and run the Actor. When the post is a repost, the `reshared_post` field and the Reshared posts table hold the original post: its link, author, publish time, text and media. The `is_repost` field tells you which rows are reposts.

#### What happens when a post is private or deleted?

The Actor does not stop. The post becomes a short row with `status` set to `not_found` or `not_found_or_private` and an `error` text, while all other posts continue. These problem rows are not charged, so you pay only for posts that were read and saved.

#### Why is Post Reshares & Reposts Scraper for LinkedIn (No Cookies) not working?

First check the run log and the `status` and `error` values of the rows. Make sure each link is a public post, not a profile or company page. If the problem remains, open the [Issues tab](https://apify.com/data_minds/post-reshares-reposts-scraper-for-linkedin-no-cookies/issues/open) and include the post link and the run link.

### Support and feedback

Found a bug or need another field? Open the [Issues tab](https://apify.com/data_minds/post-reshares-reposts-scraper-for-linkedin-no-cookies/issues/open) and include the post link and the run link. For custom solutions, write to hello.dataminds@gmail.com. Built and maintained by the [data_minds team on Apify](https://apify.com/data_minds).

This Actor is an independent tool and is not affiliated with or endorsed by LinkedIn. You are responsible for using the data in line with the law and the terms of the sites you scrape.

# Actor input Schema

## `urls` (type: `array`):

One per line: a post link (linkedin.com/posts/... or linkedin.com/feed/update/urn:li:activity:...), a urn:li:activity ID or just the numeric post ID. Duplicates are skipped.

## `max_comments` (type: `integer`):

Top comments to save for each post. Use 0 for none. Without a login LinkedIn shows about the first 10 comments of a post.

## `max_related_posts` (type: `integer`):

How many of the author's other articles and how many related posts to save for each post. Use 0 for none.

## `resolve_short_links` (type: `boolean`):

Replace shortened lnkd.in links with the real destination address when LinkedIn shows it.

## `include_video_transcript` (type: `boolean`):

For video posts, save the caption text when the post has captions.

## `proxyConfiguration` (type: `object`):

Optional. By default no proxy is used. You can choose Apify Proxy or add your own proxy URLs.

## Actor input object example

```json
{
  "urls": [
    "https://www.linkedin.com/posts/williamhgates_this-book-clears-up-climate-change-bill-activity-7408723748973056001-lp_x",
    "https://www.linkedin.com/posts/linkedin_add-job-preferences-activity-7208418413906464769-P2hn"
  ],
  "max_comments": 5,
  "max_related_posts": 3,
  "resolve_short_links": true,
  "include_video_transcript": true,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

One row per post with author, engagement, media, links and comments.

## `authors` (type: `string`):

One row per post author.

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

One row per top comment.

## `links` (type: `string`):

One row per link, article card or mention.

## `media` (type: `string`):

One row per image, video or document.

## `related` (type: `string`):

One row per article by the author or related post.

## `reshares` (type: `string`):

One row per repost with the original post inside it.

## `summary` (type: `string`):

Counts and timing of the run.

# 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 = {
    "urls": [
        "https://www.linkedin.com/posts/williamhgates_this-book-clears-up-climate-change-bill-activity-7408723748973056001-lp_x",
        "https://www.linkedin.com/posts/linkedin_add-job-preferences-activity-7208418413906464769-P2hn"
    ],
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("data_minds/post-reshares-reposts-scraper-for-linkedin-no-cookies").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 = {
    "urls": [
        "https://www.linkedin.com/posts/williamhgates_this-book-clears-up-climate-change-bill-activity-7408723748973056001-lp_x",
        "https://www.linkedin.com/posts/linkedin_add-job-preferences-activity-7208418413906464769-P2hn",
    ],
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("data_minds/post-reshares-reposts-scraper-for-linkedin-no-cookies").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 '{
  "urls": [
    "https://www.linkedin.com/posts/williamhgates_this-book-clears-up-climate-change-bill-activity-7408723748973056001-lp_x",
    "https://www.linkedin.com/posts/linkedin_add-job-preferences-activity-7208418413906464769-P2hn"
  ],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call data_minds/post-reshares-reposts-scraper-for-linkedin-no-cookies --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,data_minds/post-reshares-reposts-scraper-for-linkedin-no-cookies"
        }
    }
}
```

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/yq9ugzKc3NaRu7ZI8/builds/5uKyvJxS8euaE2vQY/openapi.json