# LinkedIn Posts Scraper ✅ NO COOKIES (`atomus/linkedin-posts-scraper-pro`) Actor

Scrape every post from any LinkedIn profile or company page: post text, media, reactions, comments, shares, reposts, author details, and mentions. No LinkedIn account or cookies needed. Auto-pagination handles full feeds, with batch scraping across many profiles in one run.

- **URL**: https://apify.com/atomus/linkedin-posts-scraper-pro.md
- **Developed by:** [Atomus APIs](https://apify.com/atomus) (community)
- **Categories:** Lead generation, Social media, Automation
- **Stats:** 196 total users, 95 monthly users, 100.0% runs succeeded, 6 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $1.00 / 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

A **LinkedIn posts scraper** that extracts every post from any LinkedIn profile or company page: post text, media, reactions, comments, shares, author details, mentions, and repost data. Auto-pagination handles full feeds, and you can batch many profiles and companies in a single run.

**No LinkedIn account or cookies required.** Over **50,000 posts scraped** and counting.

> 💡 **For other LinkedIn tools by Atomus**, check: https://apify.com/atomus

---

### ✨ Key Features

| Feature | Description |
|---------|-------------|
| 🔄 **Auto-pagination** | One run extracts every post LinkedIn exposes. No manual page management. |
| 📦 **Batch processing** | Scrape posts from multiple profiles and company pages in a single run. |
| 🎬 **Full media support** | Captures images, videos, embedded articles, and carousel / document slide previews. |
| 📊 **Engagement breakdown** | Total reactions, comments, shares, and reaction-type counts (like, praise, empathy, interest, appreciation, entertainment). |
| 👤 **Author details** | Name, headline, avatar, LinkedIn ID, custom website link. |
| 🔁 **Repost detection** | Distinguishes simple reposts (no added text) from quote posts (with added commentary). Includes original author info. |
| 🗓️ **Time and content filters** | Filter by `24h` / `week` / `month`, by absolute date, or by content type (videos, images, documents, jobs). |
| 🆕 **Latest-post mode** | Use `latestPostOnly` to check if a profile posted recently without a full scrape. |
| 🔗 **Flexible URL formats** | Profile URLs, company URLs, or plain usernames all work. |
| 🔐 **No cookies needed** | No risk of account restrictions or bans. |

---

### 📊 What data can this Actor extract from LinkedIn?

For every post on a target profile or company page, this LinkedIn Posts Scraper extracts:

| Data category | Fields |
|---------------|--------|
| Post content | Post text, post URL, share URL, post type, timestamp, relative "posted ago" date |
| Media | Image URLs, video URL, embedded article (title, summary, link), document / carousel slides |
| Engagement | Total reactions, comments count, shares count, per-type reaction breakdown |
| Author | Name, headline, avatar, LinkedIn URL, LinkedIn ID, website URL, website label |
| Mentions | Person and company mentions inside post text (with URL, name, type, and offset) |
| Repost data | `is_repost` flag, original author info, reposter info on quote posts |

See the [Output](#-output) section for the full JSON schema with examples.

---

### 🚀 How to scrape LinkedIn posts from any profile or company

1. **Pick your target.** Paste one or more LinkedIn profile URLs into `profiles` or company page URLs into `companies`. You can mix full URLs and plain usernames freely.
2. **Set your scope.** Optional: cap `maxPosts` per source, filter by `postedLimit` (`24h`, `week`, `month`), or filter by `postedAfterDate` (ISO format such as `2026-01-01`).
3. **Pick a content type.** Optional: filter to `videos`, `images`, `documents`, `jobs`, or leave as `all`.
4. **Run the Actor.** Click **Start**. Watch progress in the run log.
5. **Get your data.** When the run finishes, your posts are in the run's dataset. View them in the Console or pull them via the [Apify API](https://docs.apify.com/api).

For continuous and programmatic use, the Apify platform handles [scheduling](https://docs.apify.com/platform/schedules), [proxy rotation](https://docs.apify.com/platform/proxy), monitoring, dataset storage, and [integrations](https://apify.com/integrations) with Zapier, Make, n8n, Slack, and webhooks out of the box.

---

### 📥 Input

#### Quick Start

```json
{
  "profiles": ["https://www.linkedin.com/in/satyanadella/"]
}
````

#### All Parameters

| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| `profiles` | string\[] | At least one of `profiles` or `companies` | `[]` | LinkedIn profile URLs or usernames |
| `companies` | string\[] | At least one of `profiles` or `companies` | `[]` | LinkedIn company page URLs or usernames |
| `maxPosts` | integer | No | `0` | Max posts per source. `0` means unlimited. |
| `postedLimit` | string | No | `none` | Time filter: `24h`, `week`, `month`. |
| `postedAfterDate` | string | No | `-` | Only posts after this date (ISO format, e.g. `2026-01-01`). |
| `contentType` | string | No | `all` | Filter: `videos`, `images`, `documents`, `jobs`. |
| `sortBy` | string | No | `date` | Sort by `date` (newest first) or `relevance` (LinkedIn ranking). |
| `latestPostOnly` | boolean | No | `false` | Only fetch the most recent post per source. |
| `includeSharedPosts` | boolean | No | `true` | Include quote posts (the user reposted and added their own text). |
| `includeReposts` | boolean | No | `true` | Include simple reposts (shared as is, no added text). |

#### Supported URL Formats

All of these work, just paste whatever you have:

```
✅ https://www.linkedin.com/in/satyanadella/
✅ https://linkedin.com/in/satyanadella
✅ satyanadella
✅ https://www.linkedin.com/company/microsoft/
✅ https://linkedin.com/company/microsoft
✅ microsoft
```

***

### 📤 Output

The dataset contains one record per post, with `type: "post"`.

#### Post

```json
{
  "type": "post",
  "author_name": "Satya Nadella",
  "content": "Today at Microsoft Build...",
  "post_url": "https://www.linkedin.com/feed/update/urn:li:activity:123/",
  "posted_at": "2026-03-15T14:30:00.000Z",
  "posted_ago": "2 weeks ago",
  "is_repost": false,
  "images": ["https://media.licdn.com/..."],
  "video_url": null,
  "article": null,
  "doc": null,
  "mentions": [
    {
      "start": 0,
      "length": 9,
      "type": "COMPANY_NAME",
      "url": "https://www.linkedin.com/company/microsoft/",
      "name": "Microsoft"
    }
  ],
  "share_url": "https://www.linkedin.com/posts/...",
  "engagement": {
    "total_reactions": 15234,
    "comments": 892,
    "shares": 1205,
    "reactions": [
      { "type": "LIKE", "count": 10000 },
      { "type": "PRAISE", "count": 3000 }
    ]
  },
  "author": {
    "name": "Satya Nadella",
    "username": "satyanadella",
    "headline": "Chairman and CEO at Microsoft",
    "linkedinUrl": "https://www.linkedin.com/in/satyanadella/",
    "avatar": "https://media.licdn.com/...",
    "linkedin_id": "ACoAAA8BYqEBCGLg...",
    "website_url": "https://example.com",
    "website_label": "My website"
  },
  "reposted_by": null,
  "_metadata": {
    "post_id": "7302346926123798528",
    "extracted_at": "2026-03-30T12:00:00.000Z",
    "source_url": "https://www.linkedin.com/in/satyanadella/"
  }
}
```

#### Carousel / Document Post

When a post contains a document or carousel slides, the `doc` field is populated:

```json
{
  "doc": {
    "title": "How we grew 10x in 6 months",
    "pdf_url": "https://media.licdn.com/dms/document/...",
    "slide_images": [
      "https://media.licdn.com/.../0/...",
      "https://media.licdn.com/.../1/...",
      "https://media.licdn.com/.../2/..."
    ],
    "total_slides": 7
  }
}
```

`slide_images` contains cover previews (up to 3). Use `pdf_url` to access the full document.

#### Repost (quote post)

When the post is a quote repost, `is_repost` is `true` and `reposted_by` carries the original author's info:

```json
{
  "is_repost": true,
  "content": "Great insight, agree completely.",
  "reposted_by": {
    "author_name": "Original Author",
    "author_url": "https://www.linkedin.com/in/original-author/",
    "post_url": "https://www.linkedin.com/feed/update/urn:li:activity:456/",
    "content": "Original post text..."
  }
}
```

***

### 📌 Examples

#### Example 1: Multiple profiles and companies

```json
{
  "profiles": ["satyanadella", "jeffweiner08"],
  "companies": ["microsoft", "google"],
  "maxPosts": 50
}
```

#### Example 2: Only original posts (no reposts)

```json
{
  "profiles": ["satyanadella"],
  "includeReposts": false,
  "includeSharedPosts": false
}
```

#### Example 3: Posts after a specific date

```json
{
  "profiles": ["satyanadella"],
  "postedAfterDate": "2026-01-01"
}
```

#### Example 4: Quick activity check

Use `latestPostOnly` to check if a profile posted recently without scraping everything:

```json
{
  "profiles": ["satyanadella"],
  "latestPostOnly": true
}
```

#### Example 5: Only video posts from the last week

```json
{
  "companies": ["microsoft"],
  "contentType": "videos",
  "postedLimit": "week"
}
```

#### Example 6: Sort by relevance, top 10 per profile

```json
{
  "profiles": ["satyanadella", "jeffweiner08"],
  "sortBy": "relevance",
  "maxPosts": 10
}
```

***

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

This LinkedIn Posts Scraper uses Apify's pay-per-event pricing. You pay per dataset item, and one item equals one scraped post. The exact per-post price is shown above the Actor on Apify Store.

What this means for you:

- **Free tier**: every Apify account gets a monthly platform credit, so you can try this Actor for free.
- **Predictable cost**: 1,000 posts equals 1,000 events. No surprise overruns.
- **No cost for invalid sources**: private, deleted, or invalid LinkedIn URLs do not produce dataset items, so they do not bill.
- **Cap your spend**: set `maxPosts` per source to bound the run cost, or use `latestPostOnly: true` for cheap activity checks.

***

### 🎯 Use Cases

- 🔎 **Sales prospecting**: build prospect lists from posts on competitor profiles or industry leaders.
- 📊 **Content monitoring**: track what executives, founders, or thought leaders are publishing in your space.
- 🏆 **Competitor analysis**: compare engagement patterns across competitor company pages.
- 📋 **Lead enrichment**: combine post data with the [Comments Scraper](https://apify.com/atomus/linkedin-comments-scraper-pro) and [Reactions Scraper](https://apify.com/atomus/linkedin-reactions-scraper-pro) to map full engagement.
- 📈 **Content strategy**: spot the post types and topics that drive reactions in your industry.
- 🤖 **AI agent context**: feed structured post data into LLM agents for summarization, classification, or trend detection.
- 📰 **Brand and PR monitoring**: watch a company page for product announcements, releases, or PR events.
- 📚 **Research and journalism**: collect public statements made by public figures over time.

***

### 🤖 Integration with AI Agents

This Actor is optimized for AI agents and LLMs via the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp).

#### Output Schema

The dataset is flat. Every record is a single post (`type: "post"`). Iterate or filter directly. Key fields useful for agents:

- `content`: post text
- `author.name`, `author.headline`: who posted and their professional context
- `engagement.total_reactions`, `engagement.comments`, `engagement.shares`: engagement signal
- `posted_at`, `posted_ago`: when the post was published
- `is_repost`, `reposted_by`: whether the author shared someone else's content
- `mentions`: people and companies tagged inside the post

#### Example Agent Prompt

> "Scrape Satya Nadella's last 50 LinkedIn posts and return the top 5 by total reactions. Summarize the key topics and flag any product announcements."

For cheap exploratory checks, the agent can use `latestPostOnly: true` or `maxPosts: 50` to bound cost.

***

### How does this compare to cookie-based tools and the official API?

| Capability | This scraper (cookieless) | Cookie-based scrapers | Official LinkedIn API |
|------------|:-------------------------:|:---------------------:|:---------------------:|
| LinkedIn account / cookie | **Not needed** | Required (`li_at`) | Marketing Developer Platform partner |
| Account restriction risk | **None** | Yes | None |
| Posts from any public profile or company | ✅ | ✅ | Approved partners / owned pages only |
| Full text, media, and engagement | ✅ | ✅ | Partner-gated |
| Setup | **Paste a URL** | Extract and paste your cookie | Partnership application + OAuth |

For public profile and company posts, the cookieless approach returns the same data with zero account risk and no partnership approval.

***

### 🔗 Other LinkedIn Scrapers by Atomus

Pair this LinkedIn Posts Scraper with our other LinkedIn tools to map full engagement:

| Actor | What it does |
|-------|--------------|
| [LinkedIn Post Comments & Replies Scraper Pro](https://apify.com/atomus/linkedin-comments-scraper-pro) | Extract every comment and reply on a LinkedIn post, with reaction counts and reply tracking. |
| [LinkedIn Post Reactions Scraper Pro](https://apify.com/atomus/linkedin-reactions-scraper-pro) | Extract every reactor on a LinkedIn post (name, headline, profile URL, reaction type). |
| [LinkedIn Profile Scraper](https://apify.com/atomus/linkedin-profile-scraper) | Enrich a list of LinkedIn profiles with full headline, location, experience, and contact data. |

See all our LinkedIn scrapers at [apify.com/atomus](https://apify.com/atomus).

***

### ❓ FAQ

#### Do I need a LinkedIn account or cookies to scrape LinkedIn posts?

No. This Actor uses public LinkedIn data only. You will not risk account restrictions or bans, and you do not need to provide a `li_at` cookie.

#### Is there an official LinkedIn API for posts?

LinkedIn's official Posts API requires a Marketing Developer Platform partnership and is restricted to approved partners. This Actor is a public-data alternative that does not require partnership approval.

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

This Actor only collects publicly visible data. Scraping public data has been ruled lawful under the U.S. Computer Fraud and Abuse Act (hiQ Labs v. LinkedIn). Always review your local laws and LinkedIn's terms before using extracted data for commercial purposes, and comply with applicable data protection laws (GDPR, CCPA).

#### How many posts can I scrape per profile?

LinkedIn paginates profile posts publicly. The Actor follows pagination as far as LinkedIn exposes. For very high-volume profiles, set a `maxPosts` cap to control cost.

#### Can I scrape posts from a private profile?

No. Private profiles are not publicly visible, so this Actor cannot extract posts from them.

#### What happens if a profile URL is invalid or deleted?

The Actor logs an error and continues with the remaining sources. No dataset item is produced for invalid URLs, so you are not billed for them.

#### Can I sort posts by date or relevance?

Yes. Use `sortBy: "date"` (default) for newest first or `sortBy: "relevance"` for LinkedIn's own ranking.

#### How do I include or exclude reposts?

Use `includeReposts: false` to exclude simple reshares (no added text), and `includeSharedPosts: false` to exclude quote posts (where the user adds their own commentary).

#### Can I run this LinkedIn Posts Scraper on a schedule?

Yes. Apify [Schedules](https://docs.apify.com/platform/schedules) let you run the Actor on cron-style intervals. Combine with webhooks to push fresh data to your own systems.

#### How do I integrate this with my own app or pipeline?

Use the [Apify API](https://docs.apify.com/api) to start runs and pull dataset results. The Actor also supports [webhooks](https://docs.apify.com/platform/integrations/webhooks) on run completion and integrates with Zapier, Make, n8n, and Slack out of the box.

#### Why are some posts missing fields like `images` or `video_url`?

Different post types expose different fields. A text-only post has no `images` or `video_url`. A carousel post has `doc.slide_images` but no `images`. This is normal LinkedIn behavior.

#### Can I use this to extract data in Python or JavaScript?

Yes. The Apify API has official clients in [Python](https://docs.apify.com/api/client/python) and [JavaScript](https://docs.apify.com/api/client/js). Run the Actor, fetch the dataset, and use it in your code.

***

### ⚠️ Disclaimer

This Actor is an independent tool and is not affiliated with, endorsed by, or sponsored by LinkedIn Corporation. LinkedIn® is a registered trademark of LinkedIn Corporation. All trademarks are property of their respective owners.

Use the data extracted by this Actor in compliance with applicable data protection laws (GDPR, CCPA, etc.) and LinkedIn's terms of service. Do not use the data for spam, harassment, or unlawful purposes.

# Actor input Schema

## `profiles` (type: `array`):

LinkedIn profile URLs or usernames. Examples: https://www.linkedin.com/in/satyanadella/ or just satyanadella

## `companies` (type: `array`):

LinkedIn company URLs or usernames. Examples: https://www.linkedin.com/company/microsoft/ or just microsoft

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

Maximum number of posts to extract per profile or company. 0 = unlimited.

## `postedLimit` (type: `string`):

Only scrape posts published within this time period.

## `postedAfterDate` (type: `string`):

Only scrape posts published after this date. Supports ISO format (e.g. 2025-01-01) or timestamps.

## `contentType` (type: `string`):

Only scrape posts with specific content types.

## `sortBy` (type: `string`):

How to sort results.

## `latestPostOnly` (type: `boolean`):

If enabled, only fetches the most recent post for each profile/company. Useful for checking if there are new posts before running a full scrape.

## `includeSharedPosts` (type: `boolean`):

Include posts that someone shared and added their own text on top. For example, when a user reposts an article and writes their opinion about it. Disable this to only get original posts.

## `includeReposts` (type: `boolean`):

Include posts that someone simply reposted as-is, without adding any text of their own. These are the 'repost' button shares with no original commentary. Disable this to only get original posts and quote posts.

## Actor input object example

```json
{
  "profiles": [],
  "companies": [],
  "maxPosts": 0,
  "postedLimit": "none",
  "contentType": "all",
  "sortBy": "date",
  "latestPostOnly": false,
  "includeSharedPosts": true,
  "includeReposts": true
}
```

# Actor output Schema

## `posts` (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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("atomus/linkedin-posts-scraper-pro").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 = {}

# Run the Actor and wait for it to finish
run = client.actor("atomus/linkedin-posts-scraper-pro").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 '{}' |
apify call atomus/linkedin-posts-scraper-pro --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "LinkedIn Posts Scraper ✅ NO COOKIES",
        "description": "Scrape every post from any LinkedIn profile or company page: post text, media, reactions, comments, shares, reposts, author details, and mentions. No LinkedIn account or cookies needed. Auto-pagination handles full feeds, with batch scraping across many profiles in one run.",
        "version": "1.0",
        "x-build-id": "I8GNbChPgNSpO3dCa"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/atomus~linkedin-posts-scraper-pro/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-atomus-linkedin-posts-scraper-pro",
                "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/atomus~linkedin-posts-scraper-pro/runs": {
            "post": {
                "operationId": "runs-sync-atomus-linkedin-posts-scraper-pro",
                "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/atomus~linkedin-posts-scraper-pro/run-sync": {
            "post": {
                "operationId": "run-sync-atomus-linkedin-posts-scraper-pro",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "profiles": {
                        "title": "LinkedIn Usernames or Profile URLs",
                        "type": "array",
                        "description": "LinkedIn profile URLs or usernames. Examples: https://www.linkedin.com/in/satyanadella/ or just satyanadella",
                        "items": {
                            "type": "string"
                        },
                        "default": []
                    },
                    "companies": {
                        "title": "LinkedIn Company Usernames or Company URLs",
                        "type": "array",
                        "description": "LinkedIn company URLs or usernames. Examples: https://www.linkedin.com/company/microsoft/ or just microsoft",
                        "items": {
                            "type": "string"
                        },
                        "default": []
                    },
                    "maxPosts": {
                        "title": "Max Posts per Profile/Company",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of posts to extract per profile or company. 0 = unlimited.",
                        "default": 0
                    },
                    "postedLimit": {
                        "title": "Posted Within",
                        "enum": [
                            "none",
                            "24h",
                            "week",
                            "month"
                        ],
                        "type": "string",
                        "description": "Only scrape posts published within this time period.",
                        "default": "none"
                    },
                    "postedAfterDate": {
                        "title": "Posted After Date",
                        "type": "string",
                        "description": "Only scrape posts published after this date. Supports ISO format (e.g. 2025-01-01) or timestamps."
                    },
                    "contentType": {
                        "title": "Content Type Filter",
                        "enum": [
                            "all",
                            "videos",
                            "images",
                            "documents",
                            "jobs"
                        ],
                        "type": "string",
                        "description": "Only scrape posts with specific content types.",
                        "default": "all"
                    },
                    "sortBy": {
                        "title": "Sort By",
                        "enum": [
                            "date",
                            "relevance"
                        ],
                        "type": "string",
                        "description": "How to sort results.",
                        "default": "date"
                    },
                    "latestPostOnly": {
                        "title": "Latest Post Only",
                        "type": "boolean",
                        "description": "If enabled, only fetches the most recent post for each profile/company. Useful for checking if there are new posts before running a full scrape.",
                        "default": false
                    },
                    "includeSharedPosts": {
                        "title": "Include Quote Posts",
                        "type": "boolean",
                        "description": "Include posts that someone shared and added their own text on top. For example, when a user reposts an article and writes their opinion about it. Disable this to only get original posts.",
                        "default": true
                    },
                    "includeReposts": {
                        "title": "Include Simple Reposts",
                        "type": "boolean",
                        "description": "Include posts that someone simply reposted as-is, without adding any text of their own. These are the 'repost' button shares with no original commentary. Disable this to only get original posts and quote posts.",
                        "default": true
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
