# LinkedIn Profile Posts Scraper · No Cookies (`data-slayer/linkedin-profile-posts-scraper`) Actor

Scrape recent posts, quote posts, and reposts from public LinkedIn profiles with text, media, author details, and engagement—no login or cookies.

- **URL**: https://apify.com/data-slayer/linkedin-profile-posts-scraper.md
- **Developed by:** [Data Slayer](https://apify.com/data-slayer) (community)
- **Categories:** Social media, Lead generation, Automation
- **Stats:** 301 total users, 58 monthly users, 100.0% runs succeeded, 2 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.00 / 1,000 posts

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?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

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

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## LinkedIn Profile Posts Scraper — No Cookies

Collect recent posts, quote posts, and reposts from public LinkedIn personal profiles. Get clean post text, canonical URLs, author details, media, mentions, publication dates, and engagement counts without providing a LinkedIn login or session cookie.

**Paste one or more profile URLs, choose how many posts you need, optionally set a date cutoff, and click Run.** Results are ready to download as JSON, CSV, or Excel or use in an automated workflow.

### Watch the demo

[![Watch the LinkedIn Profile Posts Scraper demo](https://img.youtube.com/vi/B6HG8qGkzVk/hqdefault.jpg)](https://www.youtube.com/watch?v=B6HG8qGkzVk)

### What this LinkedIn profile posts scraper returns

Each successful dataset row represents one usable LinkedIn post and includes:

- Post text, public post ID, URN, canonical LinkedIn URL, and publication time
- A stable `post_type`: `post`, `quote_post`, or `repost`
- Author name, headline, profile URL, public identifier, image, and LinkedIn ID when available
- Likes, comments, shares, and reaction counts by type
- Images, videos, and linked articles in one `media` array
- People and companies mentioned in the post
- Original-post content, author, media, and engagement for quote posts and reposts when LinkedIn exposes it
- The requested `source_profile_url` on every row for reliable bulk-run tracing

This Actor returns engagement counts and reaction-type totals. It does **not** return the individual people who reacted or the text of individual comments; those belong in dedicated post-reaction and post-comment workflows.

### How to scrape posts from a LinkedIn profile

1. Open the **Input** tab.
2. Add one or more public LinkedIn personal-profile URLs, such as `https://www.linkedin.com/in/satyanadella/`.
3. Set **Maximum Posts per Profile**. The default is 20.
4. Optionally set **Only Posts From** to an exact date or a relative period such as `30 days`.
5. Click **Run** and open the **Dataset** tab to preview or download the results.

No LinkedIn account, browser extension, or proxy configuration is required from you.

### Input

| Field | Type | Required | Default | Description |
|---|---|---:|---:|---|
| `profileUrls` | Array of strings | Yes | — | 1–100 public LinkedIn personal-profile URLs. Company and individual-post URLs are not accepted. |
| `maxPosts` | Integer | No | `20` | Maximum usable posts returned for each profile. Accepted range: 1–1,000. |
| `postedAfter` | String | No | — | Return posts published on or after an exact date/time or relative period such as `30 days`, `6 months`, or `1 year`. |

Example input:

```json
{
  "profileUrls": [
    "https://www.linkedin.com/in/satyanadella/",
    "https://www.linkedin.com/in/williamhgates/"
  ],
  "maxPosts": 20,
  "postedAfter": "30 days"
}
```

`maxPosts` applies separately to every profile. For example, two profiles with `maxPosts: 20` can return up to 40 post rows.

### Output

The default dataset uses one canonical schema. Duplicate URL aliases, unstable relative dates, and empty repost placeholders are excluded. Optional scalar values use `null`; collection fields such as `reactions`, `mentions`, and `media` use empty arrays when no values are available.

```json
{
  "source_profile_url": "https://www.linkedin.com/in/satyanadella/",
  "post_id": "7485746420684296192",
  "post_urn": "urn:li:ugcPost:7485746369614307328",
  "post_url": "https://www.linkedin.com/posts/satyanadella_looking-forward-to-ignite-this-fall-join-activity-7485746420684296192-GKhn",
  "post_type": "post",
  "text": "Looking forward to Ignite this Fall! Join me in San Francisco or online.",
  "published_at": "2026-07-22T17:23:45.134Z",
  "edited": false,
  "author_id": "ACoAAAEkwwAB9KEc2TrQgOLEQ-vzRyZeCDyc6DQ",
  "author_name": "Satya Nadella",
  "author_headline": "Chairman and CEO at Microsoft",
  "author_profile_url": "https://www.linkedin.com/in/satyanadella",
  "author_public_identifier": "satyanadella",
  "author_type": "profile",
  "author_image_url": "https://media.licdn.com/...",
  "likes": 2024,
  "comments": 77,
  "shares": 198,
  "reactions": [
    { "type": "like", "count": 1790 },
    { "type": "support", "count": 12 },
    { "type": "love", "count": 118 },
    { "type": "insightful", "count": 17 },
    { "type": "celebrate", "count": 85 },
    { "type": "funny", "count": 2 }
  ],
  "mentions": [],
  "media": [
    {
      "type": "video",
      "url": "https://dms.licdn.com/...",
      "thumbnail_url": "https://media.licdn.com/..."
    }
  ],
  "original_post": null
}
```

| Output field | Meaning |
|---|---|
| `source_profile_url` | Exact profile URL that produced the row |
| `post_id`, `post_urn` | Public post ID and LinkedIn entity identifier |
| `post_url` | Canonical LinkedIn post URL without tracking parameters |
| `post_type` | `post`, `quote_post`, or `repost` |
| `text`, `published_at`, `edited` | Post content and publication metadata |
| `author_*` | Flattened author fields designed for clean CSV exports |
| `likes`, `comments`, `shares` | Native numeric engagement totals |
| `reactions` | Normalized reaction counts: like, support, love, insightful, celebrate, and funny |
| `mentions` | Mentioned people or companies, including IDs and URNs when available |
| `media` | Images, videos, or linked articles in one consistent array |
| `original_post` | Nested original-post details for quote posts or reposts; otherwise `null` |

Profile-level failures are kept out of the successful post dataset. Check the run's `OUTPUT` record for a summary of requested profiles, successful profiles, failed profiles, posts written, and any error details.

### Common use cases

- **Thought-leader monitoring:** Track what executives, founders, creators, and industry experts publish over time.
- **Sales research:** Understand a prospect's recent priorities before writing a relevant outreach message.
- **Content intelligence:** Compare topics, formats, posting cadence, and engagement across public profiles.
- **Competitive research:** Monitor public posts from leaders at competing companies.
- **Recruiting research:** Review a candidate's public professional content and areas of interest.
- **Reporting and analysis:** Send structured post data to spreadsheets, databases, dashboards, or AI analysis workflows.

### Automation and API access

Run the Actor manually, on a schedule, through the Apify API, or from tools that connect to Apify. Common workflows include:

- Schedule a weekly run to monitor a list of profiles
- Use a webhook when a run finishes
- Export results to JSON, CSV, or Excel
- Send the dataset to Make, Zapier, Google Sheets, a database, or your own application
- Use the canonical fields in an LLM, RAG pipeline, or content-analysis agent

The **API** tab contains generated examples for Python, JavaScript, CLI, HTTP, OpenAPI, and MCP usage.

### Pricing

This Actor uses pay-per-event pricing: each successful post written to the default dataset is one billable post event, plus the Actor-start event shown on the Pricing tab. Use `maxPosts` and `postedAfter` to control result volume and cost. See the live **Pricing** tab for the current rate for your Apify plan.

### Limitations

- Supports public LinkedIn **personal profile** URLs. It does not accept company-page or individual-post URLs.
- Only data publicly exposed by LinkedIn can be returned. Private, deleted, unavailable, or restricted profiles may return no posts.
- LinkedIn can limit how many historical posts are publicly available, so the Actor cannot guarantee a complete lifetime archive.
- Engagement counts can change after a run as people continue interacting with a post.
- Individual comments and reactor identities are not included.
- For a repost that LinkedIn exposes without usable post details, the Actor skips the empty placeholder and continues fetching toward `maxPosts` when more pages are available.

### Other LinkedIn Actors by Data Slayer

| Actor | What it does |
|---|---|
| [LinkedIn Profile Scraper](https://apify.com/data-slayer/linkedin-profile-scraper) | Extract public profile, career, skill, and education data |
| [LinkedIn Post Analytics Scraper](https://apify.com/data-slayer/linkedin-post-analytics-scraper) | Analyze one LinkedIn post in depth |
| [LinkedIn Company Scraper](https://apify.com/data-slayer/linkedin-company-scraper) | Extract public LinkedIn company information |
| [LinkedIn Company Posts Scraper](https://apify.com/data-slayer/linkedin-company-posts-scraper) | Collect recent posts from company pages |

### Frequently asked questions

#### Do I need a LinkedIn account or cookie?

No. The Actor does not ask for a LinkedIn login, password, `li_at` cookie, or browser session. Your LinkedIn account is not used to run it.

#### Can I scrape several profiles in one run?

Yes. Add up to 100 profile URLs to `profileUrls`. Every output row retains its `source_profile_url` so you can trace it back to the requested profile.

#### Can I fetch only recent posts?

Yes. Set `postedAfter` to an exact date or a relative period such as `7 days`, `3 months`, or `1 year`.

#### Does it include reposts and quote posts?

Yes. The `post_type` field distinguishes normal posts, quote posts, and reposts. When original-post details are available, they are returned in `original_post`.

#### Does it return comments and the people who reacted?

It returns comment totals and a reaction-type count breakdown. It does not return individual comment records or individual reactor profiles.

#### How do I report a problem?

Open the Actor's **Issues** tab and include the run ID plus a non-sensitive example input. This makes the issue easier to reproduce and resolve.

### Responsible use

This Actor extracts publicly available information. You are responsible for using the data in accordance with applicable laws, privacy requirements, LinkedIn's terms, and Apify's policies. Avoid collecting or using personal data in ways that could harm, discriminate against, or unfairly target individuals.

# Actor input Schema

## `profileUrls` (type: `array`):

Add 1 to 100 public personal-profile URLs, one per row. Use URLs such as https://www.linkedin.com/in/satyanadella/. Company and individual-post URLs are not accepted.

## `maxPosts` (type: `integer`):

Maximum recent posts and reposts to return for each profile. Use a smaller number for faster, lower-cost runs.

## `postedAfter` (type: `string`):

Optional. Return posts published on or after this date. Choose an exact date or enter a relative period such as 30 days. For reposts without a repost timestamp, the shared post's publication date is used.

## `linkedin_urls` (type: `array`):

Backward-compatible alias retained for existing API integrations.

## `linkedin_url` (type: `string`):

Backward-compatible single-URL alias retained for existing API integrations.

## `maxPages` (type: `integer`):

Backward-compatible pagination control retained for existing API integrations.

## `pages` (type: `integer`):

Backward-compatible pagination alias retained for existing API integrations.

## `maxItems` (type: `integer`):

Backward-compatible global output cap retained for existing API integrations.

## `retries` (type: `integer`):

Internal reliability control retained for existing API integrations.

## `requestTimeoutSecs` (type: `integer`):

Internal request timeout retained for existing API integrations.

## `outputFormat` (type: `string`):

Existing output-mode control retained until the output stage is reviewed.

## Actor input object example

```json
{
  "profileUrls": [
    "https://www.linkedin.com/in/satyanadella/"
  ],
  "maxPosts": 20,
  "postedAfter": "30 days"
}
```

# Actor output Schema

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

No description

## `run_summary` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "profileUrls": [
        "https://www.linkedin.com/in/satyanadella/"
    ],
    "maxPosts": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("data-slayer/linkedin-profile-posts-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 = {
    "profileUrls": ["https://www.linkedin.com/in/satyanadella/"],
    "maxPosts": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("data-slayer/linkedin-profile-posts-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 '{
  "profileUrls": [
    "https://www.linkedin.com/in/satyanadella/"
  ],
  "maxPosts": 20
}' |
apify call data-slayer/linkedin-profile-posts-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,data-slayer/linkedin-profile-posts-scraper"
        }
    }
}

```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/wsl6FhgEVCTBfIJ7t/builds/5ud1LsG763vmQ98rX/openapi.json