# LinkedIn Company API (`truefetch/linkedin-company-api`) Actor

Look up one public LinkedIn company page and return a source-dependent profile snapshot with company details, counts, locations, highlighted people, Life sections, updates, and optional job records.

- **URL**: https://apify.com/truefetch/linkedin-company-api.md
- **Developed by:** [TrueFetch](https://apify.com/truefetch) (community)
- **Categories:** Business, Marketing, Automation
- **Stats:** 15 total users, 5 monthly users, 100.0% runs succeeded, 2 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $0.30 / result

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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

**Independent LinkedIn data extraction Actor.** LinkedIn Company Profile is not affiliated with, endorsed by, or operated by LinkedIn or Microsoft. It reads information exposed on a public company page; page access, field availability, and values can change without notice.

LinkedIn Company Profile turns one `linkedin.com/company/...` URL into a source-dependent company snapshot. The possible contract covers company identity, About text, website, industry, size, type, headquarters, address, specialties, public links, dynamic employee and follower counts, locations, highlighted people, update samples, Life sections, and optional job details.

- A verified Apple run returned one company row with 20 of the 26 possible top-level keys.
- A second Apple run with `max_jobs=1` returned one company Result and one separately charged Job.
- Every populated row includes a canonical company URL, processing timestamp, status, page type, and Actor provenance.
- Empty values are omitted instead of invented, preserving the difference between observed and unavailable data.

This Actor is a snapshot extractor, not a verification service or a complete company database. Counts changed between valid runs, highlighted people are not guaranteed decision-makers, and a successful run can produce zero rows when the source cannot be parsed. Review the Dataset before using it for outreach, hiring, scoring, or material decisions.

[Run one company profile](https://console.apify.com/actors/zSJMwA6pZ817yodN3/input) · [Connect through the Apify API](https://docs.apify.com/api/v2)

### What does LinkedIn Company Profile do?

The Actor accepts one public LinkedIn company-page URL, requests the available company surfaces, normalizes the extracted values, removes empty values, and writes one traceable Dataset item when a company name can be parsed. It combines fields that may appear across overview data, page text, structured markup, locations, highlighted people, updates, Life content, and the optional Jobs route.

The possible top-level contract contains 26 keys. They include provenance keys such as `processor` and `processed_at`; identity keys such as `linkedin_url`, `name`, and `headline`; profile attributes such as `industry`, `company_size`, and `founded`; dynamic values such as employee and follower counts; and nested arrays for locations, people, updates, Life sections, and jobs. A real row normally contains only the subset exposed and parsed during that run.

The Actor does not search by company name, process a list of URLs, scrape member profiles, send messages, verify employment, enrich data from private databases, or certify that a value is current. It also does not turn source-selected people into an executive roster. The result should remain attached to its source URL and timestamp.

### How do I run LinkedIn Company Profile?

Open the input page and begin with one HTTPS LinkedIn company URL. Keep job collection disabled for the first run. This isolates the core profile request, avoids optional Job events, and gives you a simple one-row expectation.

```json
{
  "linkedin_url": "https://www.linkedin.com/company/apple/",
  "max_jobs": 0
}
```

Start the Actor, wait for a terminal status, and inspect the default Dataset. A populated run contains at most one company row. If the Dataset is empty, review the status message and source URL; `SUCCEEDED` confirms that the process ended normally, not that LinkedIn exposed a parsable company profile.

For a second controlled test, set `max_jobs` to `1`. Compare the returned `jobs` length with charged events. The verified job scenario produced Actor Start `1`, Result `1`, and Job `1`; the company-only scenario produced Job `0`. Persist the run ID, Dataset ID, input, item count, timestamp, and event counts for later comparison.

### What data does LinkedIn Company Profile return?

The Dataset schema exposes the following field groups:

| Group | Possible fields | Interpretation |
| --- | --- | --- |
| Provenance | `processor`, `processed_at`, `status`, `type` | Run-specific trace data; a row is written only when a name is parsed. |
| Identity | `linkedin_url`, `name`, `headline`, `logo_url` | Source-facing company identity and media. |
| Profile | `about`, `website`, `industry`, `company_size`, `company_type`, `founded` | Company or source labels, not externally verified attributes. |
| Place and contact | `headquarters`, `address`, `locations`, `phones`, `social_links` | Publicly exposed values that may be incomplete or omitted. |
| Classification | `specialties` | Company-declared focus labels without taxonomy normalization. |
| Dynamic signals | `employee_count`, `follower_count` | Parsed snapshot values, not audited totals or a stable time series. |
| Samples | `featured_employees`, `updates`, `life` | Source-selected people, activity, and culture sections; not complete archives. |
| Optional hiring | `jobs` | Retained job details; each retained record uses the separate Job event. |

This shortened example reflects the shape of a verified Apple company-only run. Values are illustrative snapshots and will change.

```json
{
  "processor": "https://apify.com/truefetch/linkedin-company-profile?fpr=aiagentapi",
  "processed_at": "2026-07-23T21:34:09+00:00",
  "status": "success",
  "type": "company",
  "linkedin_url": "https://www.linkedin.com/company/apple/",
  "name": "Apple",
  "website": "http://www.apple.com/careers",
  "industry": "Computers and Electronics Manufacturing",
  "company_size": "10,001+ employees",
  "company_type": "Public Company",
  "headquarters": "Cupertino, California",
  "employee_count": 206263,
  "follower_count": 18337808,
  "specialties": ["Innovative Product Development", "World-Class Operations", "Retail"]
}
```

Nested records can also be sparse. A location may contain address lines and a directions URL. A highlighted person may contain a name, profile URL, image, subtitle, and source influencer flag. A job may contain its LinkedIn URL, title, posting text, location, applicant count, description, employment type, seniority, function, and industries.

### What inputs can I configure?

| Parameter | Type | Required | Range or format | Behavior |
| --- | --- | --- | --- | --- |
| `linkedin_url` | string | Yes | `https://www.linkedin.com/company/{slug}/` | One public company page. The public schema rejects unsupported paths and malformed URL forms. |
| `max_jobs` | integer | No | `0` to `100`; default `0` | Requested job-detail cap. Zero skips the Jobs tab; a positive value can return fewer items. |

Only values supplied through these fields are supported. The Actor does not accept cookies, credentials, member-profile URLs, Sales Navigator links, company-name queries, date ranges, geographic filters, or URL arrays. Use a separate run for each company so the input, outcome, and charge evidence remain unambiguous.

The positive job cap is a collection ceiling, not a promise. LinkedIn can expose fewer job links, detail requests can fail, duplicates can be removed, and a charge limit can stop retention before the requested number is reached.

### What platforms and markets does LinkedIn Company Profile cover?

The supported source is the public LinkedIn company path on `www.linkedin.com`. The input is not country-specific, and there is no market selector. Company pages may represent organizations from many regions, but source accessibility, labels, languages, locations, and available tabs can vary by company and request context.

The Actor does not claim global completeness. A company can maintain multiple pages, omit a headquarters value, expose localized labels, or show different content over time. URLs outside the `/company/` path are outside the input contract. Media and directions URLs remain third-party links and may expire or redirect after collection.

### Why use LinkedIn Company Profile?

The main benefit is a stable, machine-readable envelope around a changing public page. Instead of coupling an integration to raw HTML, consumers receive named fields, nested records, a canonical URL, a timestamp, and a processing status. Empty values are removed consistently, which supports explicit key-presence checks.

The Actor is also useful for controlled, low-volume enrichment because jobs are opt-in. You can first validate the company row with `max_jobs=0`, then request a small job cap only where hiring data is relevant. Separate Result and Job events make the two output surfaces visible in run charges.

Traceability is more important than apparent completeness. Keeping the Dataset ID, run ID, URL, and timestamp lets analysts distinguish a current observation from an older export and investigate source drift.

### Who is LinkedIn Company Profile for?

CRM and revenue-operations teams can attach source-reported industry, size, type, headquarters, website, and specialties to an existing account while retaining the observation timestamp. Market researchers can collect repeated snapshots for a defined panel, provided that they treat count changes and missing fields cautiously.

Talent teams can request a small number of job details alongside company context. Developers can use the sparse schema in ETL pipelines, AI-agent tools, and review queues. Account researchers can use the public website, specialties, and highlighted people as research starting points, but highlighted people do not establish authority, relationship, or permission to contact.

The Actor is not suitable as a sole source for identity verification, regulated eligibility decisions, exact workforce accounting, complete vacancy monitoring, or automated high-impact decisions.

### How can I use LinkedIn Company Profile through the API or MCP?

The stable Actor ID is `zSJMwA6pZ817yodN3`, and the full Actor name is `truefetch/linkedin-company-profile`. Through the Apify API, start a run with the same input object, poll its terminal status, then read items from `defaultDatasetId`. Keep API tokens in server-side secret storage and out of logs.

For MCP, fetch current Actor details before execution so the client sees the current schema and pricing surface. A minimal payload is:

```json
{
  "actor": "truefetch/linkedin-company-profile",
  "input": {
    "linkedin_url": "https://www.linkedin.com/company/apple/",
    "max_jobs": 0
  },
  "callOptions": {
    "memory": 256,
    "timeout": 300
  },
  "waitSecs": 45
}
```

If the wait window expires while a run remains active, poll that run instead of creating a duplicate. Read the Dataset independently and check the top-level keys. An MCP client or account policy may allow metadata and Dataset reads while denying public Actor execution; that is an access-policy outcome, not evidence that the Actor failed.

### How much does LinkedIn Company Profile cost?

The Actor uses pay-per-event pricing. The Apify Console and the charged events recorded on your run are authoritative.

| Event | Trigger | Free | Bronze | Silver | Gold | Platinum | Diamond |
| --- | --- | ---: | ---: | ---: | ---: | ---: | ---: |
| Actor Usage | Runtime, proxy, and storage consumption | `$0.00001` per usage unit | same | same | same | same | same |
| Actor Start | Actor starts; memory rules affect counted starts | `$0.01` | same | same | same | same | same |
| Result | One company row written to the default Dataset | `$0.30000` | `$0.29000` | `$0.28000` | `$0.27000` | `$0.27000` | `$0.27000` |
| Job | Each retained job detail included in the company row | `$0.0035` | same | same | same | same | same |

At the Free-tier Result rate, a populated company-only run contributes `$0.30000` for Result plus Actor Start and metered Actor Usage. A populated run with one retained job contributes `$0.30350` for Result plus Job before Start and Usage. A zero-row run has no Result or Job event but can still incur Start and Usage.

Keep `max_jobs=0` until the company source is known to work. Raise it gradually and set any maximum-total-charge limit high enough for Result, requested Jobs, Start, and Usage. A billing cap is not a production item limit and can reduce the retained job count.

### How does LinkedIn Company Profile compare with alternatives?

Manual review can be appropriate for one consequential company because a person can inspect context and resolve ambiguity. It is slower to repeat and harder to preserve as structured evidence. This Actor is better when you need a consistent sparse JSON shape, timestamps, and run identifiers across repeated lookups.

Generic browser automation offers more control over navigation and screenshots but requires maintenance when markup changes. A broad business database may provide normalized or verified attributes, yet it may use different sources and licensing terms. LinkedIn Company Profile stays deliberately narrow: one public company URL, source-dependent fields, and optional jobs.

Choose based on evidence requirements. Use this Actor for observation and automation; use authoritative registries, the company itself, or qualified data providers when a decision requires verified legal, financial, or employment facts.

### What are the limits and troubleshooting steps?

A run can succeed with zero Dataset items if the overview request fails or a company name cannot be parsed. First verify that the URL uses HTTPS and the LinkedIn `/company/` path. Then check terminal status, status message, Dataset count, and whether the source page is publicly reachable. Retry later rather than launching many duplicate runs.

Fields can disappear because the page changed, a tab was unavailable, or the response variant omitted content. Compare present keys instead of assuming a missing value is an empty real-world fact. Dynamic counts can differ between nearby runs. Require repeated observations or another source before interpreting a delta as growth or decline.

For jobs, compare requested `max_jobs`, actual array length, and Job event count. A smaller array can be valid. For integration issues, record the run ID, build number, Dataset ID, item count, key set, event counts, and redacted input. Never share tokens, proxy credentials, or private Dataset contents.

### Frequently asked questions

#### Does every run return all 26 top-level keys?

No. The formatter omits null, blank, empty-array, and empty-object values. The verified Apple company-only row contained 20 possible keys.

#### Is the employee count exact?

It is a parsed source snapshot, not an audited workforce total. Valid runs produced different counts, so preserve timestamps and corroborate important conclusions.

#### Are highlighted employees verified contacts or executives?

No. They are source-highlighted people. Inclusion does not confirm current role, authority, identity, relationship, or outreach suitability.

#### Why are jobs missing with a positive cap?

The cap is a request ceiling. Source availability, request failures, deduplication, parsing, or charge limits can produce fewer retained jobs.

#### Can a successful run have no row?

Yes. Successful process completion does not guarantee that a company name was parsed. Inspect the Dataset and status evidence.

#### Can I submit a personal profile or search by name?

No. This Actor accepts one LinkedIn company URL only.

### Related TrueFetch Actors

- [LinkedIn Person Profile](https://apify.com/truefetch/linkedin-person-profile?fpr=aiagentapi) handles one public member-profile URL under its own schema and source limits.
- [LinkedIn Job Listing](https://apify.com/truefetch/linkedin-job-listing?fpr=aiagentapi) focuses on LinkedIn vacancy discovery rather than company-profile snapshots.
- [Job Search](https://apify.com/truefetch/job-search?fpr=aiagentapi) provides a broader job-search workflow with independent inputs, fields, and pricing.

These Actors are separate products. Review each current input schema, output contract, pricing, and source boundary before combining results.

### Support and last updated

For a reproducible issue, send the run ID, public company URL, requested `max_jobs`, terminal status message, Dataset item count, observed top-level keys, and charged-event counts. Do not send an Apify token, proxy password, database credential, private Dataset, or unrelated personal information.

Use [TrueFetch support on Telegram](https://t.me/AiAgentApi) for Actor-specific help and the [Apify community](https://discord.com/invite/jyEM2PRvMU) for platform questions. State whether the problem concerns source access, an omitted field, a changed value, Job collection, event charging, or cloud execution.

Last updated: July 23, 2026.

# Actor input Schema

## `linkedin_url` (type: `string`):

One public LinkedIn company page URL in the supported /company/ path format

## `max_jobs` (type: `integer`):

Requested job-detail cap; use 0 to skip jobs. Source availability, parsing, and charge limits can return fewer.

## Actor input object example

```json
{
  "linkedin_url": "https://www.linkedin.com/company/apple/",
  "max_jobs": 10
}
```

# Actor output Schema

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

The looked-up company row. Optional keys are omitted when LinkedIn does not expose them, and a completed run can return zero rows.

# 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 = {
    "linkedin_url": "https://www.linkedin.com/company/apple/",
    "max_jobs": 0
};

// Run the Actor and wait for it to finish
const run = await client.actor("truefetch/linkedin-company-api").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 = {
    "linkedin_url": "https://www.linkedin.com/company/apple/",
    "max_jobs": 0,
}

# Run the Actor and wait for it to finish
run = client.actor("truefetch/linkedin-company-api").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 '{
  "linkedin_url": "https://www.linkedin.com/company/apple/",
  "max_jobs": 0
}' |
apify call truefetch/linkedin-company-api --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/zSJMwA6pZ817yodN3/builds/8AwTQe6JtWQUx5hci/openapi.json