# LinkedIn Company Posts Scraper (`crawlix/linkedin-company-posts-scraper`) Actor

LinkedIn Company Posts Scraper extracts public feed updates, post text, images, videos, article links, and social reactions from any LinkedIn company page. Export post text, media links, and engagement metrics into clean Excel, CSV, or JSON tables for research and content tracking.

- **URL**: https://apify.com/crawlix/linkedin-company-posts-scraper.md
- **Developed by:** [Crawlix](https://apify.com/crawlix) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.80 / 1,000 post collecteds

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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

The **LinkedIn Company Posts Scraper** extracts public feed updates, post text, media assets, article links, and social engagement numbers from any organization on LinkedIn. Provide company URLs or usernames, specify how many posts you need, and every update lands in your dataset as one clean, structured row: company name, post URL, publication date, text, images, videos, article previews, likes, and reposts.

Use it as an automated content monitoring pipeline, a competitor intelligence engine, or a reliable way to scrape LinkedIn company posts directly into Excel, CSV, or JSON tables for research and social analytics.

***

### Overview & Core Capabilities: LinkedIn Company Posts Scraper

The **LinkedIn Company Posts Scraper** is built for one dedicated job: turning LinkedIn company pages into detailed, tabular datasets of their published updates. Instead of manually scrolling organization feeds, copying text, saving links, and recording engagement numbers, this tool automates the entire collection process across single or multiple organizations in a single run.

#### What This LinkedIn Company Posts Scraper Extracts:

- **Direct Update Access**: Canonical post URLs, unique activity IDs, and direct links to view the update on LinkedIn.
- **Publishing Metadata**: Publication timestamps in ISO UTC format and human-readable relative time markers (e.g. `3d`, `1w`).
- **Complete Post Content**: Full post text and captions, formatting, mentions, and announced corporate developments.
- **Topic & Entity Intelligence**: Extracted `#hashtags`, tagged `@mentions`, and embedded destination `external_links`.
- **Rich Media Assets**: Direct high-resolution image links, embedded video stream URLs, and media format tags (`image`, `video`, `article`, `document`, `poll`, `none`).
- **Shared Articles & Documents**: External article cards with titles and host domains, plus PDF presentation decks with slide counts.
- **Polls & Repost Insights**: Community poll question prompts, choices, and vote totals, plus original author metadata on reshared updates.
- **Social Engagement Metrics**: Live counts for public likes/reactions, comments count, reposts, and total unified reactions count.
- **Source Identification**: Publisher company name, official company page link, numeric company ID, and the exact input that produced the row.

Every post is saved individually the moment it is collected, so your results are preserved even if a run is cut short or hits your budget limit. Whether you run the **LinkedIn Company Posts Scraper** once for competitor analysis or schedule it weekly for market intelligence, the output keeps a consistent schema that integrates smoothly with your existing spreadsheets, dashboards, and databases.

***

### Practical Use Cases & Applications

Marketing agencies, brand strategists, data engineers, and market researchers rely on the **LinkedIn Company Posts Scraper** across numerous core applications:

1. **Competitor Content & Campaign Tracking**: Run the **LinkedIn Company Posts Scraper** weekly on industry rivals to analyze post frequencies, content themes, campaign launches, and audience reception.
2. **Engagement & Viral Post Benchmarking**: Analyze thousands of updates across top industry leaders using the **LinkedIn Company Posts Scraper** to uncover which topics, formats (video vs image), and headlines drive the highest reaction and engagement counts.
3. **Product Announcement & PR Monitoring**: Track brand positioning shifts, newly released features, and executive communications across target accounts.
4. **Influencer & Brand Partnership Intelligence**: Identify which external authors, articles, and brands are frequently cited and shared by prominent corporate profiles.
5. **AI Model Training & Sentiment Analysis**: Feed clean corporate communication records into language models to study industry-specific tone, terminology, and engagement drivers.
6. **B2B Prospect Research**: Review an account's recent posts before outreach calls to identify current corporate priorities and pain points.

Each use case starts the same way: enter your target company links or handles, set your post target, and let the **LinkedIn Company Posts Scraper** do the collecting.

***

### Target Audiences & Engineering Teams

The **LinkedIn Company Posts Scraper** is built to empower both technical and non-technical teams:

- **Social Media & Content Strategists**: Discover high-performing content formats and optimize post timing based on real historical data.
- **Sales Intelligence & Account Executives**: Review prospect news and announcements before high-value enterprise sales meetings.
- **Data Engineers & Analytics Teams**: Stream structured feed data directly into analytical warehouses like BigQuery, Snowflake, and PostgreSQL.
- **Market Researchers & Brand Analysts**: Track cross-industry trends and aggregate corporate communications across hundreds of global brands.

***

### Key Architectural Advantages & Reliability

| Operational Feature | LinkedIn Company Posts Scraper | Manual Data Entry | Browser Extension Tools |
|---|---|---|---|
| **Data Structure** | Flat 1-row-per-post JSON / CSV | Inconsistent and messy | Incomplete field coverage |
| **Paging Capability** | Automatic continuous feed retrieval | Slow manual scrolling | Halts after 2–3 updates |
| **Media Extraction** | Direct high-res image & video links | Laborious manual downloads | Often misses video assets |
| **Engagement Numbers** | Exact likes, reactions, and shares | Prone to human errors | Frequently inaccurate |
| **State Resilience** | Auto-resumes after container migration | N/A | Crashes on interruptions |
| **Export Formats** | Excel, CSV, JSON, XML, HTML | Manual formatting | Limited export options |

***

### Quickstart: Step-by-Step Execution Guide

Running the **LinkedIn Company Posts Scraper** takes only a few quick steps:

1. **Provide Company Targets**: In the input form, enter one or more LinkedIn company links (e.g., `https://www.linkedin.com/company/google`) or plain handles (e.g., `microsoft`).
2. **Set Post Target**: Choose how many recent posts to collect per company (defaults to `10` posts per company, maximum 80).
3. **Start the Run**: Click **Start**. The actor verifies the input, loads the company feed, and streams each post row directly into the default dataset.
4. **Export Your Dataset**: Visit the **Output** tab to download your results in Excel, CSV, JSON, or XML.

*Free Plan Limit*: A free Apify account collects up to 50 posts in total per run across all requested companies. A paid Apify plan has no volume limits.

***

### Input Parameters & Configuration Reference

The **LinkedIn Company Posts Scraper** accepts the following parameters:

| Parameter Name | Data Type | Default | Description |
|---|---|---|---|
| `company_urls` | Array | `["https://www.linkedin.com/company/google"]` | Full public LinkedIn company page URLs. Accepts standard links, links with tabs (e.g. `/posts`), and URLs with tracking parameters. |
| `usernames` | Array | `["microsoft"]` | Company usernames or slugs (the text following `/company/` in the URL). One per line. Works identically to full links. |
| `max_posts` | Integer | `10` | Maximum number of unique posts to collect for each company (maximum 80, as LinkedIn guest mode delivers up to ~70–80 recent posts per company). The run ends cleanly when no more posts are available. |
| `proxyCountry` | Select | `"US"` | Regional connection exit country for web requests. Choose from 158+ supported worldwide countries. |

***

### Extracted Dataset Schema & Field Definitions

Every collected update produces one row in the dataset. Headline fields are bolded below:

| Field Name | Type | Description |
|---|---|---|
| `number` | Integer | Chronological sequence position of the post within the run. |
| **`company_name`** | String | Official public trade name of the company that published the post. |
| **`company_id`** | String | Unique numeric identifier of the organization on LinkedIn. |
| `company_username` | String | Unique company slug or handle. |
| **`company_url`** | String | Canonical link to the publisher's company page on LinkedIn. |
| `company_input` | String | The exact input link or username entered by the user that generated this result. |
| **`post_id`** | String | Unique numerical activity identifier of the post. |
| `post_urn` | String | Canonical activity URN (e.g. `urn:li:activity:7185038481234567890`). |
| **`post_url`** | String | Direct permanent link to the post on LinkedIn. |
| `posted_date` | String | Publication date written in ISO 8601 UTC format if available. |
| `posted_time_ago` | String | Relative timestamp displayed on the post (e.g. `3d`, `1w`, `2mo`). |
| **`text`** | String | Full text body and caption of the post. |
| `hashtags` | Array | List of topic hashtags extracted from the post caption. |
| `mentions` | Array | Tagged people and company handles mentioned in the post body. |
| `external_links` | Array | Destination URLs and links embedded inside the post body. |
| **`media_type`** | String | Classification of attached media (`image`, `video`, `article`, `document`, `poll`, or `none`). |
| `media_urls` | Array | Direct URLs to high-resolution images or video stream assets. |
| `article_url` | String | Destination link if an external article or blog was shared. |
| `article_title` | String | Title headline of the shared external article. |
| `article_domain` | String | Publisher or domain host of the shared external article. |
| `document_title` | String | Title headline of attached PDF/presentation carousel document. |
| `document_pages` | Integer | Number of slides or pages in the attached PDF carousel document. |
| `is_poll` | Boolean | True if this post is an interactive community poll. |
| `poll_question` | String | The poll question prompt if this post is a poll. |
| `poll_options` | Array | List of selectable answer choices in the poll. |
| `poll_total_votes` | Integer | Total count of community votes cast on the poll. |
| `is_repost` | Boolean | True if this post is a reshared update from another account. |
| `reshared_author` | String | Original author or company name if this update is a reshare. |
| `reshared_post_url` | String | Link to the original update that was reshared. |
| **`likes_count`** | Integer | Total count of public likes and social reactions. |
| **`comments_count`** | Integer | Total count number of public comments on the post. |
| **`reposts_count`** | Integer | Total count of public shares and reposts. |
| **`total_reactions_count`** | Integer | Unified total of all public social actions (likes + comments + reposts). |
| `scraped_at` | String | UTC timestamp when this post was collected. |

#### Sample Dataset Record (JSON)

```json
{
  "number": 1,
  "company_name": "Google",
  "company_id": "1441",
  "company_username": "google",
  "company_url": "https://www.linkedin.com/company/google",
  "company_input": "https://www.linkedin.com/company/google",
  "post_id": "7185038481234567890",
  "post_urn": "urn:li:activity:7185038481234567890",
  "post_url": "https://www.linkedin.com/feed/update/urn:li:activity:7185038481234567890",
  "posted_date": "2026-04-12T14:30:00Z",
  "posted_time_ago": "3d",
  "text": "Excited to share our newest developments in scalable computing architecture and cloud infrastructure. Check details at https://cloud.google.com/blog/ai-future #AI #Cloud",
  "hashtags": [
    "#AI",
    "#Cloud"
  ],
  "mentions": [
    "@GoogleCloud"
  ],
  "external_links": [
    "https://cloud.google.com/blog/ai-future"
  ],
  "media_type": "image",
  "media_urls": [
    "https://media.licdn.com/dms/image/v2/D4E22AQH/feedshare-shrink_800/media.jpg"
  ],
  "article_url": "https://blog.google/technology/ai/",
  "article_title": "Advancing Frontier AI Systems",
  "article_domain": "blog.google",
  "document_title": null,
  "document_pages": null,
  "is_poll": false,
  "poll_question": null,
  "poll_options": [],
  "poll_total_votes": null,
  "is_repost": false,
  "reshared_author": null,
  "reshared_post_url": null,
  "likes_count": 1420,
  "comments_count": 87,
  "reposts_count": 45,
  "total_reactions_count": 1552,
  "scraped_at": "2026-10-16T10:15:30Z"
}
```

***

### Operational Constraints & Platform Limits

1. **Public Feeds Only**: The **LinkedIn Company Posts Scraper** accesses strictly public corporate posts. Private groups, personal profile posts, and restricted internal content are not collected.
2. **Post Volume Limit (Max 80 Posts per Company)**: LinkedIn's public guest architecture serves up to ~70–80 of the most recent corporate posts per company without login credentials. To protect performance and prevent unnecessary network calls, the actor caps input at 80 posts per company and cleanly exits the moment the feed ends with zero warnings or errors.
3. **Missing Field Policy**: If an update does not include media assets or external article links, those fields return `null` or empty arrays. The scraper never invents data.
4. **Media Link Lifespans**: Direct image and video URLs point to platform-hosted content delivery networks. These external links may rotate over time per the source network's policies.
5. **Account Limits**: Free Apify tiers can collect up to 50 posts in total per run. Upgrading to a paid Apify plan removes this ceiling.

***

### Best Practices & Performance Optimization

- **Run in Batches**: When scraping posts across large lists with the **LinkedIn Company Posts Scraper**, group companies into sets of 10 to 30 organizations for structured review.
- **Target Appropriate Depths**: Requesting 20 to 80 posts per company gives an accurate representation of recent strategy while keeping run durations fast and efficient.
- **Schedule Automated Monitoring**: Schedule the **LinkedIn Company Posts Scraper** to run weekly on Apify Console to automatically collect fresh corporate posts and build longitudinal engagement benchmarks.

***

### Troubleshooting & Frequently Asked Questions

#### What is the maximum number of posts I can scrape per company?

You can scrape up to **80 recent posts per company**. LinkedIn's public guest infrastructure exposes approximately 70–76 recent posts for any organization without requiring user logins. Once the available recent posts are collected, the actor exits pagination cleanly, saves all collected records, and moves directly to the next company.

#### Does the LinkedIn Company Posts Scraper require login credentials?

No. The **LinkedIn Company Posts Scraper** operates entirely on public web data and does not require you to connect cookies, personal accounts, or login details (100% ban-free and zero account risk).

#### What happens if a company has fewer posts than requested?

If an organization has only published 4 updates in total and you asked for 80, the scraper collects all 4 available posts, reports that no further updates exist, and proceeds cleanly to the next company.

#### Can I enter company page links with `/posts` or sub-tabs?

Yes. The scraper automatically normalizes any company URL, strips sub-tabs, and accesses the feed directly.

#### Is there a post limit on a free Apify plan?

Yes. Free accounts can collect up to 50 posts in total per run. Upgrading to any paid Apify plan enables unlimited post collection.

#### Does the free limit apply per day or per run?

The limit applies per individual run. It is not a daily or lifetime restriction.

#### What should I do if the log says "Free user detected" but I am on a paid plan?

Open an issue in the **Issues** tab on the actor console with your Apify plan name and the Run ID, and our team will resolve it quickly.

#### Does this actor scrape individual comment replies or comment threads?

No. The **LinkedIn Company Posts Scraper** collects the total count of public comments (`comments_count`) and social engagement metrics for each post. It extracts public post feeds and does not scrape individual member comments or nested reply threads.

***

### Code Integration: Python, JavaScript & REST API

Run the **LinkedIn Company Posts Scraper** programmatically via official client libraries:

#### Python (`apify-client`)

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_API_TOKEN")

run_input = {
    "company_urls": [
        {"url": "https://www.linkedin.com/company/google"}
    ],
    "usernames": ["microsoft"],
    "max_posts": 20,
    "proxyCountry": "US"
}

run = client.actor("linkedin-company-posts-scraper").call(run_input=run_input)

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(f"[{item.get('company_name')}] {item.get('post_url')} | Likes: {item.get('likes_count')}")
```

#### JavaScript / Node.js (`apify-client`)

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

const client = new ApifyClient({
    token: 'YOUR_APIFY_API_TOKEN',
});

const runInput = {
    company_urls: [
        { url: 'https://www.linkedin.com/company/google' }
    ],
    usernames: ['microsoft'],
    max_posts: 20,
    proxyCountry: 'US'
};

const run = await client.actor('linkedin-company-posts-scraper').call(runInput);
const { items } = await client.dataset(run.defaultDatasetId).listItems();

items.forEach((post) => {
    console.log(`${post.company_name}: ${post.post_url} - ${post.text.slice(0, 50)}...`);
});
```

#### Direct REST API (cURL)

```bash
curl --request POST \
  --url "https://api.apify.com/v2/acts/linkedin-company-posts-scraper/runs?token=YOUR_APIFY_API_TOKEN" \
  --header "Content-Type: application/json" \
  --data '{
    "company_urls": [{"url": "https://www.linkedin.com/company/google"}],
    "usernames": ["microsoft"],
    "max_posts": 20
  }'
```

***

### Technical Architecture Glossary

| Term | Definition |
|---|---|
| **Actor Run** | A single execution of the **LinkedIn Company Posts Scraper** initialized via web UI, API, or automated schedule. |
| **Default Dataset** | The storage container generated automatically for each run, accessible in JSON, CSV, Excel, and XML formats. |
| **Post Row** | A discrete record representing one public LinkedIn feed update with attached metadata and metrics. |
| **Item Limit** | The maximum total posts a free account may collect during one execution (50 posts). |
| **Activity URN** | The permanent, unique resource identifier assigned by LinkedIn to each feed post. |

***

### Complementary Scrapers in the Ecosystem

Combine data from the **LinkedIn Company Posts Scraper** with our complementary actors:

- **LinkedIn Company Scraper**: Extract complete organization profiles, employee scale, website, office locations, and affiliated pages.
- **Meta Ad Scraper**: Collect running ads, creative assets, spend disclosures, and audience impressions across Facebook and Instagram advertisers.
- **Meta Ad Search Actor**: Search the public Meta Ad Library by brand keyword or niche to identify active advertisers worldwide.

***

### Support & Feedback Channels

If you encounter unexpected errors, missing fields, or have feature requests for the **LinkedIn Company Posts Scraper**:

- Navigate to the **Issues** tab on this actor's console page.
- Create a new ticket with your **Run ID**, your target input companies, and a brief summary of the issue.
- Our team monitors issues actively to ensure seamless operation across all public company feeds.

# Actor input Schema

## `company_urls` (type: `array`):

Links of the LinkedIn company pages whose posts you want to collect. Accepted formats:

- https://www.linkedin.com/company/google
- https://www.linkedin.com/company/microsoft/
- links with sub-tabs (e.g. /posts) or tracking parameters.

Each company's feed is collected independently.

## `usernames` (type: `array`):

LinkedIn company handles or usernames, for example google, microsoft, or chipotle-mexican-grill. One per line. Type each one exactly as it appears in the company page link after linkedin.com/company/. They work identically to company links.

## `max_posts` (type: `integer`):

Maximum number of recent posts and feed updates to collect for each company (maximum 80, as LinkedIn serves up to ~70–80 recent posts to guest visitors). The run stops automatically when LinkedIn has no more posts for a company. A free Apify account collects up to 50 posts in total per run across all companies; a paid plan can collect up to 80 posts per company.

## `proxyCountry` (type: `string`):

The country your run connects from. Pick the one closest to your target market. If a country is not available right now, the run connects from the United States instead and the log says so.

## Actor input object example

```json
{
  "company_urls": [
    {
      "url": "https://www.linkedin.com/company/google"
    }
  ],
  "usernames": [
    "microsoft"
  ],
  "max_posts": 10,
  "proxyCountry": "US"
}
```

# Actor output Schema

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

Every row this run delivered. Use the Export button on the Output tab for CSV, Excel, JSON or XML.

# 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 = {
    "company_urls": [
        {
            "url": "https://www.linkedin.com/company/google"
        }
    ],
    "usernames": [
        "microsoft"
    ],
    "max_posts": 10,
    "proxyCountry": "US"
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlix/linkedin-company-posts-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 = {
    "company_urls": [{ "url": "https://www.linkedin.com/company/google" }],
    "usernames": ["microsoft"],
    "max_posts": 10,
    "proxyCountry": "US",
}

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

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

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

```

## CLI example

```bash
echo '{
  "company_urls": [
    {
      "url": "https://www.linkedin.com/company/google"
    }
  ],
  "usernames": [
    "microsoft"
  ],
  "max_posts": 10,
  "proxyCountry": "US"
}' |
apify call crawlix/linkedin-company-posts-scraper --silent --output-dataset

```

## MCP server setup

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

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

## OpenAPI specification

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