# LinkedIn Posts Search Scraper | Social Listening (No Cookies) (`b2b_leads/linkedin-posts-search-scraper-social-listening-no-cookies`) Actor

Search LinkedIn posts by keyword, URL, or profile. Export text, author, likes, comments & media as structured JSON. Built for social listening, lead generation, competitive intelligence, market research & LLM/AI workflows. Fast, lightweight — no browser, real-time results.

- **URL**: https://apify.com/b2b\_leads/linkedin-posts-search-scraper-social-listening-no-cookies.md
- **Developed by:** [Chidubem Aneke](https://apify.com/b2b_leads) (community)
- **Categories:** Social media, Lead generation, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.97 / 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.

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/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## LinkedIn Posts Search Scraper

**The fastest, lightest way to collect LinkedIn posts on Apify.** Turn any topic, profile, or post link into clean, structured JSON — ready for dashboards, alerts, research, and AI workflows. Results land in your dataset **in real time**, as each post is collected.

Built for marketers, founders, sales teams, researchers, and builders who need **reliable LinkedIn post data at scale** — without heavy setups, slow runs, or messy exports.

---

### Why this Actor

| | LinkedIn Posts Search Scraper | Typical post collector |
|---|------------------------------|------------------------|
| **Speed** | ~1–3 s per post | 5–15 s per post |
| **Memory** | **256–512 MB** default | 2–4 GB+ |
| **Setup** | Run in seconds — no login | Often requires accounts & maintenance |
| **Cost** | Low compute, efficient runs | High |
| **Output** | Structured JSON, LLM-ready | Often messy HTML |
| **Scale** | Up to **1,000 posts** per keyword | Often capped lower |
| **Filters** | Keyword, author, company, topic, date, sort | Often keyword-only |

---

### What you get — every post, fully structured

Each record is one LinkedIn post with `featureType: "post"` and `scrapedAt` so you can sort, filter, and join with your own data.

| Field | What it tells you |
|-------|-------------------|
| `text`, `authorName`, `authorHeadline`, `authorUrl` | Post content and who published it |
| `numLikes`, `numComments`, `numShares`, `numReactions` | Engagement at a glance |
| `createdAtISO`, `postUrl`, `urn` | When it was posted and direct links |
| `comments[]` | Top comments — author, text, likes |
| `mediaUrls[]`, `articleTitle`, `articleUrl` | Images, videos, and shared articles |
| `searchQuery`, `sourceProfile` | Which search or profile produced this row |

Set `includeRaw: true` if you need the extended source payload for custom processing.

---

### Three ways to collect posts

#### By keyword (default)
Search LinkedIn content the way you would on the platform:

- **Keywords** — one search per keyword (e.g. `AI regulation`, `product launch`, `hiring freeze`)
- **Location** — narrow by geography
- **Author** — filter by person name
- **Company** — posts from or about a company
- **Topic** — combine with keywords for sharper results
- **Date posted** — any time, past month, week, or 24 hours
- **Sort** — relevance or most recent
- **Volume** — up to **1,000 posts per keyword**

#### By post URL
Paste LinkedIn post or activity links and get structured data back instantly.

#### By profile URL
Load recent posts from any public profile's activity — great for tracking executives, competitors, or influencers.

---

### Use cases — real outcomes

- **Social listening** — track brand mentions, product launches, and industry conversations
- **Competitive intelligence** — monitor what competitors and leaders are saying
- **Sales & BD** — spot buying signals, funding news, and hiring announcements in posts
- **Content research** — study what topics and formats get engagement in your niche
- **Influencer & executive tracking** — follow key profiles and export their latest posts
- **PR & comms** — collect posts around a crisis, campaign, or news event
- **AI assistants & agents** — summarize trends, draft replies, score sentiment, or build briefings
- **Data warehouses & CRMs** — push JSON into Snowflake, BigQuery, HubSpot, Airtable, or your stack via API

---

### LLM & MCP integration

Output is **structured JSON** — ideal for ChatGPT, Claude, Gemini, LangChain, LlamaIndex, CrewAI, and custom agents. No cleanup step. No HTML stripping. Just records your model can read.

#### Recommended workflow

1. Run the Actor with your keywords, URLs, or profiles.
2. Pull dataset items via [Apify API](https://docs.apify.com/api/v2), webhook, or export JSON/CSV.
3. Pass records to your LLM, vector store, or automation — one post per row.

#### Example: one post record for an LLM prompt

```json
{
  "featureType": "post",
  "authorName": "Jane Doe",
  "authorHeadline": "VP Marketing at Acme",
  "authorUrl": "https://www.linkedin.com/in/janedoe",
  "text": "Excited to share that Acme just launched our new AI platform...",
  "numLikes": 342,
  "numComments": 48,
  "numShares": 12,
  "createdAtISO": "2026-07-06T10:00:00.000Z",
  "postUrl": "https://www.linkedin.com/feed/update/urn:li:activity:1234567890/",
  "comments": [
    {
      "author": "John Smith",
      "text": "Congrats on the launch!",
      "likes": 5
    }
  ],
  "searchQuery": "AI platform launch",
  "scrapedAt": "2026-07-08T12:00:00.000Z"
}
````

#### Apify MCP (Model Context Protocol)

Connect the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp) so AI assistants can:

- **Run** this Actor from natural-language instructions
- **Read** post results directly in the chat
- **Chain** with other Actors — enrich contacts, send alerts, update spreadsheets

**Example MCP conversation:**

```
User: "Find 30 posts about AI regulation from the past week and summarize top themes"

→ MCP runs LinkedIn Posts Search Scraper with postKeywords, postDatePosted=week
→ MCP reads dataset items
→ LLM summarizes trending topics and key voices
```

#### API quick start

```bash
curl -X POST "https://api.apify.com/v2/acts/YOUR_ACTOR_ID/runs?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "postSearchMode": "keyword",
    "postKeywords": ["AI regulation"],
    "postDatePosted": "week",
    "postsPerQuery": 30,
    "includeComments": true
  }'
```

**Fetch results:** `GET https://api.apify.com/v2/datasets/{datasetId}/items?format=json`

**Dataset views in Apify Console:** Overview (core fields) · Full details (includes media and traceability)

Export as **JSON**, **CSV**, **Excel**, **RSS**, or via **API**.

***

### Input reference

| Input | Type | Default | Description |
|-------|------|---------|-------------|
| `postSearchMode` | enum | `keyword` | `keyword`, `url`, or `profile` |
| `postKeywords` | string\[] | `["AI regulation"]` | Search keywords — one run per keyword |
| `postLocation` | string | `"United States"` | Geographic filter |
| `postAuthor` | string | `""` | Author name filter |
| `postCompany` | string | `""` | Company filter |
| `postTopic` | string | `""` | Topic or theme filter |
| `postDatePosted` | enum | `any` | any, month, week, day |
| `postSort` | enum | `relevance` | relevance or date |
| `postsPerQuery` | integer | `10` | Max posts per keyword (1–1000) |
| `postUrls` | string\[] | example post URL | Post URLs (url mode) |
| `activityProfiles` | string\[] | example profile URL | Profile URLs or handles (profile mode) |
| `postsPerProfile` | integer | `10` | Max posts per profile (1–500) |
| `includeComments` | boolean | `true` | Include top comments on each post |
| `maxItems` | integer | `25` | Global cap on total posts |
| `includeRaw` | boolean | `false` | Attach extended source payload |
| `proxyConfiguration` | object | residential US | Connection settings (US residential recommended) |

Full schema: **Input** tab on Apify Console or `.actor/input_schema.json` in this repository.

***

### Output reference

Every dataset row is a single post. All rows include `featureType: "post"` and `scrapedAt`.

| Field | Type | Description |
|-------|------|-------------|
| `featureType` | string | Always `"post"` |
| `scrapedAt` | string | ISO timestamp when the row was collected |
| `text` | string | null | Post body text |
| `authorName` | string | null | Author display name |
| `authorHeadline` | string | null | Author headline or role |
| `authorUrl` | string | null | Author profile or company URL |
| `authorType` | string | null | Author type when available |
| `postUrl` | string | null | Direct link to the post |
| `urn` | string | null | LinkedIn activity identifier |
| `createdAtISO` | string | null | When the post was published |
| `numLikes` | integer | null | Like count |
| `numComments` | integer | null | Comment count |
| `numShares` | integer | null | Share count |
| `numReactions` | integer | null | Total reactions when available |
| `mediaType` | string | null | Media type (e.g. image, video) |
| `mediaUrls` | string\[] | Attached image or video URLs |
| `articleTitle` | string | null | Linked article title |
| `articleUrl` | string | null | Linked article URL |
| `sharedContentUrl` | string | null | Shared link URL when present |
| `comments` | object\[] | Top comments: `author`, `authorUrl`, `text`, `likes` |
| `searchQuery` | string | null | Keyword that produced this row |
| `sourceProfile` | string | null | Profile handle (profile mode) |
| `raw` | object | Extended payload (when `includeRaw` is true) |

Full schema: **Dataset** tab on Apify Console or `.actor/dataset_schema.json` in this repository.

***

### Quick start examples

**Topic monitoring — past week**

```json
{
  "postSearchMode": "keyword",
  "postKeywords": ["AI regulation", "EU AI Act"],
  "postDatePosted": "week",
  "postSort": "date",
  "postsPerQuery": 50,
  "includeComments": true
}
```

**Posts from a specific company**

```json
{
  "postSearchMode": "keyword",
  "postKeywords": ["product launch"],
  "postCompany": "Stripe",
  "postsPerQuery": 25
}
```

**Track an executive's recent posts**

```json
{
  "postSearchMode": "profile",
  "activityProfiles": ["https://www.linkedin.com/in/janedoe"],
  "postsPerProfile": 30,
  "includeComments": false
}
```

**Collect specific post URLs**

```json
{
  "postSearchMode": "url",
  "postUrls": [
    "https://www.linkedin.com/feed/update/urn:li:activity:1234567890/"
  ],
  "includeComments": true
}
```

**High-volume industry scan**

```json
{
  "postSearchMode": "keyword",
  "postKeywords": ["generative AI", "LLM", "machine learning"],
  "postLocation": "United States",
  "postsPerQuery": 500,
  "maxItems": 1500,
  "includeComments": true
}
```

***

### Performance & reliability

- **Lightweight by design** — default **512 MB** memory handles large runs with multiple keywords.
- **Fast collection** — posts stream into your dataset as they are found; no waiting until the end.
- **Residential proxy (US recommended)** — best results and consistent throughput on LinkedIn.
- **Smart coverage** — automatically widens search when you request large result sets.

***

### Limitations & compliance

- This is an unofficial tool — not affiliated with LinkedIn.
- Use responsibly and comply with applicable laws and LinkedIn's Terms of Service.
- Some fields (engagement counts, comments) appear only when publicly visible.
- Post availability can change; removed or restricted posts may not return data.

***

### Contact & custom work

Need something beyond this Actor? I design and build **custom data solutions** and **full-stack products** for teams that want results — not experiments.

**Email:** <dubem115@gmail.com>\
**GitHub:** [github.com/DrunkCodes](https://github.com/DrunkCodes)

Reach out for:

- **Custom Apify Actors** — any website, social platform, or API
- **LinkedIn & social data projects** — listening pipelines, alerts, and dashboards at scale
- **LLM & MCP integrations** — connect your data to ChatGPT, Claude, and agent workflows
- **Web apps & automation** — data tools, internal platforms, SaaS products, and client-facing apps

Whether you need a one-off data feed or a production system, I can help you ship it.

***

*LinkedIn Posts Search Scraper · by [DrunkCodes](https://github.com/DrunkCodes)*

# Actor input Schema

## `postSearchMode` (type: `string`):

How you want to find posts: search by keyword, paste post links, or load from profile pages.

## `postKeywords` (type: `array`):

Topics to search for — one run per keyword (e.g. "AI regulation", "product launch", "Series B funding").

## `postLocation` (type: `string`):

Geographic filter to focus results on a region or city.

## `postAuthor` (type: `string`):

Filter by author name to find posts from a specific person.

## `postCompany` (type: `string`):

Filter by company — finds posts published by or about that company.

## `postTopic` (type: `string`):

Additional topic or theme to combine with your keywords for sharper results.

## `postDatePosted` (type: `string`):

Only return posts published within this time window.

## `postSort` (type: `string`):

Order results by relevance or most recent first.

## `postsPerQuery` (type: `integer`):

Maximum posts to collect per keyword (1–1000).

## `postUrls` (type: `array`):

LinkedIn post or activity links to collect directly.

## `activityProfiles` (type: `array`):

LinkedIn profile URLs or handles — collects recent posts from each profile.

## `postsPerProfile` (type: `integer`):

Maximum posts to collect per profile (1–500).

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

Add top comments to each post — author name, comment text, and like count.

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

Global limit on how many posts to return across the entire run.

## `includeRaw` (type: `boolean`):

Attach extended source data to each record. Larger output — useful for custom processing.

## `proxyConfiguration` (type: `object`):

Residential US proxy recommended for best speed and consistent results on LinkedIn.

## Actor input object example

```json
{
  "postSearchMode": "keyword",
  "postKeywords": [
    "AI regulation"
  ],
  "postLocation": "United States",
  "postAuthor": "",
  "postCompany": "",
  "postTopic": "",
  "postDatePosted": "any",
  "postSort": "relevance",
  "postsPerQuery": 10,
  "postUrls": [
    "https://www.linkedin.com/feed/update/urn:li:activity:7152578889167302656/"
  ],
  "activityProfiles": [
    "https://www.linkedin.com/in/oliver-patel"
  ],
  "postsPerProfile": 10,
  "includeComments": true,
  "maxItems": 25,
  "includeRaw": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}
```

# Actor output Schema

## `allResults` (type: `string`):

Complete dataset with every post field from this run.

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

Core post fields — author, text, engagement, URL.

## `full` (type: `string`):

All post fields including media and traceability.

# 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 = {
    "postSearchMode": "keyword",
    "postKeywords": [
        "AI regulation"
    ],
    "postLocation": "United States",
    "postAuthor": "",
    "postCompany": "",
    "postTopic": "",
    "postDatePosted": "any",
    "postSort": "relevance",
    "postsPerQuery": 10,
    "postUrls": [
        "https://www.linkedin.com/feed/update/urn:li:activity:7152578889167302656/"
    ],
    "activityProfiles": [
        "https://www.linkedin.com/in/oliver-patel"
    ],
    "postsPerProfile": 10,
    "includeComments": true,
    "maxItems": 25,
    "includeRaw": false,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "US"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("b2b_leads/linkedin-posts-search-scraper-social-listening-no-cookies").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 = {
    "postSearchMode": "keyword",
    "postKeywords": ["AI regulation"],
    "postLocation": "United States",
    "postAuthor": "",
    "postCompany": "",
    "postTopic": "",
    "postDatePosted": "any",
    "postSort": "relevance",
    "postsPerQuery": 10,
    "postUrls": ["https://www.linkedin.com/feed/update/urn:li:activity:7152578889167302656/"],
    "activityProfiles": ["https://www.linkedin.com/in/oliver-patel"],
    "postsPerProfile": 10,
    "includeComments": True,
    "maxItems": 25,
    "includeRaw": False,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "US",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("b2b_leads/linkedin-posts-search-scraper-social-listening-no-cookies").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 '{
  "postSearchMode": "keyword",
  "postKeywords": [
    "AI regulation"
  ],
  "postLocation": "United States",
  "postAuthor": "",
  "postCompany": "",
  "postTopic": "",
  "postDatePosted": "any",
  "postSort": "relevance",
  "postsPerQuery": 10,
  "postUrls": [
    "https://www.linkedin.com/feed/update/urn:li:activity:7152578889167302656/"
  ],
  "activityProfiles": [
    "https://www.linkedin.com/in/oliver-patel"
  ],
  "postsPerProfile": 10,
  "includeComments": true,
  "maxItems": 25,
  "includeRaw": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}' |
apify call b2b_leads/linkedin-posts-search-scraper-social-listening-no-cookies --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "LinkedIn Posts Search Scraper | Social Listening (No Cookies)",
        "description": "Search LinkedIn posts by keyword, URL, or profile. Export text, author, likes, comments & media as structured JSON. Built for social listening, lead generation, competitive intelligence, market research & LLM/AI workflows. Fast, lightweight — no browser, real-time results.",
        "version": "0.0",
        "x-build-id": "mMqSPPgqbe3RlBJzI"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/b2b_leads~linkedin-posts-search-scraper-social-listening-no-cookies/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-b2b_leads-linkedin-posts-search-scraper-social-listening-no-cookies",
                "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/b2b_leads~linkedin-posts-search-scraper-social-listening-no-cookies/runs": {
            "post": {
                "operationId": "runs-sync-b2b_leads-linkedin-posts-search-scraper-social-listening-no-cookies",
                "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/b2b_leads~linkedin-posts-search-scraper-social-listening-no-cookies/run-sync": {
            "post": {
                "operationId": "run-sync-b2b_leads-linkedin-posts-search-scraper-social-listening-no-cookies",
                "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": {
                    "postSearchMode": {
                        "title": "Search mode",
                        "enum": [
                            "url",
                            "profile",
                            "keyword"
                        ],
                        "type": "string",
                        "description": "How you want to find posts: search by keyword, paste post links, or load from profile pages.",
                        "default": "keyword"
                    },
                    "postKeywords": {
                        "title": "Keywords",
                        "type": "array",
                        "description": "Topics to search for — one run per keyword (e.g. \"AI regulation\", \"product launch\", \"Series B funding\").",
                        "default": [
                            "AI regulation"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "postLocation": {
                        "title": "Location",
                        "type": "string",
                        "description": "Geographic filter to focus results on a region or city.",
                        "default": "United States"
                    },
                    "postAuthor": {
                        "title": "Post author",
                        "type": "string",
                        "description": "Filter by author name to find posts from a specific person.",
                        "default": ""
                    },
                    "postCompany": {
                        "title": "Post company",
                        "type": "string",
                        "description": "Filter by company — finds posts published by or about that company.",
                        "default": ""
                    },
                    "postTopic": {
                        "title": "Topic",
                        "type": "string",
                        "description": "Additional topic or theme to combine with your keywords for sharper results.",
                        "default": ""
                    },
                    "postDatePosted": {
                        "title": "Date posted",
                        "enum": [
                            "any",
                            "month",
                            "week",
                            "day"
                        ],
                        "type": "string",
                        "description": "Only return posts published within this time window.",
                        "default": "any"
                    },
                    "postSort": {
                        "title": "Sort posts by",
                        "enum": [
                            "relevance",
                            "date"
                        ],
                        "type": "string",
                        "description": "Order results by relevance or most recent first.",
                        "default": "relevance"
                    },
                    "postsPerQuery": {
                        "title": "Posts per keyword",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum posts to collect per keyword (1–1000).",
                        "default": 10
                    },
                    "postUrls": {
                        "title": "Post URLs",
                        "type": "array",
                        "description": "LinkedIn post or activity links to collect directly.",
                        "default": [
                            "https://www.linkedin.com/feed/update/urn:li:activity:7152578889167302656/"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "activityProfiles": {
                        "title": "Profile URLs",
                        "type": "array",
                        "description": "LinkedIn profile URLs or handles — collects recent posts from each profile.",
                        "default": [
                            "https://www.linkedin.com/in/oliver-patel"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "postsPerProfile": {
                        "title": "Posts per profile",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum posts to collect per profile (1–500).",
                        "default": 10
                    },
                    "includeComments": {
                        "title": "Include top comments",
                        "type": "boolean",
                        "description": "Add top comments to each post — author name, comment text, and like count.",
                        "default": true
                    },
                    "maxItems": {
                        "title": "Max total posts",
                        "minimum": 1,
                        "maximum": 100000,
                        "type": "integer",
                        "description": "Global limit on how many posts to return across the entire run.",
                        "default": 25
                    },
                    "includeRaw": {
                        "title": "Include raw data",
                        "type": "boolean",
                        "description": "Attach extended source data to each record. Larger output — useful for custom processing.",
                        "default": false
                    },
                    "proxyConfiguration": {
                        "title": "Proxy settings",
                        "type": "object",
                        "description": "Residential US proxy recommended for best speed and consistent results on LinkedIn.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ],
                            "apifyProxyCountry": "US"
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
