# Linkedin Posts Search Scraper (No Cookie) (`datadoping/linkedin-posts-search-scraper`) Actor

For just $1.2 per 1,000 posts, scrape LinkedIn posts of a keyword and extract full content, engagement stats, and author details using their profile URL.
Note: If you're on free tier you can only scrape 4 profile and 100 posts per profile per run (12 profiles in total)

- **URL**: https://apify.com/datadoping/linkedin-posts-search-scraper.md
- **Developed by:** [Data Doping](https://apify.com/datadoping) (community)
- **Categories:** Social media, Lead generation, Automation
- **Stats:** 914 total users, 205 monthly users, 100.0% runs succeeded, 28 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.20 / 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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

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

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

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

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

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


# README

🔍 What is LinkedIn Posts Search Scraper?

LinkedIn Posts Search Scraper automates the process of searching and gathering publicly available posts from LinkedIn using keyword-based queries. Simply provide a search keyword, and the scraper will fetch comprehensive post details from search results such as:

**Post Content:**
- Post text and content
- Post URLs and timestamps
- Author information (name, headline, profile picture)
- Post statistics (likes, comments, reposts, reactions)

**Media Content:**
- Images with dimensions and URLs
- Article links and titles
- Video content references

**Engagement Data:**
- Total reaction counts
- Individual reaction types (like, appreciation, empathy, interest, praise)
- Comment and repost counts
- Post timestamps (both absolute and relative)

**Search Features:**
- Keyword-based search across LinkedIn posts
- Sort by date posted or relevance
- Date filtering (past 24h, past week, past month)

All extracted data is limited strictly to public information—nothing private or sensitive is collected.

💡 Why Search LinkedIn Posts?

LinkedIn post search provides valuable insights for professionals and businesses:

🔎 **Content Discovery**: Find trending posts and discussions around specific topics or keywords.

🧠 **Market Research**: Monitor industry conversations and trending topics in real-time.

📈 **Lead Generation**: Identify potential clients through their content interests and engagement patterns.

🤝 **Content Strategy**: Research what content performs well for specific keywords and topics.

📊 **Competitive Analysis**: Track how competitors discuss certain topics and their engagement.

🎯 **Social Listening**: Monitor brand mentions, industry discussions, and trending topics.

⚖️ Is it Legal to Search LinkedIn Posts?

We prioritize ethical scraping practices.

This scraper only extracts information that users have chosen to display publicly on LinkedIn. It does not access private data, restricted content, or information behind login walls. All data collection follows LinkedIn's robots.txt guidelines and respects rate limits.

🚀 How to Use

1. **Search Keyword**: Provide the keyword to search for in LinkedIn posts
   - Example: `artificial intelligence`, `marketing trends`, `job opportunities`

2. **Page Number**: Set the page number for pagination (starts with 1)

3. **Sort Options**: Choose how to sort results
   - `date_posted`: Sort by publication date (newest first)
   - `relevance`: Sort by relevance to the search keyword

4. **Date Filter**: Filter posts by publication date
   - `past-24h`: Posts from the last 24 hours
   - `past-week`: Posts from the last week
   - `past-month`: Posts from the last month

📊 Output Data Structure

The scraper returns comprehensive post data including:

- **Post Content**: Text, URLs, timestamps, and metadata
- **Author Info**: Name, headline, profile picture, and profile URL
- **Engagement**: Reaction counts, comments, reposts, and interaction data
- **Media**: Images, articles, and other media attachments
- **Search Metadata**: Keyword used

🔧 Technical Features

- **Keyword Search**: Search across LinkedIn posts using specific keywords
- **Input Validation**: Validates search parameters and provides defaults
- **Sorting Options**: Sort results by date or relevance
- **Date Filtering**: Filter results by publication timeframe
- **Error Handling**: Comprehensive error reporting for failed requests
- **Search Metadata**: Track search parameters with each result

⚠️ Important Notes

- All data is publicly available information only
- Free tier users have rate limits
- Free tier limited to 4 keywords per run with maximum 50 posts per keyword (12 Keyword in total)
- To unlock unlimited scraping, [subscribe to a paid plan](https://apify.com?fpr=sfks2f)

# Actor input Schema

## `keywords` (type: `array`):

List of keywords to search for in LinkedIn posts. Enter one keyword per line.
## `max_posts` (type: `integer`):

Maximum number of posts to scrape for each keyword. Minimum is 10 posts. Default is 10.
## `sort_by` (type: `string`):

How to sort the search results.
## `date_filter` (type: `string`):

Filter posts by publication date.

## Actor input object example

```json
{
  "keywords": [
    "artificial intelligence"
  ],
  "max_posts": 100,
  "sort_by": "date_posted",
  "date_filter": "past-24h"
}
````

# 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 = {
    "keywords": [
        "artificial intelligence"
    ],
    "max_posts": 100,
    "sort_by": "date_posted",
    "date_filter": "past-24h"
};

// Run the Actor and wait for it to finish
const run = await client.actor("datadoping/linkedin-posts-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 = {
    "keywords": ["artificial intelligence"],
    "max_posts": 100,
    "sort_by": "date_posted",
    "date_filter": "past-24h",
}

# Run the Actor and wait for it to finish
run = client.actor("datadoping/linkedin-posts-search-scraper").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 '{
  "keywords": [
    "artificial intelligence"
  ],
  "max_posts": 100,
  "sort_by": "date_posted",
  "date_filter": "past-24h"
}' |
apify call datadoping/linkedin-posts-search-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Linkedin Posts Search Scraper (No Cookie)",
        "description": "For just $1.2 per 1,000 posts, scrape LinkedIn posts of a keyword and extract full content, engagement stats, and author details using their profile URL.\nNote: If you're on free tier you can only scrape 4 profile and 100 posts per profile per run (12 profiles in total)",
        "version": "0.0",
        "x-build-id": "LtmbKd0cE0cdg3E1X"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/datadoping~linkedin-posts-search-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-datadoping-linkedin-posts-search-scraper",
                "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/datadoping~linkedin-posts-search-scraper/runs": {
            "post": {
                "operationId": "runs-sync-datadoping-linkedin-posts-search-scraper",
                "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/datadoping~linkedin-posts-search-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-datadoping-linkedin-posts-search-scraper",
                "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",
                "required": [
                    "keywords"
                ],
                "properties": {
                    "keywords": {
                        "title": "Search Keywords",
                        "type": "array",
                        "description": "List of keywords to search for in LinkedIn posts. Enter one keyword per line.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "max_posts": {
                        "title": "Maximum Posts Per Keyword",
                        "minimum": 10,
                        "type": "integer",
                        "description": "Maximum number of posts to scrape for each keyword. Minimum is 10 posts. Default is 10.",
                        "default": 10
                    },
                    "sort_by": {
                        "title": "Sort By",
                        "enum": [
                            "date_posted",
                            "relevance"
                        ],
                        "type": "string",
                        "description": "How to sort the search results.",
                        "default": "date_posted"
                    },
                    "date_filter": {
                        "title": "Date Filter",
                        "enum": [
                            "past-24h",
                            "past-week",
                            "past-month"
                        ],
                        "type": "string",
                        "description": "Filter posts by publication date.",
                        "default": "past-24h"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```