# Linkedin Post Search Scraper (`api-ninja/linkedin-post-search-scraper`) Actor

🔎 Search LinkedIn posts by keyword, then choose a result limit or collect every available result.

- **URL**: https://apify.com/api-ninja/linkedin-post-search-scraper.md
- **Developed by:** [API ninja](https://apify.com/api-ninja) (community)
- **Stats:** 2 total users, 1 monthly users, 50.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.50 / 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.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

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

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

## How to integrate an Actor?

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

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

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

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

# README

### What does LinkedIn Post Search Scraper do?

**LinkedIn Post Search Scraper finds public [LinkedIn](https://www.linkedin.com/) posts by keyword and turns them into a clean, analysis ready dataset.** Enter a search phrase such as `generative AI`, choose how many posts you need, and optionally filter the results by date, content type, author title, company, mentioned organization, or industry.

The Actor extracts post text, author details, publication time, engagement counts, media, articles, hashtags, and links. It also retains the complete source record in `rawData` for advanced workflows. No LinkedIn cookies or account credentials are required as input.

Run it on the [Apify platform](https://apify.com/) to get:

- 🔎 LinkedIn keyword and phrase search
- 🎯 Filters for recent posts, content types, companies, industries, and author titles
- 📊 Normalized post, author, engagement, article, and media data
- ♾️ Automatic pagination with a fixed result limit or **Parse all posts**
- 🔌 API access and integrations with tools such as Google Sheets, Make, Zapier, and webhooks
- 🗓️ Scheduled searches for recurring research and monitoring
- 📈 Run monitoring, logs, reusable datasets, and multiple export formats

### Why use LinkedIn Post Search Scraper?

Searching posts manually takes time and makes comparison difficult. This Actor creates consistent records that can be filtered, exported, analyzed, or sent into another workflow.

Common uses include:

- **Brand monitoring:** find conversations about a company, product, or campaign.
- **Market research:** study topics, customer language, and emerging trends.
- **Content research:** discover popular formats, hashtags, and discussion themes.
- **Lead research:** identify relevant authors and open their public LinkedIn profiles.
- **Competitor tracking:** monitor public posts published by or mentioning selected organizations.
- **Industry analysis:** find posts written by people associated with a matching industry.
- **Reporting:** export engagement and post data for dashboards or spreadsheets.

### How to scrape LinkedIn posts

1. Open the Actor's **Input** tab.
2. Enter a keyword or phrase in **Search query**.
3. Set **Maximum posts**, or enable **Parse all posts** to collect all results reported by the search.
4. Optionally select a content type, sorting method, or open the **Filters** section.
5. Enter company and industry names as ordinary text. The Actor automatically selects the first and best matching LinkedIn result.
6. Click **Start** and follow progress in the run log.
7. Open the **Output** tab to inspect the LinkedIn posts table or download the dataset.

For recurring searches, create an Apify schedule and connect the resulting dataset to your preferred storage or automation tool.

### Input

The only required field is `query`. The following example finds recent AI posts associated with Google and the technology industry:
![Input Schema](https://i.ibb.co/ZphzG6cL/input-schema.jpg)

```json
{
    "query": "generative AI",
    "maxPosts": 100,
    "parseAll": false,
    "sort": "date_posted",
    "datePosted": "past-week",
    "contentType": "photos",
    "authorTitle": "Product Marketing Manager",
    "fromOrg": "Google",
    "authorCompany": "Google",
    "mentioningOrg": "OpenAI",
    "authorIndustry": "Technology"
}
```

| Input field      | Type    | Description                                                                         |
| ---------------- | ------- | ----------------------------------------------------------------------------------- |
| `query`          | String  | Required keyword or phrase used to search LinkedIn posts.                           |
| `maxPosts`       | Integer | Maximum posts to save when `parseAll` is disabled. Default: `100`.                  |
| `parseAll`       | Boolean | Continues through all reported results when enabled.                                |
| `sort`           | String  | Sort by `relevance` or `date_posted`.                                               |
| `contentType`    | String  | Filter for videos, photos, jobs, live videos, documents, or collaborative articles. |
| `datePosted`     | String  | Limit results to the past 24 hours, week, or month.                                 |
| `authorTitle`    | String  | Match words in the author's professional title.                                     |
| `fromOrg`        | String  | Company name whose organization posts should be returned.                           |
| `authorCompany`  | String  | Company name associated with the post author.                                       |
| `mentioningOrg`  | String  | Company name that must be mentioned in the post.                                    |
| `authorIndustry` | String  | Industry name or keyword associated with the author.                                |

Company and industry fields accept **one name each**. A lookup can return several candidates, so the Actor applies the first matching result. Use the full company or industry name for the most accurate match.

### Output

Every matching post is stored as one dataset item. The **LinkedIn posts** table highlights the most useful columns, while **All fields** provides every normalized value and the complete `rawData` object.

![Output example](https://i.ibb.co/MkZD08dM/SCR-20260919-nvan.png)

Example output, shortened for readability:

```json
{
    "searchQuery": "generative AI",
    "postText": "Three practical lessons from our latest generative AI project... #AI",
    "postUrl": "https://www.linkedin.com/posts/example_activity-1234567890",
    "postType": "IMAGE",
    "publishedAt": "2026-09-18T09:42:10.000Z",
    "publishedText": "1 day ago • Visible to anyone on or off LinkedIn",
    "authorName": "Alex Morgan",
    "authorHeadline": "Product Marketing Manager",
    "authorType": "PERSON",
    "authorUrl": "https://www.linkedin.com/in/example",
    "authorImageUrl": "https://media.licdn.com/example-profile-image",
    "reactions": 284,
    "reactionBreakdown": {
        "LIKE": 230,
        "PRAISE": 34,
        "INTEREST": 20
    },
    "comments": 19,
    "shares": 7,
    "mediaPreviewUrl": "https://media.licdn.com/example-post-image",
    "imageUrls": ["https://media.licdn.com/example-post-image"],
    "hashtags": ["#AI"],
    "isArticle": false,
    "isRepost": false,
    "visibility": "PUBLIC",
    "postUrn": "urn:li:ugcPost:1234567890",
    "activityUrn": "urn:li:activity:1234567890",
    "rawData": {
        "postId": "urn:li:ugcPost:1234567890",
        "update": "Complete original source object is stored here"
    }
}
```

You can download the dataset in various formats such as **JSON, HTML, CSV, or Excel**. You can also access results through the Apify API without downloading a file.

### LinkedIn post data fields

| Category           | Main fields                                                                                         | Description                                                                     |
| ------------------ | --------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------- |
| Search             | `searchQuery`                                                                                       | The keyword or phrase used for the run.                                         |
| Post               | `postText`, `postUrl`, `postType`, `postUrn`, `activityUrn`                                         | Main post content, link, type, and identifiers.                                 |
| Publication        | `publishedAt`, `publishedText`, `visibility`                                                        | Calculated timestamp, displayed relative time, and audience.                    |
| Author             | `authorName`, `authorHeadline`, `authorType`, `authorId`, `authorUrl`, `authorImageUrl`             | Public author identity and profile details.                                     |
| Engagement         | `reactions`, `reactionBreakdown`, `comments`, `shares`, `views`, `impressions`                      | Available interaction and reach metrics.                                        |
| Images and video   | `mediaPreviewUrl`, `mediaUrl`, `imageUrls`, `videoUrl`, `videoThumbnailUrl`, `videoDurationSeconds` | Media previews and direct media details when available.                         |
| Documents          | `documentTitle`, `documentUrl`, `documentPageCount`, `documentCoverUrl`                             | LinkedIn document metadata and cover.                                           |
| Articles           | `articleTitle`, `articleDescription`, `articleUrl`, `isArticle`                                     | Article or newsletter details.                                                  |
| Text analysis      | `hashtags`, `contentLinks`                                                                          | Hashtags and URLs detected in the post text.                                    |
| Reposts and groups | `isRepost`, `groupName`, `originalAuthorName`, `originalPostText`, `originalPostUrl`                | Context for reposted or group content.                                          |
| Source             | `rawData`                                                                                           | Complete original post object for fields not included in the normalized output. |

Some LinkedIn posts do not expose every field. Missing media, view counts, impression counts, or article details are omitted from that dataset item.

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

This Actor uses **pay-per-event pricing** with a **$0.10 minimum total charge per run**.

| Charge | Free plan | Bronze-Diamond plans |
| --- | ---: | ---: |
| Actor start | $0.01 | $0.01 |
| Result saved to the default dataset | $0.015 per result | $0.0015 per result |

The Actor start event is charged once per GB of memory, with at least one event per run. The final cost depends mainly on how many matching post records are saved. Start with the default limit and a focused query, and enable **Parse all posts** only when you need the complete result set. Check the Actor's **Pricing** tab for the latest rates before starting a large run.

### Tips for better LinkedIn search results

- Use a focused phrase such as `AI customer support` instead of a very broad word such as `software`.
- Select **Date posted** sorting and a recent date range for monitoring workflows.
- Enter complete company names so the first automatic match is the intended organization.
- Run separate searches when you need several companies or industries. Each company and industry field accepts one name.
- Set a practical maximum during testing, then increase it after confirming the filters.
- Use **Parse all posts** for exhaustive research and scheduled monitoring where a changing result count is acceptable.
- Read the run log to see which company and industry matches were selected.
- Use `rawData` when a specialized field is not part of the normalized dataset columns.

### Other LinkedIn Scraping Tools

If you like this Actor, you might also find these LinkedIn tools useful:

- 👤 **[LinkedIn Profile Posts Scraper](https://apify.com/api-ninja/linkedin-profile-posts-scraper)**: Collect public posts published by LinkedIn member profiles.
- 💡 **[LinkedIn Post Reactions Scraper](https://apify.com/api-ninja/linkedin-post-reactions-scraper)**: Collect people who reacted to a post and their reaction types.
- 💼 **[LinkedIn Jobs Scraper](https://apify.com/api-ninja/linkedin-jobs-scraper)**: Search and extract structured LinkedIn job listings.
- 🏢 **[LinkedIn Company Posts Scraper](https://apify.com/api-ninja/linkedin-company-posts-scraper)**: Collect posts, media, authors, and engagement from company pages.
- 💬 **[LinkedIn Post Comments Scraper](https://apify.com/api-ninja/linkedin-post-comments-scraper)**: Extract comments and optional replies from public posts.
- 🔁 **[LinkedIn Post Reposters Scraper](https://apify.com/api-ninja/linkedin-post-reposters-scraper)**: Find people and companies that reposted a public post.

### FAQ, limitations, and support

#### Can I use LinkedIn Post Search Scraper through an API?

Yes. Every Actor can be started through the [Apify API](https://docs.apify.com/api/v2), and its dataset can be retrieved programmatically. You can also use webhooks, schedules, and integrations without changing the Actor input.

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

No LinkedIn account, cookie, or password is required in the Actor input.

#### Why did a company or industry filter select an unexpected result?

LinkedIn matching can return several candidates. The Actor uses the first result, so short or ambiguous names can select a different organization or industry. Enter the full official name and check the matching message in the run log.

#### Why are some output fields missing?

LinkedIn exposes different structures for text posts, images, videos, documents, articles, reposts, and group posts. Engagement and media fields can also be unavailable. The Actor keeps the complete source record in `rawData` whenever you need to inspect additional values.

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

Scraping publicly available data can be lawful, but requirements vary by country and use case. You are responsible for complying with applicable laws, privacy rules, LinkedIn's terms, and the rights of data subjects. Avoid collecting or using personal data without a valid purpose.

#### What if I need another field or a custom LinkedIn workflow?

Use the Actor page's **Issues** tab to report a problem, request a field, or suggest an improvement. Custom solutions and integrations based on this Actor are also available; describe the desired input, output, volume, and destination in your request.

# Actor input Schema

## `query` (type: `string`):

Keywords or phrase to search for in LinkedIn posts.

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

Only return this type of post.

## `sort` (type: `string`):

Order returned by the search API.

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

Maximum number of raw posts to save. Ignored when Parse all posts is enabled.

## `parseAll` (type: `boolean`):

Continue until all reported search results are fetched or the API returns an empty page.

## `authorTitle` (type: `string`):

Filter by the author's professional title.

## `datePosted` (type: `string`):

Only posts from the selected time period.

## `fromOrg` (type: `string`):

Company name to filter posts published by an organization. The first matching LinkedIn company is used.

## `authorCompany` (type: `string`):

Company name to filter authors by employer. The first matching LinkedIn company is used.

## `mentioningOrg` (type: `string`):

Company name that must be mentioned in a post. The first matching LinkedIn company is used.

## `authorIndustry` (type: `string`):

Industry name or keyword used to filter post authors. The first matching LinkedIn industry is used.

## Actor input object example

```json
{
  "query": "chat",
  "sort": "relevance",
  "maxPosts": 100,
  "parseAll": false
}
```

# Actor output Schema

## `results` (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 = {
    "query": "chat"
};

// Run the Actor and wait for it to finish
const run = await client.actor("api-ninja/linkedin-post-search-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 = { "query": "chat" }

# Run the Actor and wait for it to finish
run = client.actor("api-ninja/linkedin-post-search-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "query": "chat"
}' |
apify call api-ninja/linkedin-post-search-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,api-ninja/linkedin-post-search-scraper"
        }
    }
}
```

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

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/JR9wvDEeohdoE6pPQ/builds/nScZanPNGvjMe6oQz/openapi.json
