# LinkedIn Post Search Scraper 2$/1K (`lofomachines/linkedin-post-search-scraper`) Actor

Find and extract public LinkedIn posts by keyword, country and date range. Clean, structured, ready-to-use data. Fast and Cheaper.

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

## Pricing

from $2.00 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/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

## LinkedIn Post Search Scraper 🔍

**Search LinkedIn posts by keyword and export them as clean, structured data — by country and date range, with no login, cookies, or LinkedIn account required.**

Find every public LinkedIn post that mentions your brand, product, competitor, hashtag, event, or any topic you care about — and turn it into a ready-to-use dataset in minutes. Perfect for **social listening, lead generation, market research, brand monitoring, and content discovery**.

> Type a keyword. Pick a country. Get hundreds or thousands of matching LinkedIn posts with author details, engagement metrics, images, hashtags, mentions, and exact publication dates.

---

### ✨ Why use this LinkedIn Post Scraper?

- 🔎 **Keyword-based search** — collect posts that contain your exact keywords, brand names, hashtags, or phrases.
- 📦 **Bulk keywords** — search many keywords in a single run.
- 🌍 **Country targeting** — focus your search on any market (US, UK, Italy, Germany, France, India, Brazil, and 50+ more).
- 🗓️ **Date range filtering** — collect posts from a specific time window, or grab the most recent posts automatically.
- 📊 **Rich, structured output** — author, headline, reactions, comments, text, images, hashtags, mentions, exact post date, and more.
- 🔐 **No login, no cookies, no LinkedIn account** — only publicly available data.
- ⚡ **Fast & scalable** — optimized to collect large volumes quickly and cost-efficiently.
- 🧹 **Clean & deduplicated** — one tidy row per post, ready for Excel, Google Sheets, BI tools, or your CRM.

---

### 💼 Who is it for?

| Role | What you can do |
| --- | --- |
| **Marketing & social teams** | Track brand mentions, campaigns, and hashtags. Measure organic reach and engagement. |
| **Sales & lead generation** | Find people and companies talking about your niche, then build targeted prospect lists. |
| **Market & competitive research** | Monitor competitors, products, and industry trends in real time. |
| **PR & communications** | Catch every mention of your company, executives, or events as they happen. |
| **Recruiters & talent teams** | Discover professionals posting about specific skills, technologies, or topics. |
| **Content creators & analysts** | Research what resonates in your space and source ideas backed by real engagement data. |

---

### 🚀 How to use it

1. **Add your keywords.** Enter one or more keywords, brand names, hashtags, or phrases. You can paste many at once for bulk search.
2. **Choose a target country.** Enter a two-letter country code (for example `us`, `it`, `gb`, `de`, `fr`, `in`, `br`).
3. **Set how many posts you want** per keyword (from 10 up to 3,000).
4. *(Optional)* **Pick a date range.** Leave it empty to automatically collect the most recent posts.
5. Click **Start** ▶️ and watch your dataset fill up.

That's it — no technical setup, no proxies to configure, no scraping knowledge needed.

---

### ⚙️ Input

| Field | Description | Example |
| --- | --- | --- |
| **Keywords** | Words, names, hashtags, or phrases to find inside LinkedIn posts. One per line; bulk paste supported. A post is matched whenever the keyword appears in its text — even when joined with other words or symbols (so `enilive` also matches `#enilive` and `EniLivePassion`). | `enilive`, `#sustainability`, `AI agents` |
| **Max posts per keyword** | How many posts to collect for each keyword (10–3,000). | `100` |
| **Target country** | Two-letter country code of the market you want to target. | `it` |
| **Posted after** *(optional)* | Only collect posts published on or after this date. | `2026-06-01` |
| **Posted before** *(optional)* | Only collect posts published on or before this date. | `2026-06-16` |

#### Example input

```json
{
  "keywords": ["enilive", "#sustainability"],
  "country": "it",
  "maxPostsPerKeyword": 200,
  "publishedAfter": "2026-06-01",
  "publishedBefore": "2026-06-16"
}
````

***

### 📤 Output

Each post becomes a single, clean record. Export the full dataset to **JSON, CSV, Excel, XML, or HTML**, or pull it via the **API**.

#### Data points you get

| Field | Description |
| --- | --- |
| `postUrl` | Direct link to the post |
| `postId` / `postUrn` | Unique identifiers of the post |
| `text` | Full post text |
| `authorName` | Name of the person or company that posted |
| `authorUrl` | Link to the author's profile or company page |
| `authorType` | `person`, `company`, or `school` |
| `authorHeadline` | Author's professional headline |
| `authorImageUrl` | Author's profile or company picture |
| `postedAt` | Exact publication date & time (ISO 8601) |
| `postedAtRelative` | Human-friendly time (e.g. `1d`) |
| `isEdited` | Whether the post was edited |
| `reactionsCount` | Total reactions (likes, celebrate, support, …) |
| `commentsCount` | Total comments |
| `imageUrl` / `images` | Image(s) attached to the post |
| `hashtags` | Hashtags found in the post |
| `mentions` | People & companies mentioned, with links |
| `hasVideo` | Whether the post contains a video |
| `locale` | Language/locale of the post |
| `searchKeyword` | The keyword that matched this post |
| `searchCountry` | The target country used |
| `scrapedAt` | When the record was collected |

#### Example output

```json
{
  "postUrl": "https://www.linkedin.com/feed/update/urn:li:activity:7471837778893459457",
  "postId": "7471837778893459457",
  "postUrn": "urn:li:activity:7471837778893459457",
  "text": "Auch wenn es nicht mehr ganz neu ist, so nen e-LKW am Charger zu sehen ist schon sehr cool. Springer Transporte x Plenitude @ Enilive Gersthofen. As good as it gets!",
  "authorName": "Andreas Bolze",
  "authorUrl": "https://www.linkedin.com/in/andreas-bolze",
  "authorType": "person",
  "authorHeadline": "Head of Rollout Germany at Plenitude On The Road",
  "authorImageUrl": "https://media.licdn.com/dms/image/v2/...",
  "postedAt": "2026-06-14T08:15:46.000Z",
  "postedAtRelative": "1d",
  "isEdited": true,
  "reactionsCount": 42,
  "commentsCount": 8,
  "imageUrl": "https://media.licdn.com/dms/image/v2/...",
  "images": ["https://media.licdn.com/dms/image/v2/..."],
  "hashtags": [],
  "mentions": [
    { "name": "Springer Transporte", "url": "https://www.linkedin.com/company/springer-transporte", "type": "company" },
    { "name": "Enilive", "url": "https://www.linkedin.com/company/enilive", "type": "company" }
  ],
  "hasVideo": false,
  "locale": "en_US",
  "searchKeyword": "enilive",
  "searchCountry": "it",
  "scrapedAt": "2026-06-15T10:00:00.000Z"
}
```

***

### 💡 Tips & best practices

- **Be specific.** Precise keywords and brand names return more relevant results than broad terms.
- **Use bulk keywords** to compare brands, products, or campaigns side by side in one run.
- **Combine with a date range** for time-bound analysis (campaign windows, event coverage, weekly monitoring).
- **Match the country to your audience** for the most relevant, localized results.
- **Schedule recurring runs** to monitor mentions automatically and build a historical archive over time.

***

### 🔗 Integrations & automation

Connect your results to the tools you already use:

- 📥 Export to **CSV, Excel, JSON, XML, HTML**
- 🔌 Access data through the **Apify API**
- 🔔 Trigger **webhooks** when a run finishes
- 🤝 Automate with **Make, Zapier, n8n, Google Sheets, Slack**, and more
- ⏰ **Schedule** runs hourly, daily, or weekly

***

### ❓ FAQ

**Do I need a LinkedIn account, login, or cookies?**
No. This scraper works only with publicly available information and requires no credentials.

**How many posts can I collect?**
Up to 3,000 posts per keyword, per run. Run multiple keywords in a single run for even more coverage.

**Which countries and languages are supported?**
50+ markets across North & South America, Europe, the Middle East, Africa, Asia, and Oceania, each automatically localized.

**What if I don't set a date range?**
The scraper automatically collects the most recent matching posts.

**Will I get duplicates?**
No. Results are automatically deduplicated, so every post appears only once.

**How is a post matched to my keyword?**
A post is included whenever your keyword appears anywhere in its text, even when joined with other words or symbols, and regardless of letter case.

***

### ⚖️ Legal & responsible use

This Actor collects only **publicly available** data and is intended for legitimate purposes such as research, analytics, monitoring, and lead generation. You are responsible for ensuring your use complies with applicable laws and regulations (including data protection rules such as the GDPR) and with LinkedIn's terms. Do not use the data to harass individuals or for any unlawful purpose.

***

#### Ready to turn LinkedIn conversations into actionable data?

Enter your keywords, pick a country, and click **Start**. 🚀

# Actor input Schema

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

Words, names, hashtags or phrases to find inside LinkedIn posts. Add one keyword per line (you can paste many at once for bulk search). A post is collected when the keyword appears anywhere in its text, even when joined with other words or symbols (for example, the keyword "enilive" also matches "#enilive" and "EniLivePassion").

## `maxPostsPerKeyword` (type: `integer`):

How many posts to collect for each keyword. Increase it for broader coverage, lower it for faster and cheaper runs.

## `country` (type: `string`):

Two-letter country code of the market you want to target, e.g. "us" (United States), "it" (Italy), "gb" (United Kingdom), "de" (Germany), "fr" (France), "es" (Spain), "br" (Brazil), "in" (India). Results and language are tuned to this market.

## `publishedAfter` (type: `string`):

Only collect posts published on or after this date. Leave both date fields empty to automatically search the most recent posts first.

## `publishedBefore` (type: `string`):

Only collect posts published on or before this date. Leave both date fields empty to automatically search the most recent posts first.

## Actor input object example

```json
{
  "keywords": [
    "enilive"
  ],
  "maxPostsPerKeyword": 100,
  "country": "us"
}
```

# Actor output Schema

## `posts` (type: `string`):

All LinkedIn posts collected during the run.

# 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": [
        "enilive"
    ],
    "country": "us"
};

// Run the Actor and wait for it to finish
const run = await client.actor("lofomachines/linkedin-post-search-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "keywords": ["enilive"],
    "country": "us",
}

# Run the Actor and wait for it to finish
run = client.actor("lofomachines/linkedin-post-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": [
    "enilive"
  ],
  "country": "us"
}' |
apify call lofomachines/linkedin-post-search-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "LinkedIn Post Search Scraper 2$/1K",
        "description": "Find and extract public LinkedIn posts by keyword, country and date range. Clean, structured, ready-to-use data. Fast and Cheaper.",
        "version": "1.0",
        "x-build-id": "BTyfVLjLxSWJAZ0z6"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/lofomachines~linkedin-post-search-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-lofomachines-linkedin-post-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/lofomachines~linkedin-post-search-scraper/runs": {
            "post": {
                "operationId": "runs-sync-lofomachines-linkedin-post-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/lofomachines~linkedin-post-search-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-lofomachines-linkedin-post-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",
                    "country"
                ],
                "properties": {
                    "keywords": {
                        "title": "Keywords",
                        "minItems": 1,
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Words, names, hashtags or phrases to find inside LinkedIn posts. Add one keyword per line (you can paste many at once for bulk search). A post is collected when the keyword appears anywhere in its text, even when joined with other words or symbols (for example, the keyword \"enilive\" also matches \"#enilive\" and \"EniLivePassion\").",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxPostsPerKeyword": {
                        "title": "Max posts per keyword",
                        "minimum": 10,
                        "maximum": 3000,
                        "type": "integer",
                        "description": "How many posts to collect for each keyword. Increase it for broader coverage, lower it for faster and cheaper runs.",
                        "default": 100
                    },
                    "country": {
                        "title": "Target country",
                        "pattern": "^[A-Za-z]{2}$",
                        "type": "string",
                        "description": "Two-letter country code of the market you want to target, e.g. \"us\" (United States), \"it\" (Italy), \"gb\" (United Kingdom), \"de\" (Germany), \"fr\" (France), \"es\" (Spain), \"br\" (Brazil), \"in\" (India). Results and language are tuned to this market.",
                        "default": "us"
                    },
                    "publishedAfter": {
                        "title": "Posted after (optional)",
                        "type": "string",
                        "description": "Only collect posts published on or after this date. Leave both date fields empty to automatically search the most recent posts first."
                    },
                    "publishedBefore": {
                        "title": "Posted before (optional)",
                        "type": "string",
                        "description": "Only collect posts published on or before this date. Leave both date fields empty to automatically search the most recent posts first."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```