# LinkedIn Post Search Scraper | Keywords & Engagement (`crawlkite/linkedin-post-search`) Actor

Search LinkedIn posts by keywords, authors, companies and content filters. Export post content and engagement, with optional comments, reactions and author details.

- **URL**: https://apify.com/crawlkite/linkedin-post-search.md
- **Developed by:** [CrawlKite](https://apify.com/crawlkite) (community)
- **Categories:** Lead generation, Social media
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.35 / 1,000 posts

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
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

## LinkedIn Post Search Scraper | Keywords & Engagement

Find LinkedIn posts by keyword and supported author, company or content filters. CrawlKite returns structured content and engagement data for social listening, topic discovery and account research, with optional comment, reaction and main-profile enrichment.

### Key Benefits

- **No customer cookies or LinkedIn login:** provide targets or search filters without uploading session credentials.
- **Usage-based pricing:** from $1.35 per 1,000 posts on Business. Optional engagement and enrichment are additional.
- **Structured exports:** keep nested fields in JSON or select columns for CSV and Excel.
- **Use case:** Find relevant conversations around a product, topic or market.
- **Use case:** Research content from selected authors or companies.
- **Use case:** Build structured exports for content analysis and prospect research.

### How It Works

1. Enter keywords or phrases in `searchQueries` and optionally add supported author, company or content filters.
2. Choose `date` or `relevance` sorting and set `maxPosts` per query. Use `maxResults` to cap primary results across the run.
3. Optionally collect comments, reactions or main-profile author details. Each selected add-on has its own charge.
4. Set a spending limit, run the actor and inspect the resulting dataset before increasing volume.

#### Example input

```json
{
  "searchQueries": [
    "Hiring software engineer"
  ],
  "maxPosts": 20,
  "sortBy": "date"
}
```

#### Key input options

| Input | How to use it |
|---|---|
| `searchQueries` | Keywords or phrases to search. Each string is a separate query. |
| `maxPosts` | Maximum posts per query. Use maxResults for a run-wide primary-result cap. |
| `sortBy` | date or relevance. |
| `authorUrls / authorsCompanies` | Restrict the search to supported author or author-company filters. |
| `contentType` | all, videos, images, jobs, live_videos, documents or collaborative_articles. |
| `scrapeComments / scrapeReactions` | Optional engagement collection; limit each with maxComments or maxReactions. |
| `profileScraperMode` | short author details, or separately priced main-profile enrichment. |

Use the **Input** tab for the full list of controls, defaults and accepted values.

#### Example: collect posts with comments and reactions

This input requests at most two posts and, for each post, up to five comments and five reactions. Each delivered post, comment and reaction is billed separately.

```json
{
  "searchQueries": [
    "Hiring software engineer"
  ],
  "sortBy": "date",
  "maxPosts": 2,
  "maxResults": 2,
  "scrapeComments": true,
  "maxComments": 5,
  "scrapeReactions": true,
  "maxReactions": 5
}
```

#### Comments, reactions and author details

Enable scrapeComments or scrapeReactions and choose a per-post limit. Collected items appear as separate dataset rows. postNestedComments and postNestedReactions also embed copies inside each post, without charging twice for the copy. Choose main mode for separately priced profile enrichment of authors, commenters or reactors.

Use maxPosts for a per-target or per-query limit and maxResults for a total run cap. maxPosts overrides scrapePages; without maxPosts, scrapePages controls post-search pagination. With engagement enabled, maxComments or maxReactions set to 0 collects all available items within the run limits. Profile-post runs embed collected engagement by default; post search uses the postNestedComments and postNestedReactions switches. A zero maxPosts value continues only until source exhaustion or your request, page, spending and result safety limits. Leave contextCountry set to any with the standard connection; other regional contexts require additional configuration.

### Data You'll Receive

| Fields | What they contain |
|---|---|
| type, id, linkedinUrl | Record type, identifier and URL |
| content, author, postedAt | Post content, author fields and date |
| engagement, media fields | Available engagement counts and media |
| query, commentIds, reactionIds | Available search context and collected add-on IDs |

Available fields retain their nested structure. Values can be absent or empty. The optional `_crawlkite` metadata object is disabled by default. Media links and source data can change after collection.

### Sample output

Results are stored as individual records in the run's **dataset**. A JSON export wraps those records in an array. The example below is illustrative, shortened and uses fictional names and IDs; it shows the output structure, not a real person or a guaranteed set of populated fields.

```json
[
  {
    "type": "post",
    "id": "example-post-id",
    "linkedinUrl": "https://www.linkedin.com/feed/update/urn:li:activity:1234567890123456789/",
    "content": "We are hiring software engineers to help build our next product.",
    "author": {
      "type": "profile",
      "name": "Jane Example",
      "linkedinUrl": "https://www.linkedin.com/in/jane-example",
      "publicIdentifier": "jane-example"
    },
    "postedAt": {
      "date": "2026-11-01T09:00:00.000Z",
      "timestamp": 1793523600000
    },
    "engagement": {
      "likes": 42,
      "comments": 8,
      "shares": 3,
      "reactions": [
        {
          "type": "LIKE",
          "count": 42
        },
        {
          "type": "EMPATHY",
          "count": 3
        }
      ]
    },
    "postImages": [],
    "commentIds": [],
    "reactionIds": []
  }
]
```

#### Optional comments and reactions

When enabled, comments and reactions are **separate dataset records**, each with a `type` field. For example, this export contains one comment and one reaction associated with a post:

```json
[
  {
    "type": "comment",
    "id": "example-comment-id",
    "postId": "example-post-id",
    "commentary": "Thank you for sharing this opportunity.",
    "createdAt": "2026-11-01T10:00:00.000Z",
    "actor": {
      "name": "Alex Example",
      "linkedinUrl": "https://www.linkedin.com/in/alex-example"
    }
  },
  {
    "type": "reaction",
    "id": "example-reaction-id",
    "postId": "example-post-id",
    "reactionType": "LIKE",
    "actor": {
      "name": "Alex Example",
      "linkedinUrl": "https://www.linkedin.com/in/alex-example"
    }
  }
]
```

Dataset order is not guaranteed. Filter by `type` to separate posts, comments and reactions. A post's `engagement.comments` value is a reported count, not the number of comment records this run collected. For example, a post can report 500 comments while your `maxComments: 5` setting collects at most five. Missing or restricted source data can reduce that further.

### CrawlKite pricing

The actor's Apify Pricing tab is authoritative. The table below shows actor usage rates by Apify plan. Platform subscriptions are separate from actor usage.

| Operation / billing unit | Free | Starter | Scale | Business |
|---|---:|---:|---:|---:|
| Posts / 1,000 posts | $1.80 | $1.80 | $1.575 | $1.35 |
| Comments or reactions / 1,000 items | $1.80 | $1.80 | $1.575 | $1.35 |
| Main-profile enrichment / 1,000 profiles | $1.80 | $1.80 | $1.62 | $1.40 |

#### Pricing comparison with HarvestAPI

The rates below are 10% below the corresponding HarvestAPI rates for the operations shown below, except Business full profiles (6.25% lower) and Business main profiles (6.67% lower), where applicable. This compares individual billing events, not the total cost of every possible run or a guarantee of identical data coverage.

| Operation / billing unit | Apify plan | CrawlKite | HarvestAPI | Lower by |
|---|---|---:|---:|---:|
| Posts / 1,000 posts | Free | $1.80 | $2.00 | 10% |
| Posts / 1,000 posts | Starter | $1.80 | $2.00 | 10% |
| Posts / 1,000 posts | Scale | $1.575 | $1.75 | 10% |
| Posts / 1,000 posts | Business | $1.35 | $1.50 | 10% |
| Comments or reactions / 1,000 items | Free | $1.80 | $2.00 | 10% |
| Comments or reactions / 1,000 items | Starter | $1.80 | $2.00 | 10% |
| Comments or reactions / 1,000 items | Scale | $1.575 | $1.75 | 10% |
| Comments or reactions / 1,000 items | Business | $1.35 | $1.50 | 10% |
| Main-profile enrichment / 1,000 profiles | Free | $1.80 | $2.00 | 10% |
| Main-profile enrichment / 1,000 profiles | Starter | $1.80 | $2.00 | 10% |
| Main-profile enrichment / 1,000 profiles | Scale | $1.62 | $1.80 | 10% |
| Main-profile enrichment / 1,000 profiles | Business | $1.40 | $1.50 | 6.67% |

Comparison checked on 1 November 2026 against [HarvestAPI's corresponding actor pricing](https://apify.com/harvestapi/linkedin-post-search/pricing). Rates can change. Full-profile prices in post enrichment use the [profile actor comparison](https://apify.com/harvestapi/linkedin-profile-scraper/pricing). This table covers Free, Starter, Scale and Business. Optional enrichment and engagement are separately priced; short people-search results are billed per search page, not per profile. There is no separate actor-start charge. Free-plan trials have stricter request and result caps.

Email search is charged for the requested enrichment operation and does not guarantee a found email. Additional search/probe pages, filters and requested add-ons can affect total usage. CrawlKite and HarvestAPI are independent services; CrawlKite is not affiliated with HarvestAPI.

#### Billing example

On Starter, 100 posts cost **100 × $0.0018 = $0.18**. If you also collect 200 comments and 100 reactions, add **300 × $0.0018 = $0.54**, for **$0.72 total**. Main-profile enrichment, when selected, adds its own profile charge. Asking for 200 posts sets a maximum; billing uses delivered items, not a flat page price.

These examples use the Starter actor rates below and exclude your Apify subscription. Check the **Pricing** tab and set a run spending limit. Free-plan runs have stricter request and result caps; they cannot be used to reproduce these larger examples.

### LinkedIn Post Search Scraper API

Use the **API** tab for your actor's generated integration examples. You can run the same input from an application and retrieve dataset items through the Apify API.

For a small synchronous request, the following Bash example returns dataset items as JSON. Replace the placeholder with your Apify token and keep it out of public code:

```bash
curl --request POST \
  'https://api.apify.com/v2/acts/crawlkite~linkedin-post-search/run-sync-get-dataset-items' \
  --header 'Authorization: Bearer YOUR_APIFY_TOKEN' \
  --header 'Content-Type: application/json' \
  --data '{"searchQueries":["Hiring software engineer"],"maxPosts":20,"sortBy":"date"}'
```

For longer jobs, use the asynchronous run endpoint shown in the API tab, wait for the run to finish, and retrieve its dataset. Set a spending limit before running at scale. You can also schedule exports or connect Apify to n8n, Make or Zapier.

### Frequently Asked Questions

#### Does requesting 200 posts guarantee 200 unique results?

No. maxPosts is a maximum per query. Available results, overlapping pages, filters, spending limits and request limits can produce fewer unique posts.

#### Why are there fewer results than requested?

Requested counts are maximums. Source availability, filters, duplicate removal, pagination and spending/request limits can reduce the export. Check the run's SUMMARY for results, errors and its stopping reason. Free-plan runs also have stricter request and result caps.

#### How do I export the results?

Open the completed run's dataset and choose JSON, CSV or Excel. JSON preserves nested objects and arrays. Select or flatten the fields you need for a CRM or spreadsheet workflow.

### Support and Feedback

Create an issue in this actor's **Issues** tab with the run ID, what you expected, and a redacted input example. Review the SUMMARY and ERRORS records first. Do not include passwords, API tokens or MongoDB connection strings. If a run crashes, inspect its existing dataset and billing events before retrying; output and charges are not guaranteed to occur exactly once across a crash.

### More LinkedIn Tools from CrawlKite

- [LinkedIn Profile Scraper + Email](https://apify.com/crawlkite/linkedin-profile-scraper) — Enrich CRM contacts with current roles, work history and education.
- [LinkedIn Company Scraper](https://apify.com/crawlkite/linkedin-company) — Enrich company records with websites, industries and employee counts.
- [LinkedIn Profile & Company Posts Scraper](https://apify.com/crawlkite/linkedin-profile-posts) — Track the content published by target profiles and company pages.
- [LinkedIn People Search Scraper + Email](https://apify.com/crawlkite/linkedin-profile-search) — Build prospect lists using company, location and role filters.

Explore [CrawlKite's LinkedIn API collection](https://apify.com/crawlkite) for connected profile, company, content and people-search workflows.

Collect and use data only for authorized purposes and follow applicable privacy requirements.

# Actor input Schema

## `searchQueries` (type: `array`):

Post search queries. Optional control for your CrawlKite run.

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

Per input target or query. 0 continues until request/page/result safety limits or source exhaustion. Returned unique results can be fewer than requested.

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

postedLimit. Optional control for your CrawlKite run.

## `postedLimitDate` (type: `string`):

Oldest post date. Optional control for your CrawlKite run.

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

sortBy. Optional control for your CrawlKite run.

## `authorUrls` (type: `array`):

Profile or company authors. Optional control for your CrawlKite run.

## `authorsCompanies` (type: `array`):

Authors’ companies. Optional control for your CrawlKite run.

## `mentioningMember` (type: `array`):

mentioningMember. Optional control for your CrawlKite run.

## `mentioningCompany` (type: `array`):

mentioningCompany. Optional control for your CrawlKite run.

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

contentType. Optional control for your CrawlKite run.

## `authorsIndustryId` (type: `array`):

authorsIndustryId. Optional control for your CrawlKite run.

## `authorKeywords` (type: `string`):

authorKeywords. Optional control for your CrawlKite run.

## `profileScraperMode` (type: `string`):

Choose short author details or separately billed main-profile enrichment.

## `startPage` (type: `integer`):

startPage. Optional control for your CrawlKite run.

## `scrapePages` (type: `integer`):

Maximum pages. 0 uses the 100-page safety limit.

## `scrapeReactions` (type: `boolean`):

scrapeReactions. Optional control for your CrawlKite run.

## `maxReactions` (type: `integer`):

Per-post limit. 0 collects all available items within run request and spending limits. Each delivered root item is billed separately.

## `reactionsProfileScraperMode` (type: `string`):

reactionsProfileScraperMode. Optional control for your CrawlKite run.

## `postNestedReactions` (type: `boolean`):

Also embed collected items inside each post. Separate dataset rows are retained; nested copies do not add a second item charge.

## `scrapeComments` (type: `boolean`):

scrapeComments. Optional control for your CrawlKite run.

## `commentsPostedLimit` (type: `string`):

Comment age limit. Optional control for your CrawlKite run.

## `maxComments` (type: `integer`):

Per-post limit. 0 collects all available items within run request and spending limits. Each delivered root item is billed separately.

## `commentsProfileScraperMode` (type: `string`):

commentsProfileScraperMode. Optional control for your CrawlKite run.

## `postNestedComments` (type: `boolean`):

Also embed collected items inside each post. Separate dataset rows are retained; nested copies do not add a second item charge.

## `maxResults` (type: `integer`):

Optional total result safety cap across every input.

## `maxRequests` (type: `integer`):

Optional total supplier request safety cap; default 10,000.

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

Optional page safety cap per input; up to 100 pages.

## `filters` (type: `object`):

Legacy CrawlKite input name; still accepted.

## `includeCrawlKiteMetadata` (type: `boolean`):

Opt in to the extra \_crawlkite object. Leave disabled for source-shaped output.

## Actor input object example

```json
{
  "searchQueries": [
    "Hiring software engineer"
  ],
  "maxPosts": 20,
  "sortBy": "date",
  "profileScraperMode": "short",
  "startPage": 1,
  "maxReactions": 10,
  "reactionsProfileScraperMode": "short",
  "maxComments": 10,
  "commentsProfileScraperMode": "short",
  "includeCrawlKiteMetadata": false
}
```

# Actor output Schema

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

No description

## `summary` (type: `string`):

No description

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "searchQueries": [
        "Hiring software engineer"
    ],
    "maxPosts": 20,
    "sortBy": "date"
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlkite/linkedin-post-search").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 = {
    "searchQueries": ["Hiring software engineer"],
    "maxPosts": 20,
    "sortBy": "date",
}

# Run the Actor and wait for it to finish
run = client.actor("crawlkite/linkedin-post-search").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 '{
  "searchQueries": [
    "Hiring software engineer"
  ],
  "maxPosts": 20,
  "sortBy": "date"
}' |
apify call crawlkite/linkedin-post-search --silent --output-dataset

```

## MCP server setup

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

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/zNIYSGzAd2eGyyFWC/builds/rbgCqC8zs5b8KtrHG/openapi.json