# LinkedIn Company Posts Scraper (No Cookies) (`muhammadafzal/linkedin-company-posts-scraper`) Actor

Extract public LinkedIn company post text, IDs, URLs and dates without login cookies. Monitor announcements and competitor content using ScrapeCreators.

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

## Pricing

from $8.00 / 1,000 linkedin company 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 Scraper (No Cookies)

Extract public LinkedIn company posts into an Apify dataset using the ScrapeCreators API. This Actor requires no LinkedIn login, session cookies, browser, or proxy settings. The owner supplies the provider key through a private environment secret; users provide company URLs and bounded limits.

### What it extracts

| Field | Meaning |
| --- | --- |
| `postId` | Stable activity ID for deduplication |
| `postUrl` | Public post permalink |
| `companyUrl` | Canonical input company page |
| `companySlug` | Company URL slug or numeric identifier |
| `text` | Public post text, including Unicode |
| `publishedAt` | Provider ISO date, or `null` when unavailable |
| `page` | Source page, from 1 to 7 |
| `scrapedAt` | Collection timestamp in UTC |

Use it for competitor content monitoring, marketing research, company announcement tracking, and building a company post dataset for analysis. It does not promise a complete historical archive. Personal profiles, private posts, deleted content, employee lists, reactions, comments, and media enrichment are outside this Actor’s contract.

### Input

```json
{
  "companyUrls": ["https://www.linkedin.com/company/shopify/"],
  "maxResults": 20,
  "maxPostsPerCompany": 20,
  "startPage": 1,
  "maxPagesPerCompany": 1
}
```

`companyUrls` accepts 1–20 HTTPS LinkedIn company page URLs. Locale subdomains and `/posts/` or `/about/` tabs are normalized. Duplicate company URLs are fetched once. Invalid URLs and unsupported input properties are rejected before provider work.

`maxResults` limits all unique posts in the run (1–1000). `maxPostsPerCompany` limits each company (1–200). The first reached limit wins. Verified Apify free-plan runs are capped at **five posts**, enforced before requests and before every write. Local runs with an unknown subscription status are not automatically treated as free accounts.

`startPage` and `maxPagesPerCompany` select a bounded portion of the public feed. ScrapeCreators documents a maximum of **seven pages**. The last selected page cannot exceed seven. Start with one page; increase only when additional history is needed. Empty pages and identical page responses stop pagination. Two consecutive companies without new valid posts stop the run with an explicit warning to bound unproductive provider spend. The Actor makes at most three HTTP attempts per selected page, with sequential company processing, short backoff, a 30-second per-attempt timeout, and a three-minute total runtime bound. Company and result limits keep provider work bounded even if no posts are returned.

### Output and diagnostics

One dataset row represents one validated, unique post. Deduplication uses `postId` across all input companies. Invalid post records are skipped with warnings; no fallback posts are invented. `publishedAt` is supplied by the provider and can be missing or approximate; it is not independently verified against LinkedIn.

The `OUTPUT` key-value record contains the outcome, delivered count, provider request count, observed provider credits, warnings, effective limit, stop reason, and SDK-observed charged result events. Outcome values distinguish `DATA`, `EMPTY`, `PARTIAL`, `REJECTED`, and `FAILED`. Provider authentication, exhausted credits, blocked sources, timeouts, and malformed responses produce explicit diagnostics. A provider failure that prevents all data makes the run fail; valid partial data remains available.

Export the dataset as JSON, CSV, Excel, or through the Apify dataset API. Use the `posts` dataset view for a readable table. API callers can POST the example input to `/v2/acts/{actorId}/runs` with an Authorization header. Supply the Apify token through your application’s secret manager; never place it in the input. MCP clients can invoke the Actor with the same input and retrieve the default dataset plus `OUTPUT`.

### Pricing

The intended all-in pay-per-event prices are below. These prices are configured in the private deployment; final verification is recorded in the QA report. PLATINUM and DIAMOND use the GOLD rates. Underlying Apify platform usage is not passed through separately. The automatic start event occurs even if input is rejected, the source returns no posts, or the provider fails. No result event is charged for empty results or invalid records.

| Tier | Discount | Start per run | Per delivered post |
| --- | --- | --- | --- |
| FREE | 0% | $0.02000 | $0.01000 |
| BRONZE | 2.5% | $0.01950 | $0.00975 |
| SILVER | 5% | $0.01900 | $0.00950 |
| GOLD | 20% | $0.01600 | $0.00800 |

At list price, one post costs $0.03, five posts $0.07, and twenty posts $0.22. At GOLD, the same totals are $0.024, $0.056, and $0.176. Minimum total-charge budget is $0.03. The SDK enforces the remaining budget before dataset writes; the Actor checks it before provider work and each write. Synthetic events are never charged manually.

Provider costs are billed to the owner’s ScrapeCreators account independently of Apify. The documented company-posts endpoint and initial live probe consume one credit per page; retries may consume additional credits. A maximum input selects 140 pages and permits 420 HTTP attempts. A charge cap limits event charges, not the provider’s invoice. The runtime and request bounds apply separately.

Pricing assumes a conservative $0.002 per provider credit, based on the provider’s published $10/5,000 entry pack, subject to the owner’s actual credit plan. Final cloud evidence records measured platform usage and provider credits; prices must be revisited if those assumptions or provider prices change. Apify’s documented creator share is 80% of event revenue, before platform and external provider costs.

### Owner setup and reliability

Install with `npm ci`, run `npm test` and `npm run check`, then configure `SCRAPECREATORS_API_KEY`. For local runs, load it through a secret manager or environment. For deployment, `.actor/actor.json` references the current user’s configured Apify CLI secret of the same name. No key is stored in source or accepted as a user input field.

The implementation calls `GET https://api.scrapecreators.com/v1/linkedin/company/posts` with company URL and page number, using `x-api-key` authentication. Missing or invalid operator credentials are configuration failures, not empty feeds. HTTP 401, 402, 403 and 404 are not retried; transient HTTP errors and network failures receive at most two retries. A circuit breaker stops systemic failures after two company request failures. Run results reflect public availability at collection time.

Development and preset Tasks remain private. Publication is an owner action after checking final cloud evidence, pricing, permissions, branding, and claims. No third-party logo is included. There is no Standby server and no requirement to store LinkedIn sessions.

### Responsible use

Collect only public information you are authorized to process, and follow LinkedIn, ScrapeCreators, and Apify terms and applicable data-protection requirements. This Actor cannot access content hidden behind login or other access controls. Retain only the data needed for your research and downstream workflow.

### Sources

- [ScrapeCreators API specification](https://docs.scrapecreators.com/openapi.json)
- [Apify pay-per-event documentation](https://docs.apify.com/actors/publishing/monetize/pay-per-event)

# Actor input Schema

## `companyUrls` (type: `array`):

Use public LinkedIn company pages, e.g. https://www.linkedin.com/company/shopify/. Supports 1–20 URLs; duplicates are removed. Personal profiles and post URLs are unsupported.

## `maxResults` (type: `integer`):

Maximum unique posts across all companies. Verified Apify free-plan runs are capped at five.

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

Maximum unique posts delivered from each company. The total result limit also applies.

## `startPage` (type: `integer`):

Start at page 1–7. Use later pages to inspect older publicly exposed posts.

## `maxPagesPerCompany` (type: `integer`):

Fetch at most seven pages per company. startPage + maxPagesPerCompany - 1 cannot exceed seven. Each page normally costs one provider credit.

## Actor input object example

```json
{
  "companyUrls": [
    "https://www.linkedin.com/company/shopify/"
  ],
  "maxResults": 20,
  "maxPostsPerCompany": 20,
  "startPage": 1,
  "maxPagesPerCompany": 1
}
```

# Actor output Schema

## `posts` (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 = {
    "companyUrls": [
        "https://www.linkedin.com/company/shopify/"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("muhammadafzal/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 = { "companyUrls": ["https://www.linkedin.com/company/shopify/"] }

# Run the Actor and wait for it to finish
run = client.actor("muhammadafzal/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 '{
  "companyUrls": [
    "https://www.linkedin.com/company/shopify/"
  ]
}' |
apify call muhammadafzal/linkedin-company-posts-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,muhammadafzal/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/Fh2veaXURUXhqzQZZ/builds/kgJKts158WO5EwgAi/openapi.json