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

Extract recent posts from LinkedIn company pages — headlines, full post body text, dates, like counts, post URLs, and author info. No login required. Accepts company slugs or full URLs. Batch multiple companies in one run.

- **URL**: https://apify.com/automation-lab/linkedin-company-posts-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Social media
- **Stats:** 12 total users, 7 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.50 / 1,000 post scrapeds

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

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

### What does LinkedIn Company Posts Scraper do?

[LinkedIn Company Posts Scraper](https://apify.com/automation-lab/linkedin-company-posts-scraper) extracts **recent posts from LinkedIn company pages** — get post headlines, full post body text, publish dates, post URLs, and author info without logging in or using the LinkedIn API.

**No login required.** This scraper uses pure HTTP requests with residential proxy to fetch public LinkedIn company pages and extracts structured data embedded in the HTML. Each company page yields approximately **10-30 of the most recent posts** including the full text of each post.

Try it now — paste a company URL, or just type a slug like `google`, `microsoft`, or `apify` and click **Start**.

**Why this scraper stands out:**
- Extracts **full post text** (not just headlines) — 10 structured fields per post
- No LinkedIn account or API key needed
- Accepts full URLs, partial URLs, or simple slugs
- Batch scrape multiple companies in one run
- 5x cheaper than the leading competitor (apimaestro charges $0.005/post, we charge $0.001)

### Who is LinkedIn Company Posts Scraper for?

**B2B Marketing & Competitive Intelligence Teams**
- Monitor what competitors are publishing and which topics get the most engagement
- Track company announcements, product launches, and PR activity via LinkedIn
- Build a content calendar by analyzing top-performing posts in your industry

**Sales & Business Development Professionals**
- Stay informed about prospect companies before outreach — reference their recent posts
- Track funding announcements, partnerships, and product news from target accounts
- Trigger outreach sequences when companies post about topics relevant to your product

**Market Researchers & Analysts**
- Collect thought leadership content across a sector for trend analysis
- Analyze posting cadence and content strategy of industry players
- Feed LinkedIn company post data into AI models for sentiment analysis and topic extraction

**Data Engineers & Developers**
- Integrate LinkedIn company content into monitoring pipelines via the Apify API
- Automate competitive intelligence dashboards with scheduled scraping runs
- Connect LinkedIn data to AI agents via MCP for real-time company research

### Why use LinkedIn Company Posts Scraper?

- 🔓 **No login or cookies required** — scrapes public company pages without authentication
- 📝 **Full post body text** — get the complete text of each post, not just the headline
- 💰 **5x cheaper than competitors** — $0.001/post vs $0.005/post (apimaestro)
- ⚡ **Pure HTTP** — fast and lightweight, no browser overhead
- 🏢 **Flexible input** — accepts full LinkedIn URLs, partial URLs, or just company slugs
- 🔄 **Batch scraping** — process dozens of companies in a single run
- ⏰ **Scheduling** — set up recurring runs for ongoing competitor monitoring
- 📁 **Export** — download results as JSON, CSV, or Excel
- 🏠 **Residential proxy included** — all proxy costs built into the per-post price
- 🤖 **MCP compatible** — connect directly to Claude and other AI assistants

### What data can you extract?

Each post yields up to **10 structured fields**:

| Category | Fields |
|----------|--------|
| 🏢 **Company** | companyName, companySlug, companyUrl |
| 📝 **Post Content** | postType (Article / DiscussionForumPosting), headline, text (full body) |
| 📅 **Dates** | datePublished |
| 🔗 **Links** | postUrl |
| ✍️ **Author** | authorName |
| 🕐 **Metadata** | scrapedAt |

**Post types explained:**
- **Article** — long-form LinkedIn articles published by the company
- **DiscussionForumPosting** — standard LinkedIn feed posts, updates, and announcements

**Important note on data scope:** This scraper extracts data embedded in LinkedIn's public HTML (JSON-LD structured data). Each company page shows approximately 10-30 recent posts. The scraper returns the full post body text alongside headlines and metadata. Fields like comment counts, share counts, and reaction breakdowns are not available from the public page without login.

### How much does it cost to scrape LinkedIn company posts?

This Actor uses **pay-per-event** pricing — you pay only for what you scrape.
No monthly subscription. All platform and residential proxy costs are **included**.

| | Free | Starter ($29/mo) | Scale ($199/mo) | Business ($999/mo) |
|---|---|---|---|---|
| **Per post** | $0.001 | $0.0009 | $0.0007 | $0.0005 |
| **1,000 posts** | $1.00 | $0.90 | $0.70 | $0.50 |
| **10,000 posts** | $10.00 | $9.00 | $7.00 | $5.00 |

A one-time **$0.01 start fee** applies per run to cover initialization.

**Real-world cost examples (Free tier):**

| Input | Companies | Posts | Duration | Cost |
|---|---|---|---|---|
| 1 company | 1 | ~10 | ~8s | ~$0.020 |
| 5 companies | 5 | ~50 | ~30s | ~$0.060 |
| 20 companies | 20 | ~200 | ~2min | ~$0.210 |

Each company returns approximately 10-30 recent posts. You pay per post scraped. The free plan ($5 credit) lets you scrape approximately **5,000+ posts** before spending a dollar.

### How to scrape LinkedIn company posts

1. 🔗 Go to [LinkedIn Company Posts Scraper](https://apify.com/automation-lab/linkedin-company-posts-scraper) on Apify Store
2. 📋 Click **Try for free** to open the Actor in Apify Console
3. 🏢 Enter company URLs or slugs (e.g., `google`, `microsoft`, `https://www.linkedin.com/company/apify/`)
4. ⚙️ Set **Max Posts Per Company** if you want to limit results (default: 30)
5. ▶️ Click **Start** and wait for the run to finish
6. 📊 Preview results in the **Dataset** tab — switch to **Posts** view for a table layout
7. 💾 Export as **JSON**, **CSV**, or **Excel** — or connect via API

**Input examples for different scenarios:**

Monitor a list of competitors:
```json
{
    "companyUrls": ["salesforce", "hubspot", "zendesk"],
    "maxPostsPerCompany": 20
}
````

Use full LinkedIn URLs:

```json
{
    "companyUrls": [
        "https://www.linkedin.com/company/google/",
        "https://www.linkedin.com/company/microsoft/"
    ],
    "maxPostsPerCompany": 30
}
```

Quick single company check:

```json
{
    "companyUrls": ["openai"],
    "maxPostsPerCompany": 10,
    "maxCompanies": 1
}
```

### Input parameters

| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| `companyUrls` | Array of strings | Yes | — | LinkedIn company URLs or slugs. Accepts `https://www.linkedin.com/company/google/`, `linkedin.com/company/google`, or just `google`. |
| `maxPostsPerCompany` | Integer | No | 30 | Maximum posts to extract per company (1–100). LinkedIn typically shows 10-30 posts on the public page. |
| `maxCompanies` | Integer | No | 100 | Maximum number of companies to process. Useful when you have a long list but only want a subset. |

### Output examples

Each company produces multiple post objects in the dataset. Here is a sample:

```json
{
    "companyName": "Google",
    "companySlug": "google",
    "companyUrl": "https://www.linkedin.com/company/google",
    "postType": "DiscussionForumPosting",
    "headline": "New AI capabilities are coming to Google Vids",
    "text": "New AI capabilities, powered by Lyria 3 and Veo 3.1, are starting to roll out to Google Vids. With these new features, you'll be able to: ✨ Generate high-quality video clips from just a simple prompt or photo ✨ Score your video with custom music generation in Lyria 3...",
    "datePublished": "2026-04-02T18:10:18.151Z",
    "postUrl": "https://www.linkedin.com/posts/google_new-ai-capabilities-are-coming-to-google-activity-7445533082427858945-QyGB",
    "authorName": "Google",
    "scrapedAt": "2026-04-04T00:38:29.585Z"
}
```

```json
{
    "companyName": "Apify",
    "companySlug": "apify",
    "companyUrl": "https://www.linkedin.com/company/apify",
    "postType": "DiscussionForumPosting",
    "headline": "Build smarter AI agents with the Actor SDK",
    "text": "We just released a major update to the Apify Actor SDK. Here's what's new...",
    "datePublished": "2026-04-01T14:22:00.000Z",
    "postUrl": "https://www.linkedin.com/posts/apify_build-smarter-ai-agents-activity-7444900123456789012-AbCd",
    "authorName": "Apify",
    "scrapedAt": "2026-04-04T00:40:12.183Z"
}
```

### Tips for best results

- 🎯 **Start small** — test with 1-2 companies first to verify the data meets your needs before scaling up
- 🔄 **Schedule recurring runs** — set up daily or weekly runs to monitor competitor posts automatically
- 📋 **Use slugs for convenience** — `google` is easier to type than the full URL and works just as well
- ⚠️ **Post count varies by company** — large companies like Google typically have 10+ recent posts; smaller companies may have fewer visible on their public page
- 🏢 **Company vs personal profiles** — this scraper is for company pages only. For personal profiles, use [LinkedIn Post Scraper](https://apify.com/automation-lab/linkedin-post-scraper)
- 🧮 **Budget planning** — each post costs $0.001 (Free tier) plus a one-time $0.01 start fee. For 10 companies × 20 posts = 200 posts + start fee = $0.21
- 🔍 **Check post count** — if a company returns fewer posts than expected, they may have limited their public visibility or the scraper hit LinkedIn's anti-bot protection (retry later)

### Integrations

LinkedIn Company Posts Scraper works with the full Apify ecosystem and thousands of external tools.

**Competitor content monitoring pipeline**

- Schedule daily runs for a list of 10-20 competitor company slugs
- Connect to Google Sheets via Zapier to append new posts to a running log
- Set up Slack alerts when specific keywords appear in competitor posts

**AI-powered competitive intelligence**

- Run the scraper on 5-10 target companies weekly
- Feed post text to Claude or GPT for topic classification and sentiment analysis
- Automatically generate competitive intelligence briefings for your team

**Sales trigger workflow**

- Scrape posts from 50+ target accounts weekly
- Push results to HubSpot when a prospect posts about a topic relevant to your product
- Trigger personalized email sequences based on specific company announcements

**Content research and ideation**

- Collect posts from 20 industry thought leaders weekly
- Send results to Airtable for your content team's review
- Use engagement patterns and topics to inform your own content calendar

**Supported integrations:**

- 🔗 Zapier, Make (Integromat), n8n
- 📊 Google Sheets, Airtable, Excel
- 💼 HubSpot, Salesforce, Pipedrive
- 💬 Slack, Microsoft Teams, Discord
- 🗄️ S3, Google Cloud Storage, Dropbox
- 🔌 REST API, webhooks

### Using the Apify API

Call LinkedIn Company Posts Scraper programmatically using the Apify API.

#### Node.js

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

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

const run = await client.actor('automation-lab/linkedin-company-posts-scraper').call({
    companyUrls: ['google', 'microsoft', 'apify'],
    maxPostsPerCompany: 20,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((post) => {
    console.log(`${post.companyName}: ${post.headline}`);
    console.log(`Published: ${post.datePublished}`);
    console.log(`URL: ${post.postUrl}`);
});
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")

run = client.actor("automation-lab/linkedin-company-posts-scraper").call(run_input={
    "companyUrls": ["google", "microsoft", "apify"],
    "maxPostsPerCompany": 20,
})

for post in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(f"{post['companyName']}: {post['headline']}")
    print(f"Published: {post['datePublished']}")
    print(f"URL: {post['postUrl']}")
```

#### cURL

```bash
## Start the actor run
curl -X POST "https://api.apify.com/v2/acts/automation-lab~linkedin-company-posts-scraper/runs?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "companyUrls": ["google", "microsoft", "apify"],
    "maxPostsPerCompany": 20
  }'

## Fetch results (replace DATASET_ID with the value from the run response)
curl "https://api.apify.com/v2/datasets/DATASET_ID/items?token=YOUR_APIFY_TOKEN&format=json"
```

### Use with AI agents via MCP

LinkedIn Company Posts Scraper is available as a tool for AI assistants that support the [Model Context Protocol (MCP)](https://docs.apify.com/platform/integrations/mcp).

Add the Apify MCP server to your AI client — this gives you access to all Apify actors, including this one:

#### Setup for Claude Code

```bash
claude mcp add --transport http apify "https://mcp.apify.com"
```

#### Setup for Claude Desktop, Cursor, or VS Code

Add this to your MCP config file:

```json
{
    "mcpServers": {
        "apify": {
            "url": "https://mcp.apify.com"
        }
    }
}
```

Your AI assistant will use OAuth to authenticate with your Apify account on first use.

#### Example prompts

Once connected, try asking your AI assistant:

- "Use automation-lab/linkedin-company-posts-scraper to fetch the last 20 posts from Google, Microsoft, and OpenAI and summarize what each company is talking about this week"
- "Get LinkedIn posts from salesforce and hubspot for the past month and identify their top content themes"
- "Scrape recent posts from apple and samsung on LinkedIn, then tell me what product launches or announcements they've made"

Learn more in the [Apify MCP documentation](https://docs.apify.com/platform/integrations/mcp).

### Is it legal to scrape LinkedIn company posts?

Web scraping of publicly available data is generally legal, as confirmed by the [US Ninth Circuit ruling in hiQ Labs v. LinkedIn](https://en.wikipedia.org/wiki/HiQ_Labs_v._LinkedIn) (2022), which held that scraping public LinkedIn profiles does not violate the Computer Fraud and Abuse Act (CFAA).

This Actor only accesses **publicly available** LinkedIn company pages — the same data any visitor can see without logging in. It does not bypass any authentication, access private data, or violate LinkedIn's login barriers.

However, you should:

- Review LinkedIn's [Terms of Service](https://www.linkedin.com/legal/user-agreement) for your use case
- Comply with applicable data protection laws (GDPR, CCPA, etc.)
- Use the collected data responsibly and ethically
- Consult legal counsel if you have specific compliance questions

For more information, see Apify's guide on the [legality of web scraping](https://blog.apify.com/is-web-scraping-legal/).

### FAQ

**How many posts can I get per company?**
Each company page typically shows **10-30 of the most recent posts**. This is determined by what LinkedIn embeds in the public page's structured data — not a limitation of the scraper. Large, active companies (Google, Microsoft) tend to have more posts visible than smaller ones.

**Why did a company return 0 posts?**
This can happen when: (a) LinkedIn's anti-bot protection blocked the request — wait 10-15 minutes and retry; (b) the company doesn't have public posts visible without login; (c) the company slug is incorrect (check the URL at linkedin.com/company/SLUG). Invalid company slugs return a 404 and are skipped automatically.

**Can I get comment counts, share counts, or reaction breakdowns?**
No — these metrics are not available on the public LinkedIn company page without login. The public page embeds post headlines, body text, and dates, but not engagement stats. If you need engagement data, that would require authenticated access.

**Does this scraper work for personal LinkedIn profiles?**
No — this scraper is designed for **company pages** only (linkedin.com/company/SLUG). For personal profiles, use [LinkedIn Post Scraper](https://apify.com/automation-lab/linkedin-post-scraper).

**Why is the scraper slower than expected?**
LinkedIn uses anti-bot detection that sometimes requires multiple retries with different residential proxy IPs. The scraper automatically retries up to 3 times with exponential backoff. A 1-second delay between company requests also helps avoid rate limiting.

**Does this require a LinkedIn account or API key?**
No. LinkedIn Company Posts Scraper works entirely without login. It fetches the public version of company pages using residential proxies, extracting structured data (JSON-LD) embedded in the HTML.

**How does this compare to apimaestro/linkedin-company-posts?**
Both scrapers extract posts from LinkedIn company pages without login. Our scraper is **5x cheaper** ($0.001/post vs $0.005/post). The main trade-off: our scraper returns full post body text from the public page JSON-LD; apimaestro appears to use a third-party API proxy that may offer additional fields. Try both and compare on your specific use case.

### Other LinkedIn scrapers

- 👤 [LinkedIn Post Scraper](https://apify.com/automation-lab/linkedin-post-scraper) — Extract recent posts from LinkedIn personal profiles with headlines, dates, and like counts
- 🏢 [LinkedIn Company Scraper](https://apify.com/automation-lab/linkedin-company-scraper) — Extract company profile data: size, industry, headquarters, employee count, founded year
- 💼 [LinkedIn Jobs Scraper](https://apify.com/automation-lab/linkedin-jobs-scraper) — Scrape job listings from LinkedIn job search results with full job descriptions
- 👥 [LinkedIn Profile Scraper](https://apify.com/automation-lab/linkedin-profile-scraper) — Extract detailed LinkedIn profile data: experience, education, skills, and contact info

# Actor input Schema

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

LinkedIn company page URLs or slugs. Accepts full URLs (https://www.linkedin.com/company/google/) or just the slug (google).

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

Maximum number of posts to extract per company. LinkedIn typically shows 15-30 posts on the public page.

## `maxCompanies` (type: `integer`):

Maximum number of companies to process. Useful when you have a long list and only want to process a subset.

## Actor input object example

```json
{
  "companyUrls": [
    "google",
    "microsoft"
  ],
  "maxPostsPerCompany": 15,
  "maxCompanies": 5
}
```

# Actor output Schema

## `posts` (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": [
        "google",
        "microsoft"
    ],
    "maxPostsPerCompany": 15,
    "maxCompanies": 5
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/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": [
        "google",
        "microsoft",
    ],
    "maxPostsPerCompany": 15,
    "maxCompanies": 5,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/linkedin-company-posts-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 '{
  "companyUrls": [
    "google",
    "microsoft"
  ],
  "maxPostsPerCompany": 15,
  "maxCompanies": 5
}' |
apify call automation-lab/linkedin-company-posts-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "LinkedIn Company Posts Scraper",
        "description": "Extract recent posts from LinkedIn company pages — headlines, full post body text, dates, like counts, post URLs, and author info. No login required. Accepts company slugs or full URLs. Batch multiple companies in one run.",
        "version": "0.1",
        "x-build-id": "a9fZig7Ma5Szzgo29"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~linkedin-company-posts-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-linkedin-company-posts-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/automation-lab~linkedin-company-posts-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-linkedin-company-posts-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/automation-lab~linkedin-company-posts-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-linkedin-company-posts-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": [
                    "companyUrls"
                ],
                "properties": {
                    "companyUrls": {
                        "title": "Company URLs or Slugs",
                        "type": "array",
                        "description": "LinkedIn company page URLs or slugs. Accepts full URLs (https://www.linkedin.com/company/google/) or just the slug (google).",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxPostsPerCompany": {
                        "title": "Max Posts Per Company",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Maximum number of posts to extract per company. LinkedIn typically shows 15-30 posts on the public page.",
                        "default": 30
                    },
                    "maxCompanies": {
                        "title": "Max Companies",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum number of companies to process. Useful when you have a long list and only want to process a subset.",
                        "default": 100
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```