# Linkedin Profile Posts Scraper (`solid-scraper/linkedin-profile-posts-scraper`) Actor

🚀 Discover and capture LinkedIn profile post data fast with this LinkedIn Profile Posts Scraper. Perfect for marketers, researchers, and agencies to boost insights, track trends, and scale outreach with ease—no manual digging. 📈

- **URL**: https://apify.com/solid-scraper/linkedin-profile-posts-scraper.md
- **Developed by:** [SolidScraper](https://apify.com/solid-scraper) (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 $1.99 / 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.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#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 🔍

**Linkedin Profile Posts Scraper** is a purpose-built actor that scrapes LinkedIn profile posts (including regular feed updates) from a given profile, showcase, or company URL and exports the results as structured JSON records. If you’re looking for a **LinkedIn post scraper**, a **LinkedIn profile scraper**, or a way to **automate LinkedIn post scraping** for analysis and reporting, this actor helps you turn public web content into usable data—saving you hours of manual work.

***

### Why choose Linkedin Profile Posts Scraper?

| Feature | Benefit |
| --- | --- |
| ✅ **Scrapes posts from profile, showcase, or company URLs** | Collects feed post data for the target you provide |
| ✅ **Max posts control with `limit`** | Prevents oversized pulls and keeps runs focused |
| ✅ **Proxy support with reliable fallback** | Helps maintain access when requests are blocked |
| ✅ **Retries for URL fetching** | Improves resilience for transient failures |
| ✅ **Structured output per post** | Produces consistent fields for analytics and exports |
| ✅ **Dataset-ready results** | Appends each extracted post record immediately for faster iteration |

***

### Key features

- 🧾 **Structured post records**: Extracts text, timestamps, author metadata, engagement stats, and media info per post
- 🌐 **URL support for profiles, showcases, and companies**: Works with LinkedIn profile, showcase, or company URLs you provide
- 🛡️ **Built-in reliability**: Uses retry logic for fetching pages and built-in proxy support for more consistent runs
- ⏱️ **Controlled scale with `limit`**: Processes up to your specified “Maximum Posts per URL”
- 💾 **Immediate dataset saving**: Each successfully parsed post is pushed to the dataset as soon as it’s extracted
- 🔄 **Resilient multi-path discovery**: Uses available profile/activity paths when the target is a profile URL
- 📊 **Engagement statistics included**: Captures like/support counters and comment counts when present
- 🎞️ **Media extraction**: Detects whether a post includes video content or image content and stores media URLs

***

### Input

Provide input via an `input.json` file. Example structure:

```json
{
  "url": "https://www.linkedin.com/showcase/linkedin-news/",
  "limit": 20
}
```

#### Input Fields

| Field | Required | Description |
| --- | --- | --- |
| `url` | Yes | The LinkedIn profile, showcase, or company URL to scrape posts from. |
| `limit` | No | Maximum number of posts to scrape per provided URL. Minimum is `1`. Default is `20`. |

***

### Output

The actor pushes each extracted post record into the Apify dataset as a JSON object.

```json
{
  "urn": {
    "activity_urn": "1234567890",
    "share_urn": "9876543210",
    "ugcPost_urn": null
  },
  "full_urn": "urn:li:activity:1234567890",
  "posted_at": {
    "date": "2025-01-01 12:34:56",
    "relative": "3d",
    "timestamp": 1735734896000
  },
  "text": "Post text content...",
  "url": "https://www.linkedin.com/feed/update/urn:li:activity:1234567890",
  "post_type": "regular",
  "author": {
    "first_name": "Alex",
    "last_name": null,
    "headline": "Author headline...",
    "username": "example-profile",
    "profile_url": "https://www.linkedin.com/showcase/example-profile/",
    "profile_picture": "https://..."
  },
  "stats": {
    "total_reactions": 42,
    "like": 42,
    "support": 0,
    "love": 0,
    "insight": 0,
    "celebrate": 0,
    "funny": 0,
    "comments": 7,
    "reposts": 0
  },
  "media": {
    "type": "image",
    "url": "https://...",
    "images": [
      {
        "url": "https://...",
        "width": 1080,
        "height": 1350
      }
    ]
  }
}
```

#### Output Fields

| Field | Type | Description |
| --- | --- | --- |
| `urn` | object | URN identifiers for the activity and related share/post objects |
| `urn.activity_urn` | string | null | Activity URN id extracted from the post content |
| `urn.share_urn` | string | null | Share URN id (if available) |
| `urn.ugcPost_urn` | string | null | UGC post URN id (if available) |
| `full_urn` | string | null | Full activity URN in `urn:li:activity:<id>` format |
| `posted_at` | object | Posting time information |
| `posted_at.date` | string | null | Formatted datetime string (`%Y-%m-%d %H:%M:%S`) when available |
| `posted_at.relative` | string | Relative time text (as extracted) |
| `posted_at.timestamp` | number | null | Timestamp in milliseconds (as extracted) |
| `text` | string | Main post text content (may include newlines) |
| `url` | string | The post URL being processed/stored |
| `post_type` | string | Post classification; set to `"regular"` |
| `author` | object | Author/profile metadata associated with the post |
| `author.first_name` | string | Author first name (or profile identifier fallback) |
| `author.last_name` | string | null | Author last name (null for company/showcase-like targets) |
| `author.headline` | string | Author headline/description (as extracted) |
| `author.username` | string | Username extracted from your input URL |
| `author.profile_url` | string | Normalized author profile URL (profile/showcase/company form) |
| `author.profile_picture` | string | Author profile picture URL (if available) |
| `stats` | object | Engagement metrics captured from the post page |
| `stats.total_reactions` | number | Total reactions derived from LikeAction count |
| `stats.like` | number | Like count (same value as total reactions) |
| `stats.comments` | number | Comment count derived from CommentAction count |
| `stats.support` | number | Set to `0` |
| `stats.reposts` | number | Set to `0` |
| `media` | object | Post media information (text-only vs video vs image) |
| `media.type` | string | Media type: `"text"`, `"video"`, or `"image"` |
| `media.url` | string | null | Primary media URL when present |
| `media.images` | array | Extracted image entries with `url`, `width`, and `height` |
| `error_message` | ❌ Not present in pushed dataset output | The pushed post records do not include an `error_message` field |

After the run, export your dataset from Apify in JSON and/or CSV formats for analysis-ready pipelines.

***

### How to use Linkedin Profile Posts Scraper (via Apify Console)

1. **Open Apify Console**\
   Visit the Apify Console: [console.apify.com](https://console.apify.com) and sign in.

2. **Find the actor**\
   Search for **Linkedin Profile Posts Scraper** and open its actor page.

3. **Go to the Input panel**\
   Paste your `url` (LinkedIn profile, showcase, or company) and optionally set `limit` to control how many posts to extract.

4. **Set your target URL**\
   In the **url** field, enter a full LinkedIn URL (for example, a profile like `/in/...`, or a showcase/company URL).

5. **Tune the extraction size**\
   Set **limit** to the maximum number of posts you want scraped for that URL. Default is `20`.

6. **Run the actor**\
   Click **Run**. While it runs, watch the logs to see progress and processing of each post URL.

7. **Review dataset output**\
   After completion, open the **Dataset** tab and preview the records being pushed (one JSON object per successfully processed post).

8. **Export for downstream use**\
   Export the dataset as JSON or CSV and use it in dashboards, spreadsheets, or your data analysis workflows.

No coding required — get accurate results in minutes with this **Linkedin Profile Posts Scraper**.

***

### Advanced features & SEO optimization

- 🧠 **Engineered for “LinkedIn post analytics scraper” workflows**: Produces consistent fields (author, text, posted\_at, stats, media) for aggregation and reporting
- 🔄 **Built-in resilience for LinkedIn content scraper runs**: Includes retries and uses proxy support to reduce disruptions when access is restricted
- 🔍 **Input normalization for “LinkedIn profile posts export”**: Extracts the username from the provided URL and builds a normalized author profile URL in output
- 📌 **Designed for “LinkedIn lead scraper posts” use cases**: Captures author + engagement signals alongside post text for richer outreach targeting

***

### Best use cases

- 📈 **Lead generation teams building prospect content profiles**: Batch-scrape public LinkedIn post data to support targeting and research
- 🧑‍💼 **Recruiters tracking employer thought leadership**: Analyze showcase or company post activity for hiring signals and culture research
- 🧪 **Market researchers comparing content themes over time**: Export structured LinkedIn content scraper data for qualitative coding and trend analysis
- 📊 **Marketing analysts measuring engagement patterns**: Use extracted `stats` and timestamps to correlate topics with reactions and comments
- 💻 **Data engineers automating ETL pipelines**: Feed the dataset into downstream systems for dashboards and monitoring
- 🧠 **Brand intelligence analysts monitoring competitors**: Maintain a repeatable “scrape LinkedIn posts” workflow for consistent dataset snapshots
- ✍️ **Content strategists auditing formats and media usage**: Leverage media detection (video vs image) to evaluate content performance

***

### Technical specifications

**Supported Input Formats**

- ✅ `url`: The LinkedIn profile, showcase, or company URL to scrape posts from
- ✅ `limit`: Integer, minimum `1`, default `20`

**Proxy Support**

- ✅ Built-in proxy support for more reliable scraping runs (with fallback behavior)

**Retry Mechanism**

- ✅ Fetch requests include retry logic (up to 3 attempts per URL fetch)

**Dataset Structure**

- ✅ One dataset record per successfully processed post pushed via `Actor.push_data(..., charged_event_name="result")`

**Rate Limits & Performance**

- ✅ Designed for controlled batch runs using `limit`
- ✅ Includes delays between post requests to improve stability

**Limitations**

- ❌ If no posts can be found for the provided URL, the actor logs an error and continues to the next target (if any)
- ❌ Some posts may fail to download or parse; only successfully processed posts are pushed to the dataset

***

### FAQ

#### Can I scrape posts from a LinkedIn profile as well as a showcase or company?

✅ Yes. The `url` input accepts a LinkedIn profile, showcase, or company URL, and the actor extracts author metadata and post URLs accordingly.

#### What does the `limit` parameter do?

`limit` controls the maximum number of posts processed for the provided `url`. Default is `20`, and the minimum allowed value is `1`.

#### What exactly does the output contain?

The actor saves one JSON object per successfully processed post. Each record includes author information, post text, timestamps (`posted_at`), engagement stats (`stats`), and media details (`media`).

#### Does it require coding?

❌ Not required. You can run it directly from Apify Console by providing `url` (and optionally `limit`) in the input form.

#### Is there any proxy support for reliability?

✅ Yes. The actor supports proxy usage and includes retry logic for fetching pages to improve resilience when access is inconsistent.

#### Do you provide an error field like `error_message` in dataset results?

❌ No. The pushed dataset output (per processed post) does not include an `error_message` field.

#### Can I export the results as CSV?

Yes. After the run, you can export the Apify dataset in common formats like JSON and CSV from the **Dataset** tab.

#### Do you extract data from private or logged-in pages?

❌ No. The actor is intended for scraping data from publicly available sources.

***

### Support & feature requests

If you’re using this **Linkedin Profile Posts Scraper** for your team and want improvements, we’d love to hear from you.

- 💡 **Feature Requests**: Ideas like exporting additional fields, improving output formatting for “LinkedIn posts extraction tool” workflows, or adding new media/stat interpretations are welcome.
- 📧 **Contact**: Reach out at <dataforleads@gmail.com>.

User feedback helps shape the roadmap for future versions of this LinkedIn post analytics scraper.

***

### Closing CTA / Final thoughts

*Turn public LinkedIn profile content into structured datasets with this SEO-optimized **Linkedin Profile Posts Scraper**—built for scale, exports, and real analysis.*

***

### Disclaimer

This tool **accesses publicly accessible sources only**. It does not access private profiles, authenticated content, or password-protected pages. You are responsible for ensuring your use complies with applicable laws (including GDPR and CCPA), spam regulations, and the platform’s Terms of Service.

For data removal requests, contact <dataforleads@gmail.com>. Use this tool responsibly, ethically, and for legitimate purposes only.

# Actor input Schema

## `url` (type: `string`):

The LinkedIn profile, showcase, or company URL to scrape posts from.

## `limit` (type: `integer`):

Maximum number of posts to scrape per provided URL.

## Actor input object example

```json
{
  "url": "https://www.linkedin.com/showcase/linkedin-news/",
  "limit": 20
}
```

# 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 = {
    "url": "https://www.linkedin.com/showcase/linkedin-news/"
};

// Run the Actor and wait for it to finish
const run = await client.actor("solid-scraper/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 = { "url": "https://www.linkedin.com/showcase/linkedin-news/" }

# Run the Actor and wait for it to finish
run = client.actor("solid-scraper/linkedin-profile-posts-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 '{
  "url": "https://www.linkedin.com/showcase/linkedin-news/"
}' |
apify call solid-scraper/linkedin-profile-posts-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/3g9EiTOfzhbMVYOxJ/builds/dYEvku0iUh7WM2WPz/openapi.json