# LinkedIn Public Post Search Scraper (`automation-lab/linkedin-public-post-search-scraper`) Actor

Search public LinkedIn posts by keyword, author or company. Get full post text, author, date, images/video, reactions and comment counts with stable post IDs. No login or cookies.

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

## Pricing

from $0.96 / 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 Public Post Search Scraper

Search public LinkedIn posts by keyword, author or company and export each post with its full text, author, publish date, images or video, reaction and comment counts, and a stable post ID. No LinkedIn account, login or cookies are needed.

Give the Actor a list of search queries (for example `generative AI` or `"supply chain" hiring`), optionally limit them to specific people or companies, choose a date window, and get one clean, deduplicated record per post. Posts found by several of your queries are returned once, with every matching query listed.

### What does LinkedIn Public Post Search Scraper do?

- 🔎 **Keyword search for public posts** — finds public LinkedIn posts that match your keywords, phrases or `OR` alternatives.
- 👤 **Author and company filter** — restrict results to posts published by given profile (`/in/...`) or company (`/company/...`) URLs, with or without keywords.
- 📅 **Date window** — past 24 hours, week, month or year, or an exact `postedAfter` / `postedBefore` range checked against each post's real publish time.
- 🧾 **Full post data** — post text, headline, hashtags, author name, type, profile URL and follower count, publish time, image and video links, reactions and comments.
- 🧬 **Deduplication across queries** — overlapping queries never produce duplicate rows; `matchedQueries` shows every search that found a post.
- 🔁 **Incremental monitoring** — set an incremental state key and later runs skip posts you already received, so scheduled runs only return and bill new posts.
- 🔓 **No login** — only public pages are read. You never share a LinkedIn account or cookie.

### Who is it for?

- **B2B marketers and social listening teams** tracking what people post about a topic, a product category or a competitor, every day.
- **Sales and SDR teams** looking for buying-intent posts ("looking for a CRM", "we are hiring a data engineer") and the people who wrote them.
- **Recruiters** finding "open to work" and hiring posts in a niche.
- **PR, comms and brand teams** monitoring mentions of a brand or campaign hashtag.
- **Researchers and analysts** building datasets of public professional discussion on a theme.
- **Founders and investors** watching what a list of executives or companies posts about.

### Why use this LinkedIn post search scraper?

- **No account risk.** Many LinkedIn post tools need your session cookie. This Actor reads public pages only, so no account can be restricted.
- **Clean, stable IDs.** Every record carries the LinkedIn activity ID (`postId`) and URN, so you can deduplicate and join across runs and tools.
- **One row per post, even with overlapping queries.** Run `generative AI`, `GenAI` and `AI agents` together and each post appears once.
- **Built for schedules.** The incremental state key plus a posted-after date make daily or weekly exports simple: only new posts are saved and billed.
- **Fresh author posts.** For author and company filters the Actor also reads the public profile or company page, which lists the latest posts before search engines index them.

### What data can you extract from LinkedIn posts?

| Field | Description |
| --- | --- |
| `postId` | Stable LinkedIn activity ID, for example `7521538814591492096` |
| `postUrn` | `urn:li:activity:<postId>` |
| `shareUrn` | Underlying share or ugcPost URN when shown |
| `url` | Canonical public post URL on `www.linkedin.com` |
| `postType` | `post` (text, image, document) or `video` |
| `text` | Full public post text |
| `headline` | First line / headline LinkedIn shows |
| `hashtags` | Lowercase hashtags in the text |
| `author.name` | Person or company name |
| `author.type` | `person` or `company` |
| `author.publicIdentifier` | LinkedIn vanity name, for example `satyanadella` |
| `author.url` | Public profile or company URL |
| `author.followers` | Follower count shown on the post page |
| `author.imageUrl` | Avatar or logo URL |
| `postedAt` | Publish time in ISO 8601 (UTC) |
| `postedAtTimestamp` | Publish time in milliseconds |
| `media` | Image URLs, or the video URL with thumbnail and duration |
| `engagement.reactions` | Public reaction count |
| `engagement.comments` | Public comment count |
| `topComments` | Optional: up to 20 public comments (author, text, date, likes) |
| `matchedQueries` | Every search that found this post |
| `searchRank` | Order in which the post was first found |
| `collectedAt` | When the run collected the post |

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

The Actor uses pay-per-event pricing. You pay a small fee when a run starts and a fee for each post saved to the dataset. Posts that fail to load, fall outside your date window, or were already returned for your incremental state key are not charged.

| Event | Price (Free plan) | Price (Bronze) | Price (Silver) | Price (Gold and higher) |
| --- | --- | --- | --- | --- |
| Run start | $0.001 | $0.001 | $0.001 | $0.001 |
| Post saved | $0.00184 | $0.0016 | $0.001248 | $0.00096 |

Examples on the Bronze tier:

- 25 posts for one topic: $0.001 + 25 × $0.0016 = **$0.041**
- 100 posts across four topics: $0.001 + 100 × $0.0016 = **$0.161**
- 1,000 posts in a weekly export: $0.001 + 1,000 × $0.0016 = **$1.601**

Apify's free plan includes monthly platform credit, which covers small test runs. You can cap spending in the run options with **Maximum cost per run**; the Actor stops cleanly when the limit is reached.

### How to scrape LinkedIn posts by keyword

1. Open the Actor in Apify Console and click **Try for free**.
2. Enter one or more **Search queries**, for example `generative AI` and `"supply chain" hiring`.
3. Optional: add **Author or company URLs** to keep only posts by those people or companies.
4. Pick **Date posted** (for example *Past week*) or set **Posted after** / **Posted before**.
5. Set **Max posts per search** (default 25).
6. Click **Start**. Results stream into the dataset; open the **Posts** view or export to JSON, CSV or Excel.
7. For monitoring, set an **Incremental state key** and schedule the Actor daily.

### Input parameters

| Parameter | Type | Description |
| --- | --- | --- |
| `searchQueries` | array of strings | Keywords or phrases. Quote a phrase to require it; use `OR` between alternatives. Each query is a separate search. |
| `authorUrls` | array of strings | Profile or company URLs. Each author is combined with each query (author AND query). |
| `datePosted` | `any`, `past-24h`, `past-week`, `past-month`, `past-year` | Relative date window. Ignored when an explicit date is set. |
| `postedAfter` | `YYYY-MM-DD` | Keep posts published on or after this UTC day. |
| `postedBefore` | `YYYY-MM-DD` | Keep posts published on or before this UTC day. |
| `sortBy` | `relevance` or `date` | Search order (streamed) or newest first (saved at the end). |
| `maxPostsPerQuery` | integer 1–500 | Post URLs collected per search. Default 25. |
| `maxPostsTotal` | integer | Total limit for the run; 0 means no total limit. |
| `region` | string | Search index region, for example `us-en`, `uk-en`, `de-de`; `wt-wt` = no preference. |
| `includeComments` | boolean | Add up to 20 public comments per post. Included in the post price. |
| `incrementalStateKey` | string | Remember returned post IDs and skip them in later runs with the same key. |

Example input:

```json
{
    "searchQueries": ["generative AI", "\"supply chain\" hiring"],
    "authorUrls": [],
    "datePosted": "past-month",
    "sortBy": "relevance",
    "maxPostsPerQuery": 25,
    "includeComments": false
}
```

### Output example

```json
{
    "postId": "7514387992522727424",
    "postUrn": "urn:li:activity:7514387992522727424",
    "shareUrn": "urn:li:share:7514387991436529664",
    "url": "https://www.linkedin.com/posts/umn-ai-hub_meet-one-of-our-2026-wiads-speakers-jothsna-activity-7514387992522727424-PaAW",
    "postType": "post",
    "text": "✨Meet one of our 2026 WiADS speakers:\n\nJothsna Praveena Pendyala is an AI Platform Architect and Senior Data Scientist...",
    "headline": "✨Meet one of our 2026 WiADS speakers:",
    "hashtags": [],
    "author": {
        "name": "University of Minnesota AI Hub",
        "type": "company",
        "publicIdentifier": "umn-ai-hub",
        "url": "https://www.linkedin.com/showcase/umn-ai-hub",
        "followers": 2555,
        "imageUrl": "https://media.licdn.com/dms/image/v2/D560BAQEGnzLGSs19BQ/company-logo_100_100/..."
    },
    "postedAt": "2026-10-09T18:15:07.994Z",
    "postedAtTimestamp": 1791569707994,
    "media": [
        { "type": "image", "url": "https://media.licdn.com/dms/image/v2/D5622AQHmixaybmqpYQ/feedshare-shrink_800/..." }
    ],
    "engagement": { "reactions": 72, "comments": 0 },
    "matchedQueries": ["generative AI agents", "generative AI"],
    "searchRank": 21,
    "collectedAt": "2026-10-30T07:23:55.225Z"
}
```

Each run also writes a `RUN_SUMMARY` record to the default key-value store with the number of searches, unique posts found, posts saved, and posts skipped (out of the date window, already seen, or not loadable).

### How does it work?

1. For every query (and author + query combination) the Actor searches a public web index restricted to `linkedin.com/posts`, page by page, until **Max posts per search** is reached or results run out.
2. For author filters it also reads the public profile or company page and adds the author's latest posts. Those posts are kept only if their text contains your keywords as whole words.
3. Post URLs found by several searches are merged into one candidate.
4. Each public post page is read once to extract the full text, author, date, media and engagement from LinkedIn's public structured data.
5. The exact publish date is checked against your window, already-seen posts are skipped, and the remaining posts are saved and charged.

### Tips and limitations

- **Coverage follows the public index.** The Actor finds posts that are public and indexed by search engines. It is not LinkedIn's logged-in search, so it will not see every post, and very new posts may take hours or days to appear in keyword results. Author and company filters also read the author's page to catch the newest posts.
- **Fewer results than the limit is normal** for narrow queries, tight date windows or rare phrases.
- **Keyword matching** happens in the search index (title, text or URL slug). Quoted phrases and `OR` work; other LinkedIn search operators do not.
- **Engagement counts** are public totals at collection time: reactions and comments. Repost counts are not shown on public pages.
- **Deleted or private posts** are skipped without charge.
- **Sort by date** reads every found post before saving, so results appear at the end of the run.
- Use several short queries rather than one long query for better coverage.

### Integrations

- **Google Sheets or Excel:** schedule a daily run with `datePosted: past-24h` and an incremental state key, then send the dataset to a sheet with Apify's Google Sheets integration.
- **Slack or email alerts:** use a webhook on run success to post new buying-intent posts to a sales channel.
- **CRM enrichment:** push `author.url` and `postId` into HubSpot or Salesforce through Make or Zapier to log social touchpoints.
- **Data warehouse:** export JSON to BigQuery or Snowflake and deduplicate on `postId`.
- **LLM pipelines:** feed `text` and `hashtags` to a classifier for topic, sentiment or intent scoring.

### Use the API

#### cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/automation-lab~linkedin-public-post-search-scraper/run-sync-get-dataset-items?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"searchQueries": ["generative AI"], "datePosted": "past-week", "maxPostsPerQuery": 25}'
```

#### JavaScript

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

const client = new ApifyClient({ token: 'YOUR_APIFY_TOKEN' });
const run = await client.actor('automation-lab/linkedin-public-post-search-scraper').call({
    searchQueries: ['generative AI', '"supply chain" hiring'],
    datePosted: 'past-week',
    maxPostsPerQuery: 25,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items.map((post) => [post.postedAt, post.author.name, post.url]));
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("automation-lab/linkedin-public-post-search-scraper").call(run_input={
    "searchQueries": ["generative AI"],
    "authorUrls": ["https://www.linkedin.com/company/hubspot"],
    "datePosted": "past-month",
})
for post in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(post["postedAt"], post["author"]["name"], post["engagement"]["reactions"], post["url"])
```

### Use with AI agents via MCP

Connect this Actor to Claude, Cursor or another MCP client through the Apify MCP server.

Claude Code:

```bash
claude mcp add --transport http apify \
  "https://mcp.apify.com?tools=automation-lab/linkedin-public-post-search-scraper"
```

JSON configuration for Claude Desktop, Cursor or VS Code:

```json
{
    "mcpServers": {
        "apify": {
            "url": "https://mcp.apify.com?tools=automation-lab/linkedin-public-post-search-scraper"
        }
    }
}
```

Selecting this Actor also adds the helper tools `get-actor-run`, `get-dataset-items`, `get-key-value-store-record` and `abort-actor-run`, so the server exposes more than one tool. Check the exact tool names and arguments with your client's `tools/list` and give the agent only the tools it needs. Listing tools does not run or abort anything. A reliable agent workflow:

1. **Start one run and follow that same run.** Keep the run ID, status and dataset ID that `call-actor` returns; they are run metadata, not posts. `call-actor` waits at most 0–45 seconds (default 30), so the run may still be going. Check the same run with `get-actor-run` using growing waits (for example 2, 4, 8 seconds, capped at 10) up to a total deadline you choose, such as 2 minutes. Set the client request timeout longer than the server wait plus a transport margin.
2. **Recover instead of restarting.** If the client times out, check the known run ID; do not start a new run just to poll. If the run ID is unknown, say so instead of blindly rerunning. At the deadline, report the run as still pending with its ID and stop polling. If the run failed or was aborted, report that honestly; any rows it saved are partial, not a complete result.
3. **Read bounded pages.** When the run succeeds, call `get-dataset-items` with the dataset ID (`defaultDatasetId`), an explicit `limit` and `offset`, and only the `fields` you need, such as `postedAt`, `author.name`, `text` and `url`. Set a total budget for what enters the model context, for example pages of 20 rows from offset 0, at most 100 rows and 64 KiB of UTF-8 text in total, whichever comes first. Track the dataset offset, not the number of rows after your own filtering.
4. **Handle oversized pages and disclose partial reads.** Long post texts can make one page large. Process pages before they reach the model; trim or summarize an oversized row or page and say so. If your client cannot intercept large responses, do not promise a hard byte limit and never request an unbounded result. When you stop before the end, report the rows returned, the next `offset` to continue from, and that the result is partial. For a full export, download the dataset (JSON, CSV or Excel) or process it downstream instead of loading it into the model.

These numbers are example choices for the agent, not Apify defaults, and they limit only what the agent reads; the Actor still collects and saves every requested post. Token savings depend on your client, model and caching, so no fixed saving is promised.

Example prompts:

- "Find public LinkedIn posts from the past week about generative AI in procurement and list the authors with links."
- "Get the latest posts by HubSpot's company page that mention AI and summarize the themes."
- "Collect 50 recent posts with the phrase 'open to work' and 'data engineer' and group them by country in the text."

### Is it legal to scrape LinkedIn posts?

This Actor reads only public pages that anyone can open without logging in, and it does not bypass logins or access private data. Public posts can still contain personal data, so make sure your use complies with applicable laws such as the GDPR and CCPA and with LinkedIn's terms. Do not use the data for spam or harassment. If you are unsure, ask a lawyer. This Actor is not affiliated with or endorsed by LinkedIn.

Failed operations send sanitized diagnostic input, exceptions, and Actor/build/run IDs to our private GlitchTip service for repair. Secret fields and URL query strings are removed. Reports are retained for 30 days. Search queries are sent to the public search index and post URLs to LinkedIn through Apify Proxy; no LinkedIn account is used. Dataset, run-log and incremental-state retention follows your Apify storage settings; delete those resources in Console when no longer needed.

### FAQ

**Do I need a LinkedIn account or cookies?**
No. The Actor only reads public pages and never asks for a login.

**Why did my run fail with "LinkedIn blocked all ... public post pages"?**
Every post page found by the search was refused even after retries with fresh IPs, so the run fails instead of reporting an empty success. It is usually temporary; run again later. Runs where only some pages fail still succeed and save the posts that loaded.

**Why did I get fewer posts than Max posts per search?**
The public index has fewer matching posts, your date window is narrow, some posts were deleted, or several queries found the same post (it is returned once). Try broader keywords or a wider window.

**Why do some new posts appear only after a day or two?**
Keyword discovery uses a public search index, which needs time to pick up new posts. For specific people or companies, add their URLs: their public pages list the newest posts immediately.

**How do I get only new posts every day?**
Set an incremental state key (for example `ai-topic-daily`) and schedule the Actor. Posts already returned with that key are skipped and not billed again. A *Past week* date window keeps each run small.

**Can I search with LinkedIn's own filters such as industry or job title?**
No. Those filters need a logged-in LinkedIn session. Use keywords and author/company URLs instead.

**The run finished with zero posts. What should I check?**
Check the `RUN_SUMMARY` record. If searches found posts but all were out of the date window, widen the window. If no searches found posts, shorten the query or remove quotes.

### Related Actors

- [LinkedIn Post Scraper](https://apify.com/automation-lab/linkedin-post-scraper) — recent posts from specific public profiles.
- [LinkedIn Company Posts Scraper](https://apify.com/automation-lab/linkedin-company-posts-scraper) — posts from public company pages.
- [LinkedIn Profile Posts Scraper](https://apify.com/automation-lab/linkedin-profile-posts-scraper) — a profile's post history.
- [LinkedIn Company Scraper](https://apify.com/automation-lab/linkedin-company-scraper) — company page details for post authors.
- [LinkedIn Profile Scraper](https://apify.com/automation-lab/linkedin-profile-scraper) — enrich post authors with profile details.

# Changelog

This Actor's version history is a separate document: https://apify.com/automation-lab/linkedin-public-post-search-scraper/changelog.md

# Actor input Schema

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

Keywords or phrases to find in public LinkedIn posts, one per line. Words are matched anywhere in the indexed post (title, text or URL slug), in any order. Wrap a phrase in double quotes to require it, and use OR between alternatives, for example: "generative AI" OR "agentic AI". Each query runs as its own search; posts found by several queries are returned once with every matching query listed in matchedQueries. Optional when Author or company URLs are given.

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

Optional LinkedIn profile (https://www.linkedin.com/in/...) or company (https://www.linkedin.com/company/...) URLs. Only posts published by these authors are returned. With search queries, every author is combined with every query (author AND query); without queries, the author's indexed posts are returned. The company filter uses the company's LinkedIn vanity name, so use the URL exactly as shown on LinkedIn.

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

Keep only posts published within this period before the run started. Ignored when Posted after or Posted before is set.

## `postedAfter` (type: `string`):

Keep only posts published on or after this day (YYYY-MM-DD, UTC). Use with daily or weekly schedules for incremental exports. Overrides Date posted.

## `postedBefore` (type: `string`):

Keep only posts published on or before this day (YYYY-MM-DD, UTC). Overrides Date posted.

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

Relevance keeps search order and streams results as they are found. Date returns the newest posts first; the run then reads every found post before saving, so results appear at the end of the run.

## `maxPostsPerQuery` (type: `integer`):

Maximum post URLs collected from each search (each query, or each author + query combination). Posts outside the date window, deleted posts and posts already returned by another search do not add extra results, so a run can return fewer posts than this number. Public index coverage is limited, so very high values may stop early when no more results exist.

## `maxPostsTotal` (type: `integer`):

Optional limit on posts saved in the whole run across all searches. 0 means no total limit (only Max posts per search applies).

## `region` (type: `string`):

Region and language of the public search index, for example us-en, uk-en, de-de, fr-fr or in-en. wt-wt means no region preference. This biases which posts are found; it does not filter by author location.

## `includeComments` (type: `boolean`):

Add up to 20 public comments shown on the post page (author name, text, date, likes) to each record in topComments. This does not cost extra.

## `incrementalStateKey` (type: `string`):

Optional name for remembering post IDs between runs. When set, posts already returned by an earlier run with the same key are skipped and not charged again. Use one key per monitoring job, for example brand-monitoring-daily.

## Actor input object example

```json
{
  "searchQueries": [
    "generative AI",
    "\"supply chain\" hiring"
  ],
  "datePosted": "any",
  "sortBy": "relevance",
  "maxPostsPerQuery": 25,
  "maxPostsTotal": 0,
  "region": "wt-wt",
  "includeComments": false
}
```

# Actor output Schema

## `overview` (type: `string`):

Posts table: publish time, author, text, engagement, link and matching searches.

## `details` (type: `string`):

Every field of each post, including media, hashtags, IDs and optional top comments.

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

Run counters: searches, unique posts found, posts saved and posts skipped by reason.

# 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": [
        "generative AI",
        "\"supply chain\" hiring"
    ],
    "maxPostsPerQuery": 25
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/linkedin-public-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 = {
    "searchQueries": [
        "generative AI",
        "\"supply chain\" hiring",
    ],
    "maxPostsPerQuery": 25,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/linkedin-public-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 '{
  "searchQueries": [
    "generative AI",
    "\\"supply chain\\" hiring"
  ],
  "maxPostsPerQuery": 25
}' |
apify call automation-lab/linkedin-public-post-search-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,automation-lab/linkedin-public-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/OqRigNAPVNNqgD3Rm/builds/RqphbFUhMpbSbGMpd/openapi.json