# LinkedIn Posts Scraper \[$0.99💰 No Cookies] Profile + Companies (`memo23/linkedin-posts-scraper`) Actor

\[Only $0.99💰]  Track any LinkedIn creator or company's posts — no login, no cookies. Get text, author, reactions with types, comment counts and media, plus a unique 0–100 engagement-quality score and a monitoring mode that returns only new posts on a schedule. Profiles, companies, post URLs

- **URL**: https://apify.com/memo23/linkedin-posts-scraper.md
- **Developed by:** [Muhamed Didovic](https://apify.com/memo23) (community)
- **Categories:** Social media, Agents, AI
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.99 / 1,000 results

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/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 Posts Scraper (No Cookies)

![How It Works](https://raw.githubusercontent.com/muhamed-didovic/muhamed-didovic.github.io/main/assets/how-it-works-linkedin-posts.png)

Turn any LinkedIn **profile URL, company URL, post URL, or activity id** into clean, structured post rows — **no LinkedIn account, no cookie, no login**.
Each post comes back as one tidy row: post text, author (name + profile + headline + photo), reactions (with types), comment counts, media, post type — plus an **exact post date** you can filter by range and a **0–100 engagement-quality score** nobody else surfaces. Add **monitoring mode** to get only-new posts on a schedule. JSON or CSV out.

### Why Use This Scraper?

- ✅ Cookie-free — no LinkedIn login, no account, nothing to paste
- ✅ Clean structured rows — 18 fields per post, ready for a spreadsheet or a model
- ✅ Author included — name, profile URL, headline, and photo on every post
- ✅ Engagement — reaction count, reaction **types** (LIKE/EMPATHY/PRAISE/…), and comment count
- ✅ **Engagement-quality score** — a 0–100 score + tier (viral / high / solid / low / quiet) computed from reactions, comment ratio, and reaction depth — rank posts at a glance
- ✅ **Date-range filter** — `dateFrom` / `dateTo` keep only posts published in a window; dates are derived from the post id, so out-of-range posts are skipped *before* fetching (you don't pay for them)
- ✅ **Monitoring mode** — schedule it and get **only new posts** each run (de-dupes against what it already returned)
- ✅ **Company posts too** — paste a company URL for its recent posts
- ✅ Flexible input — profile URLs, company URLs, post URLs, or raw activity ids
- ✅ Cheap to run — built to use the lightest egress tier first

### Overview

The LinkedIn Posts Scraper is built for marketers, founders, researchers, and analysts who need a quick, structured pull of someone's recent LinkedIn posts without managing logins or accounts.

The output is **post-shaped rows** — one row per post.

- Paste a **post URL or activity id** → you get that post. **Works for any public post.**
- Paste a **profile URL** → you get that person's recent public posts — **but only for profiles that expose their activity publicly** (creators, influencers, and active public posters). Many regular profiles keep their post feed behind login; cookie-free, those return no posts, and you'd pass the individual post URLs instead.
- Paste a **company URL** → you get that company's ~12–15 most recent posts (a small share of company posts are partially login-gated and may come back with engagement but truncated text).

The author (name, profile, headline, photo) and engagement counts ride along on every row.

This is the **lightweight, cookie-free** option. It reads only LinkedIn's public surfaces, so it's honest about its limits (below) rather than pretending to do everything. If you need *unlimited* post history, full comment threads, company feeds, or keyword search, those require logged-in scraping — out of scope here by design.

### Supported Inputs

| Input type | Pattern | Example |
|---|---|---|
| Profile URL | `https://www.linkedin.com/in/{slug}` | `https://www.linkedin.com/in/williamhgates` |
| Company URL | `https://www.linkedin.com/company/{slug}` | `https://www.linkedin.com/company/microsoft` |
| Post URL | `.../feed/update/urn:li:activity:{id}` or `.../posts/...-activity-{id}-{hash}` | `https://www.linkedin.com/feed/update/urn:li:activity:7469496437156925441` |
| Activity id / URN | `{id}` or `urn:li:activity:{id}` | `7469496437156925441` |

#### Copy-pasteable startUrls

```json
{
  "startUrls": [
    "https://www.linkedin.com/in/williamhgates",
    "https://www.linkedin.com/feed/update/urn:li:activity:7469496437156925441",
    "7468855929338310656"
  ]
}
````

#### Unsupported inputs

- ❌ Keyword / content search — requires a logged-in session
- ❌ Person *search* or connection data
- ❌ Any host outside `linkedin.com`

### Use Cases

| Audience | Use case |
|---|---|
| **Marketers / ghostwriters** | Pull a creator's recent posts to study format, hooks, and engagement |
| **Founders / sales** | Watch a prospect's or competitor's recent posts for timely outreach angles |
| **Researchers / analysts** | Bulk-export public posts from a list of profiles for content analysis |
| **Social teams** | Track a roster of voices and benchmark reactions/comments over time |

### How It Works

![How It Works](https://raw.githubusercontent.com/muhamed-didovic/muhamed-didovic.github.io/main/assets/how-it-works-linkedin-posts.png)

1. **Input** — provide LinkedIn profile URLs, post URLs, or activity ids
2. **List posts** — for a profile, the actor reads its public page and collects up to ~15 recent post ids
3. **Fetch each post** — it pulls each post's public embed widget (a small ~24 KB page), cookie-free
4. **Structure** — author, text, engagement counts, media, and type are parsed into one clean row
5. **Output** — export as JSON or CSV

### Input Configuration

| Field | Type | Required | Notes |
|---|---|---|---|
| `startUrls` | `array<string>` | yes | Profile URLs, post URLs, or activity ids/URNs |
| `maxPostsPerProfile` | `integer` | optional | Posts to pull per profile. LinkedIn's cookie-free limit is **15**, so higher values are capped. Default `15` |
| `maxItems` | `integer` | optional | Hard cap on total post rows. Default `1000` |
| `maxConcurrency` | `integer` | optional | Parallel requests. Default `3` |
| `maxRequestRetries` | `integer` | optional | Retries per request before giving up. Default `2` |
| `dateFrom` | `string` | optional | Keep only posts published **on/after** this date (YYYY-MM-DD). Derived from the post id, so filtering happens before fetch. |
| `dateTo` | `string` | optional | Keep only posts published **on/before** this date (YYYY-MM-DD, inclusive). |
| `onlyNewPosts` | `boolean` | optional | **Monitoring mode.** Remembers the posts it has already returned and, on each re-run, emits **only posts it hasn't seen before** — so a schedule pays only for genuinely new content. Default `false` |
| `dedupeStoreName` | `string` | optional | Monitoring only: the named storage holding the "already-seen" ids. Give each independent monitor its own name (e.g. `seen-microsoft`). Default `linkedin-posts-seen` |
| `sdoKey` | `string` (secret) | optional | Leave blank — built-in egress is used by default. Advanced: paste your own scrape.do token to bill unblocker usage to your own account |

#### Example input

```json
{
  "startUrls": ["https://www.linkedin.com/in/williamhgates"],
  "maxPostsPerProfile": 10,
  "maxConcurrency": 3
}
```

### Output Overview

Each dataset item is one post:

- **Identity** — `urn`, `activityId`, `postUrl`
- **Content** — `postText`, `postType` (article / video / image / text), `mediaUrl`, `articleUrl` (for published LinkedIn articles)
- **Author** — `author.name`, `author.profileUrl`, `author.headline`, `author.image`, `author.isInfluencer`
- **Engagement** — `reactions`, `comments` (counts), `reactionTypes` (e.g. `["LIKE","EMPATHY","PRAISE"]`)
- **Engagement score** — `engagement.score` (0–100), `engagement.tier` (`viral`/`high`/`solid`/`low`/`quiet`), `engagement.total`, `engagement.commentRatio`, `engagement.reactionDepth`
- **Meta** — `postedAt` (exact ISO date, derived from the activity id), `postedRelative` (e.g. "1d", "3w"), `sourceProfile`, `scrapedAt`

### Output Sample

#### Profile start (`linkedin.com/in/williamhgates`)

```jsonc
{
  "urn": "urn:li:activity:7469496437156925441",
  "activityId": "7469496437156925441",
  "postUrl": "https://www.linkedin.com/feed/update/urn:li:activity:7469496437156925441",
  "postText": "Alzheimer's research has historically faced problems with scale: not enough people diagnosed early enough…",
  "postType": "article",
  "author": {
    "name": "Bill Gates",
    "profileUrl": "https://www.linkedin.com/in/williamhgates",
    "headline": "Chair, Gates Foundation and Founder, Breakthrough Energy"
  },
  "reactions": 5332,
  "comments": 692,
  "reactionTypes": ["LIKE", "EMPATHY", "PRAISE", "INTEREST"],
  "engagement": {
    "total": 6024,
    "commentRatio": 0.11,
    "reactionDepth": 3,
    "score": 71,
    "tier": "high"
  },
  "mediaUrl": "https://dms.licdn.com/playlist/vid/v2/…",
  "postedRelative": "1d",
  "postedAt": "2026-06-08T14:20:11.000Z",
  "sourceProfile": "https://www.linkedin.com/in/williamhgates",
  "scrapedAt": "2026-06-09T16:32:00.000Z"
}
```

### Key Output Fields

#### Post

- `urn`, `activityId`, `postUrl`, `postText`, `postType`, `mediaUrl`, `postedAt`, `postedRelative`

#### Author

- `author.name`, `author.profileUrl`, `author.headline`

#### Engagement

- `reactions`, `comments` (counts), `reactionTypes`
- `engagement.score` (0–100), `engagement.tier` (viral / high / solid / low / quiet), plus the raw `total`, `commentRatio`, and `reactionDepth` inputs

### FAQ

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

No. This actor reads only LinkedIn's public surfaces, so you provide nothing but the URLs.

#### Why did a profile return 0 posts?

Cookie-free, LinkedIn only exposes a profile's post feed publicly for **creator / influencer-style profiles** (and people who've made their activity public). Many regular profiles keep their feed behind login, so they come back empty. **Post URLs and activity ids always work for any public post** — so for those profiles, pass the individual post links directly.

#### How many posts do I get per profile?

For profiles that do expose activity, up to about **15 most-recent posts** — LinkedIn's hard cap for cookie-free access (no deeper pagination without login).

#### Do I get the comment text?

No — you get the **comment count**, not the comment bodies. Comment threads and reaction lists are only available to logged-in sessions, which this actor deliberately doesn't use.

#### Can I scrape company pages?

Yes — paste a company URL (`linkedin.com/company/{name}`) and you get its ~12–15 most recent posts. A small share of company posts are partially login-gated; those rows come back with engagement counts but truncated text.

#### Can I search by keyword?

No. Content search is login-walled. This actor is profile-, company-, and post-level only.

#### Is the posted date exact?

Yes. `postedAt` is an **exact ISO timestamp derived from the post's activity id** — LinkedIn encodes the creation time in the id itself, so you get a precise date cookie-free. `postedRelative` ("1d", "3w") is included too, as LinkedIn displays it. Use **`dateFrom` / `dateTo`** to keep only posts published in a date range — they're filtered before fetching, so out-of-range posts cost nothing.

#### What if a profile or post is private?

Only publicly visible posts are returned. Private/connections-only content is out of scope.

#### What is the engagement score?

A transparent **0–100 quality score** computed per post from public signals only — no extra requests, no guessing. It blends three things: **volume** (reactions + comments, log-scaled so a 5k-reaction post isn't 100× a 50-reaction one), **comment ratio** (comments are higher-effort than reactions, so a real conversation scores higher), and **reaction depth** (how many reaction *types* beyond a plain LIKE — praise/empathy/insightful/funny/support signal stronger sentiment). The score maps to a `tier`: `viral` (80+), `high` (60+), `solid` (40+), `low` (20+), `quiet` (<20). The raw inputs (`total`, `commentRatio`, `reactionDepth`) ride along so you can re-rank with your own weights.

#### How do I monitor a profile or company for new posts?

Turn on **`onlyNewPosts`** and put the actor on an **Apify Schedule** (e.g. every 6 hours). On each run it remembers the post ids it already returned (in a named storage) and emits **only posts it hasn't seen before** — so your dataset and your bill only grow with genuinely new content. Running several independent monitors? Give each its own `dedupeStoreName` (e.g. `seen-microsoft`, `seen-billgates`) so they don't share state. A monitoring run that finds nothing new simply returns 0 rows — that's the expected "all quiet" result, not an error.

### Support

- Issues or feature requests: the [Issues tab](https://apify.com/memo23/linkedin-posts-scraper/issues) of this actor.
- Custom work / questions: <muhamed.didovic@gmail.com> · all actors at [apify.com/memo23](https://apify.com/memo23).

### Additional Services

Need deeper LinkedIn data (full comments, reactions lists, company feeds, search)? That requires a logged-in approach — email <muhamed.didovic@gmail.com> to discuss a custom build.

### Explore More Scrapers

- [**Crunchbase Company Scraper**](https://apify.com/memo23/crunchbase-scraper) — clean structured company + funding data
- [**More by memo23**](https://apify.com/memo23) — directory, jobs, real-estate, and social scrapers

***

### ⚠️ Disclaimer

This Actor is an independent tool and is not affiliated with, endorsed by, or sponsored by LinkedIn Corporation or Microsoft Corporation. All trademarks mentioned are the property of their respective owners.

The scraper accesses only publicly available LinkedIn pages — no authenticated endpoints, no login, and no content behind LinkedIn's login wall. Users are responsible for ensuring their use complies with LinkedIn's Terms of Service, applicable data-protection law (GDPR, CCPA, etc.), and any contractual obligations of their own organization. Scrape responsibly and respect the rights of the individuals whose public posts you collect.

***

### SEO Keywords

linkedin posts scraper, scrape linkedin posts, linkedin post scraper, linkedin scraper no cookies, cookie-free linkedin scraper, linkedin profile posts, linkedin activity scraper, linkedin post data, linkedin content scraper, linkedin engagement data, linkedin engagement score, linkedin post monitoring, linkedin new posts alert, linkedin post tracker, social media scraper, linkedin api alternative, linkedin posts export, linkedin author data, linkedin post extractor, Apify linkedin, linkedin marketing data, creator content analysis, linkedin posts json, linkedin posts csv

# Actor input Schema

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

Paste any combination of:

- **Post URL** — `https://www.linkedin.com/feed/update/urn:li:activity:7469496437156925441` or a `.../posts/...-activity-…` link (works for ANY public post)
- **Activity id / URN** — `7469496437156925441` or `urn:li:activity:7469496437156925441`
- **Profile URL** — `https://www.linkedin.com/in/williamhgates` (up to ~15 recent posts — only for profiles that expose activity publicly: creators, influencers, public posters. Regular profiles keep their feed behind login and return no posts — use the post URLs instead.)
- **Company URL** — `https://www.linkedin.com/company/microsoft` (up to ~12-15 recent company posts)

Cookie-free: no LinkedIn account needed. Keyword search is not supported.

## `maxPostsPerProfile` (type: `integer`):

How many recent posts to pull from each profile. LinkedIn's cookie-free limit is 15, so values above 15 are capped.

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

Hard cap on total post rows emitted across the whole run.

## `maxConcurrency` (type: `integer`):

Parallel unblocker requests. Keep low (2–4) — the premium pool is metered per success.

## `maxRequestRetries` (type: `integer`):

Retries on transient unblocker errors before giving up.

## `dateFrom` (type: `string`):

Only keep posts published on or after this date (YYYY-MM-DD). Post dates are derived from the activity id, so out-of-range posts are skipped before fetching — you don't pay for them. Leave blank for no lower bound.

## `dateTo` (type: `string`):

Only keep posts published on or before this date (YYYY-MM-DD, inclusive). Leave blank for no upper bound.

## `onlyNewPosts` (type: `boolean`):

Turn this ON for a scheduled monitor. The actor remembers the posts it has already emitted (in a named storage) and, on each re-run, returns ONLY posts it hasn't seen before — so you pay only for genuinely new content. Pair it with an Apify Schedule (e.g. every 6h) to track a profile's or company's latest posts. Leave OFF for a normal one-off scrape.

## `dedupeStoreName` (type: `string`):

Advanced (monitoring mode only): the named key-value store that holds the 'already-seen' post ids. Give each independent monitor its own name so they don't share state — e.g. `seen-microsoft`, `seen-billgates`. Leave blank to use the default shared store.

## `sdoKey` (type: `string`):

Leave blank — the actor uses its built-in unblocker by default. Advanced: paste your own scrape.do API token to bill unblocker requests to your own account.

## Actor input object example

```json
{
  "startUrls": [
    "https://www.linkedin.com/in/williamhgates",
    "https://www.linkedin.com/company/microsoft"
  ],
  "maxPostsPerProfile": 15,
  "maxItems": 1000,
  "maxConcurrency": 3,
  "maxRequestRetries": 2,
  "onlyNewPosts": false,
  "dedupeStoreName": "linkedin-posts-seen"
}
```

# 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": [
        "https://www.linkedin.com/in/williamhgates",
        "https://www.linkedin.com/company/microsoft"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("memo23/linkedin-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 = { "startUrls": [
        "https://www.linkedin.com/in/williamhgates",
        "https://www.linkedin.com/company/microsoft",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("memo23/linkedin-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 '{
  "startUrls": [
    "https://www.linkedin.com/in/williamhgates",
    "https://www.linkedin.com/company/microsoft"
  ]
}' |
apify call memo23/linkedin-posts-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "LinkedIn Posts Scraper [$0.99💰 No Cookies] Profile + Companies",
        "description": "[Only $0.99💰]  Track any LinkedIn creator or company's posts — no login, no cookies. Get text, author, reactions with types, comment counts and media, plus a unique 0–100 engagement-quality score and a monitoring mode that returns only new posts on a schedule. Profiles, companies, post URLs",
        "version": "0.1",
        "x-build-id": "yODRIYkZ96ahyAMyP"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/memo23~linkedin-posts-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-memo23-linkedin-posts-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/memo23~linkedin-posts-scraper/runs": {
            "post": {
                "operationId": "runs-sync-memo23-linkedin-posts-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/memo23~linkedin-posts-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-memo23-linkedin-posts-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",
                "required": [
                    "startUrls"
                ],
                "properties": {
                    "startUrls": {
                        "title": "LinkedIn profile, company, or post URLs / activity ids",
                        "type": "array",
                        "description": "Paste any combination of:\n- **Post URL** — `https://www.linkedin.com/feed/update/urn:li:activity:7469496437156925441` or a `.../posts/...-activity-…` link (works for ANY public post)\n- **Activity id / URN** — `7469496437156925441` or `urn:li:activity:7469496437156925441`\n- **Profile URL** — `https://www.linkedin.com/in/williamhgates` (up to ~15 recent posts — only for profiles that expose activity publicly: creators, influencers, public posters. Regular profiles keep their feed behind login and return no posts — use the post URLs instead.)\n- **Company URL** — `https://www.linkedin.com/company/microsoft` (up to ~12-15 recent company posts)\n\nCookie-free: no LinkedIn account needed. Keyword search is not supported.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxPostsPerProfile": {
                        "title": "Max posts per profile",
                        "minimum": 1,
                        "maximum": 15,
                        "type": "integer",
                        "description": "How many recent posts to pull from each profile. LinkedIn's cookie-free limit is 15, so values above 15 are capped.",
                        "default": 15
                    },
                    "maxItems": {
                        "title": "Max posts total",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Hard cap on total post rows emitted across the whole run.",
                        "default": 1000
                    },
                    "maxConcurrency": {
                        "title": "Max parallel requests",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Parallel unblocker requests. Keep low (2–4) — the premium pool is metered per success.",
                        "default": 3
                    },
                    "maxRequestRetries": {
                        "title": "Max retries per request",
                        "minimum": 0,
                        "maximum": 5,
                        "type": "integer",
                        "description": "Retries on transient unblocker errors before giving up.",
                        "default": 2
                    },
                    "dateFrom": {
                        "title": "Published on or after",
                        "type": "string",
                        "description": "Only keep posts published on or after this date (YYYY-MM-DD). Post dates are derived from the activity id, so out-of-range posts are skipped before fetching — you don't pay for them. Leave blank for no lower bound."
                    },
                    "dateTo": {
                        "title": "Published on or before",
                        "type": "string",
                        "description": "Only keep posts published on or before this date (YYYY-MM-DD, inclusive). Leave blank for no upper bound."
                    },
                    "onlyNewPosts": {
                        "title": "Only new posts (monitoring mode)",
                        "type": "boolean",
                        "description": "Turn this ON for a scheduled monitor. The actor remembers the posts it has already emitted (in a named storage) and, on each re-run, returns ONLY posts it hasn't seen before — so you pay only for genuinely new content. Pair it with an Apify Schedule (e.g. every 6h) to track a profile's or company's latest posts. Leave OFF for a normal one-off scrape.",
                        "default": false
                    },
                    "dedupeStoreName": {
                        "title": "Monitor storage name",
                        "type": "string",
                        "description": "Advanced (monitoring mode only): the named key-value store that holds the 'already-seen' post ids. Give each independent monitor its own name so they don't share state — e.g. `seen-microsoft`, `seen-billgates`. Leave blank to use the default shared store.",
                        "default": "linkedin-posts-seen"
                    },
                    "sdoKey": {
                        "title": "Unblocker API token (optional)",
                        "type": "string",
                        "description": "Leave blank — the actor uses its built-in unblocker by default. Advanced: paste your own scrape.do API token to bill unblocker requests to your own account."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
