# LinkedIn Company Posts Monitor (`deepmine/linkedin-company-posts`) Actor

LinkedIn company posts scraper with no login: the newest 70 posts of any company by URL, name or ID, with full text, exact time, reactions, comments count, images, videos, documents, reposts and the first comments. Monitor mode returns only new posts on each scheduled run.

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

## Pricing

from $0.59 / 1,000 posts

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

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

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

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## LinkedIn Company Posts Monitor

LinkedIn company posts scraper with no login: paste company URLs, page names, IDs or company names and get each company's **newest 70 posts** with full text, exact time, reactions, comments count, images, videos, documents, reposts and, if you want them, repost counts, reactions by kind and the first comments. Turn on **Only new posts** and schedule it to get just what each company posted since the last run.

| Company | Author | Post | Reactions | Comments | Posted | Type |
|---|---|---|---|---|---|---|
| HubSpot | HubSpot | [the marketing team the second the calendar says October](https://www.linkedin.com/posts/hubspot_the-marketing-team-the-second-the-calendar-activity-7511424909198258177-YqFG) | 3,932 | 159 | 2026-10-01 | Post · Image |
| Figma | Figma | [Text animation and audio are now available in Figma Motion (!!) Try it out →…](https://www.linkedin.com/posts/figma_text-animation-and-audio-are-now-available-activity-7512949087059533824-lTjU) | 255 | 11 | 2026-10-05 | Post · Video |
| Microsoft | Brad Smith | [Last night we opened a door unlike any other. At the heart of Microsoft's campus…](https://www.linkedin.com/posts/activity-7511466463493341186-lZKg) | 885 | 73 | 2026-10-01 | Repost · Image |

<sub>Collected 2026-10-05 from a 7-company run (469 posts).</sub>

**$0.79 per 1,000 posts** on the Starter plan ($0.95 Free, $0.69 Scale, $0.59 Business), comments, repost counts and reactions by kind included. The prefilled run (5 companies × 20 posts = 100 posts) costs about $0.08. No start fee, no minimum.

### What you get

One row per post in the company's feed, newest first:

- **The post:** full text (plus an 80-character snippet), link, exact publish time (UTC and a millisecond timestamp), the age LinkedIn shows, edited or not.
- **Engagement:** reactions, comments count, and the reaction kinds shown (LIKE, PRAISE, EMPATHY…).
- **Reposts and reactions by kind (optional):** with 📣 Include reposts & reactions by kind, how many times each post was reposted and its reactions split into like, celebrate, support, love, insightful and funny: LinkedIn's own counts.
- **Author:** name, headline, photo, profile or page link, followers (pages). For a repost, the original author.
- **Media:** every image, the video file (MP4) with its poster and captions file, documents (title, pages, cover, file link), link previews (title, source, target, image).
- **Text parts:** hashtags, tagged companies and members with their links, other links.
- **Reposts and quote posts:** who reposted it and when; for a quote post, the shared post's author, text, images, video, link and time.
- **The company:** name, logo, link, followers, employees, industry, size, website, headquarters, page name and ID, on every row.
- **IDs:** activity id and URN, the post's own URN, share/ugcPost URN, feed position (rank).
- **Comments (optional):** with 💬 Include comments, the comments each post's public page shows (about 10): author, profile link, photo, text, time, likes.

### How to use it

1. Paste companies in **🏢 Companies**, one per line: `https://www.linkedin.com/company/stripe`, `stripe`, `2135371` or `Notion`. Country sites (`de.linkedin.com`), showcase pages and `/posts/` links work too.
2. Set **💯 Posts per company** (1-70).
3. Start. Rows arrive within seconds, page by page.

Filters (all free when they leave a post out): **📅 Posted within** (last hour to last 12 months), **🗓️ Posted after** a date, **🔁 Include reposts**, **💭 Include quote posts**. A repost counts from the day the company reposted it, so a fresh repost of an older post stays in. A date filter also stops reading a company's feed once it's past the date, so it's faster.

#### Monitor mode: only new posts

Turn on **🔔 Only new posts** and schedule the run (hourly, daily, weekly). The first run delivers the newest posts and remembers them; each later run delivers only posts it hasn't delivered before, and stops reading a company's feed as soon as it reaches the posts it already has. Posts left out this way are free. Runs that share a **🏷️ Monitor name** share their memory; give separate schedules separate names. The memory is a key-value store named `linkedin-company-posts-monitor` in your account.

### Speed

Measured on 2026-10-05 (Apify platform, default 1,024 MB, datacenter proxy):

| Run | Posts | First row after start | Whole run |
|---|---|---|---|
| 7 companies × 70 posts | 469 | 3.7 s | 9.9 s |
| 25 companies × 70 posts | 1,449 | 4.2 s (100 posts: 5.9 s) | 15.0 s |
| The prefill: 5 companies × 20 posts, one by name | 100 | 7.2 s (4.2 s of it Apify pulling the image) | 11.1 s |
| 1 company × 70 posts with comments | 70 | 4.2 s | 16.1 s |
| 1 company × 70 posts with reposts & reactions by kind (2026-10-19, 3 runs) | 70 | 1.7-2.9 s | 6.0-7.1 s |
| 2 companies, monitor mode, nothing new | 0 | – | 4.7 s |

Each company takes 7 page requests for 70 posts (one more per post with comments on, and one small request per post with reposts & reactions by kind on). Eight companies are read at once.

### Good to know

- **70 posts is LinkedIn's logged-out limit** per company feed. Companies that post less end sooner (their feed reaches back about a year); a company with no posts gives no rows and costs nothing. A few companies hide their feed from logged-out visitors (Deloitte, in our tests); they give no rows either, and the run summary says so.
- **Not shown to logged-out visitors, so not in the rows:** comments beyond the ~10 a post's public page shows, who reacted, and posts older than the newest 70. Tools that return those use LinkedIn accounts.
- Reactions, comment and repost counts are LinkedIn's numbers at the time of the run. For a repost row, `reposts` and `reactionsByType` are the original post's (as LinkedIn shows them on the repost).
- Image and video links don't expire; document file links do (see `documentUrlExpiresAt`).
- Same company twice in the input: read and charged once. A post is charged once per run.
- A run that reaches your max cost stops cleanly with the posts it has.

### Output fields

Rows have the same keys in this order (`null` when LinkedIn doesn't show the value):

- `thumbnail`: the post's picture (first image, video poster, document cover or link image)
- `authorPhoto`, `authorName`, `authorHeadline`: who posted it (for a repost, the original author)
- `textSnippet`, `text`: the post text (snippet: first 80 characters)
- `postUrl`: the post on LinkedIn
- `reactions`, `comments`: counts; `reactionTypes`: reaction kinds shown, most used first
- `reposts`, `reactionsByType` (`like`, `celebrate`, `support`, `love`, `insightful`, `funny`), `engagementStatus` (`ok`, `notShown`, `failed`): only with Include reposts & reactions by kind
- `postedAt` (ISO UTC), `postedTimestamp` (ms), `postedAgo` (as LinkedIn shows it), `isEdited`
- `postType`: Post, Quote or Repost; `contentType`: Video, Image, Images, Document, Article, Repost or Text
- `authorUrl`, `authorType` (company, person, school), `authorFollowers`, `authorUniversalName` (pages), `authorPublicIdentifier` (members)
- `images`, `imageCount`, `videoUrl`, `videoPoster`, `videoCaptionsUrl`
- `documentTitle`, `documentPageCount`, `documentCoverImage`, `documentUrl`, `documentUrlExpiresAt`
- `articleTitle`, `articleSubtitle`, `articleUrl`, `articleImage`: a shared link's preview
- `hashtags`, `mentions`, `mentionUrls`, `links`
- `repostedBy`, `repostedByUrl`, `repostedAt`: Repost rows
- `resharedFrom`, `resharedFromUrl`, `resharedFromHeadline`, `resharedFromPhoto`, `resharedText`, `resharedImages`, `resharedVideoUrl`, `resharedPostUrl`, `resharedPostedAt`: the post a Quote shares
- `topComments`: only with Include comments; each comment has `commentId`, `authorName`, `authorUrl`, `authorPhoto`, `text`, `postedAt`, `postedAgo`, `likes`, `images`
- `companyLogo`, `companyName`, `companyUrl`, `companyFollowers`, `companyEmployeeCount`, `companyIndustry`, `companySize`, `companyWebsite`, `companyHeadquarters`, `companyUniversalName`, `companyId`
- `rank`: position in the company's feed (1 = newest)
- `activityId`, `activityUrn`, `postActivityUrn`, `shareUrn`, `shareUrl`
- `input`: your line it came from; `scrapedAt`

Views in the Output tab: 📊 Overview, 📈 Stats, 🎞️ Media, 🔁 Reposts & Quotes, 💬 Comments (Include comments), 📣 Engagement (Include reposts & reactions). The run summary (OUTPUT) lists every company's result: posts, feed pages read, why its feed stopped (its max, LinkedIn's 70, the end of its feed, your date, posts seen before) and anything LinkedIn refused.

### FAQ

**Do I need a LinkedIn account or cookies?** No. It reads only what LinkedIn shows to visitors who aren't logged in.

**Can I get posts older than the newest 70?** Not without an account: LinkedIn's public company feed stops there. Schedule monitor mode to build a history going forward.

**Which proxy?** Leave the default (Apify datacenter). A residential pick runs on datacenter at no extra cost.

**Can I export it?** Yes: CSV, Excel, JSON or XML from the Output tab, or the API and integrations (Make, Zapier, Google Sheets) on a schedule.

Found it useful? A review on the Store helps other buyers find it. Questions or a field you need: open an issue on the Issues tab.

# Actor input Schema

## `companies` (type: `array`):

One per line: a LinkedIn company page URL (any country site, showcase pages, /posts/ links too), a page name like <code>stripe</code>, a numeric company ID, or a company name like <code>Notion</code>. Pages that don't exist are free.

## `maxPostsPerCompany` (type: `integer`):

The newest posts to collect and pay for per company, newest first. LinkedIn shows up to 70 without login (about a year back for companies that post less).

## `onlyNewPosts` (type: `boolean`):

Collect only posts that earlier runs with this option on haven't delivered. Schedule the run (daily, hourly) to get each company's new posts as they appear. The first run delivers the newest posts as usual and remembers them. Posts left out this way are free.

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

Adds the comments LinkedIn shows on each post's public page (about 10 per post: name, profile link, text, time, likes) in topComments. No extra charge; one more page per post, so the run takes longer.

## `includeEngagement` (type: `boolean`):

Adds each post's repost count (reposts) and its reactions by kind (reactionsByType: like, celebrate, support, love, insightful, funny), as LinkedIn counts them. No extra charge; one small extra request per post, so the run takes a little longer.

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

Keep only posts that appeared in the company's feed this recently (a repost counts from when the company reposted it). Older posts aren't read or charged.

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

Keep only posts from this date on, e.g. <code>2026-09-01</code> (or a relative <code>14 days</code>). Empty = no date limit.

## `includeReposts` (type: `boolean`):

Plain reposts: someone else's post the company shared without adding text ("Stripe reposted this").

## `includeQuotePosts` (type: `boolean`):

The company's own text over someone else's post (the shared post comes in the reshared\* fields).

## `maxResultsPerName` (type: `integer`):

For lines that are company names: how many matching companies to collect posts for, best match first. 1 = just the best match.

## `monitorName` (type: `string`):

With Only new posts on: runs with the same name share what they've seen. Give separate schedules separate names to track them apart. Empty = default.

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

Stop after this many posts in total. Empty = no limit (your max cost per run still applies).

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

Leave as is: Apify datacenter proxy works for LinkedIn's public company pages. Residential isn't used (a residential pick runs on datacenter, at no extra cost).

## Actor input object example

```json
{
  "companies": [
    "https://www.linkedin.com/company/openai",
    "https://www.linkedin.com/company/stripe",
    "nvidia",
    "Notion",
    "https://www.linkedin.com/company/ramp"
  ],
  "maxPostsPerCompany": 20,
  "onlyNewPosts": false,
  "includeComments": false,
  "includeEngagement": false,
  "postedLimit": "any",
  "includeReposts": true,
  "includeQuotePosts": true,
  "maxResultsPerName": 1,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

No description

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

No description

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "companies": [
        "https://www.linkedin.com/company/openai",
        "https://www.linkedin.com/company/stripe",
        "nvidia",
        "Notion",
        "https://www.linkedin.com/company/ramp"
    ],
    "maxPostsPerCompany": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("deepmine/linkedin-company-posts").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 = {
    "companies": [
        "https://www.linkedin.com/company/openai",
        "https://www.linkedin.com/company/stripe",
        "nvidia",
        "Notion",
        "https://www.linkedin.com/company/ramp",
    ],
    "maxPostsPerCompany": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("deepmine/linkedin-company-posts").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "companies": [
    "https://www.linkedin.com/company/openai",
    "https://www.linkedin.com/company/stripe",
    "nvidia",
    "Notion",
    "https://www.linkedin.com/company/ramp"
  ],
  "maxPostsPerCompany": 20
}' |
apify call deepmine/linkedin-company-posts --silent --output-dataset

```

## MCP server setup

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

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/OSe1QryiiBvgZCEnQ/builds/Xfj22l2C0IMhOSANJ/openapi.json