# LinkedIn Company Scraper (`cyprusapi/linkedin-company`) Actor

Scrapes public LinkedIn company pages anonymously (no cookies, no login): typed employee count and size range, followers, headquarters, locations, specialties, affiliated and similar companies — with per-field coverage and a SHA-256 provenance block. Error items are never charged.

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

## Pricing

from $3.00 / 1,000 company scrapeds

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/actors/running/actors-in-store.md#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

### What does LinkedIn Company Scraper do?

LinkedIn Company Scraper extracts **full, typed company-profile data** from public [LinkedIn](https://www.linkedin.com) company pages (`linkedin.com/company/<slug>`) — **anonymously, with no cookies and no LinkedIn account**. You get the company name, tagline, description, website, industry, company type, **typed company-size range (min/max)**, the **live employee count on LinkedIn as a number**, follower count, structured **headquarters** (city, region, country code, postal code, street), founding year, specialties, the full **locations list**, **affiliated pages**, **similar companies**, and logo/cover images — plus a **per-field coverage status** and an **audit-proof provenance block** (URL, HTTP status, SHA-256 of the page) on every single item. Whether you need **competitor intelligence**, **lead-list enrichment**, or **market mapping**, you get clean, analysis-ready JSON that never invents a value.

The actor runs on the Apify platform, so you get **API access, scheduling, integrations, proxy rotation, and run monitoring** out of the box — no infrastructure to manage. Pricing is **pay per company** at **$3 per 1,000 companies**, and **errors are never charged**. Try it on the Apify free tier in a couple of clicks.

### What makes this LinkedIn company scraper different?

Most LinkedIn company scrapers hand you a flat blob of fields with no way to tell a real value from a silent gap. This one was built for data you can defend — in a CRM import, a market report, or a pricing model.

| Capability | LinkedIn Company Scraper | [harvestapi/linkedin-company](https://apify.com/harvestapi/linkedin-company) | [apimaestro/linkedin-company-detail](https://apify.com/apimaestro/linkedin-company-detail) |
|---|---|---|---|
| **Price per 1,000 companies** | **$3.00** | $4.00 | $5.00 |
| **No cookies / no account** | ✅ | ✅ | ✅ |
| **Employee count as typed number** | ✅ | ✅ | ✅ |
| **Typed size range** (`min`/`max`) | ✅ | ⚠️ start only | ❌ |
| **Affiliated pages** (incl. showcase pages) | ✅ | ❌ | ❌ |
| **Similar companies** | ✅ | ❌ | ❌ |
| **Structured headquarters** (city/region/country code/street) | ✅ | ⚠️ inside locations list | ⚠️ partial |
| **Provenance block** (URL, HTTP status, SHA-256 page hash) | ✅ on every item | ❌ | ❌ |
| **Per-field coverage status** (`obtained`/`absent`) | ✅ on every item | ❌ silent nulls | ❌ silent nulls |
| **Error items never charged** (invalid URL, 404, blocked) | ✅, pushed for transparency | not documented | not documented |
| Store rating | — (new) | 4.69 | 3.16 |

Users per 30 days at research time (Apify Store API, August 2026): harvestapi/linkedin-company ~3,270, [harvestapi/linkedin-company-search](https://apify.com/harvestapi/linkedin-company-search) ~1,449, apimaestro/linkedin-company-detail ~497.

#### Honest data: `obtained` vs `absent`

When LinkedIn does not show a founding year on Microsoft's page, this actor reports `founded: null` with `coverage.founded: "absent"` — it does not guess, backfill, or silently drop the field. Small companies get the same discipline: if a page carries no affiliated-pages section, you get `affiliatedPages: null` and `coverage.affiliated_pages: "absent"`, so your pipeline can tell *"not there"* from *"not scraped"*.

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

The actor uses **pay-per-event** pricing — you pay only for delivered results (exact prices are always shown on the actor's **Pricing** tab in Apify Console):

- **`company`** — **$0.003 per company** ($3 per 1,000), charged once per successfully scraped company item. Includes all fields: locations, affiliated pages, similar companies, coverage, and provenance.
- **`apify-actor-start`** — a one-time **$0.01 per run**.

**Errors are never charged.** Invalid URLs, non-existent companies (404), blocked requests, and transport failures produce transparency items in the dataset at zero cost.

#### Cost by volume (company event only, + $0.01 per run)

| Companies per run | Total price |
|---|---|
| 100 companies | **$0.31** |
| 1,000 companies | **$3.01** |
| 10,000 companies | **$30.01** |

The Apify **free tier** is enough to try the actor on a handful of companies before you scale up.

### Who is this LinkedIn scraper for?

| Audience | What they use it for |
|---|---|
| **Sales & RevOps teams** | Enrich account lists with employee count, size range, industry, HQ, and website — typed and CRM-ready. |
| **Competitive intelligence** | Track competitors' follower counts, locations, and affiliated pages on a schedule; the provenance hash proves what the page showed and when. |
| **VC / market research** | Map markets via `similarCompanies`, size companies by typed ranges, and spot growth signals in employee counts. |
| **AI / data teams** | Clean, typed, provenance-stamped company JSON for agents and RAG pipelines — with honest `null` semantics instead of hallucinated gaps. |

### How to scrape LinkedIn company pages with LinkedIn Company Scraper

1. Open the actor in [Apify Store](https://apify.com/store) and click **Try for free**.
2. On the **Input** tab, paste **company URLs** (`https://www.linkedin.com/company/microsoft`) and/or plain **slugs** (`"microsoft"`).
3. Optionally set **Max companies** and the **proxy country** (defaults: 10 companies, US exits).
4. Click **Start**, then download your results from the **Output** or **Storage** tab — or pull them via the Apify API.

#### Using the Apify API (JavaScript)

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

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

const run = await client.actor('CyprusAPI/linkedin-company').call({
    companySlugs: ['apify', 'microsoft'],
    maxCompanies: 10,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### Using the Apify API (Python)

```python
from apify_client import ApifyClient

client = ApifyClient('<YOUR_APIFY_TOKEN>')

run = client.actor('CyprusAPI/linkedin-company').call(run_input={
    'companyUrls': [{'url': 'https://www.linkedin.com/company/apify'}],
    'companySlugs': ['microsoft'],
    'maxCompanies': 10,
})

for item in client.dataset(run['defaultDatasetId']).iterate_items():
    print(item)
```

### Input

The actor accepts the following parameters (see the **Input** tab for the full form). At least one of `companyUrls` or `companySlugs` is required.

| Field | Type | Description |
|---|---|---|
| `companyUrls` | array | LinkedIn company page URLs; the slug is extracted from each URL. Provide `companyUrls` and/or `companySlugs`. |
| `companySlugs` | array | LinkedIn company slugs (the part after `/company/`, e.g. `"microsoft"`). Combined with URLs and deduplicated. |
| `maxCompanies` | integer | Global cap on companies per run across both inputs. Default `10`, min `1`, max `1000`. |
| `country` | string | ISO alpha-2 proxy exit country (e.g. `"US"`, `"DE"`, `"GB"`). Default `"US"`. |
| `proxyConfiguration` | object | Optional Apify proxy settings as extra fallback tiers behind the bundled residential pool. |
| `proxiesByCountry` | object | Optional geo-pinned custom proxies per country, e.g. `{"US": ["http://user:pass@host:port"]}` — always tried first. |

### Output

One dataset item per scraped company. Flat overview fields (name, industry, employee count, followers, website) sit next to nested groups: `companySize` (typed min/max range), `headquarters` (city/region/country code/postal code/street), `locations`, `affiliatedPages`, `similarCompanies`, plus `coverage` and `capture`. You can download the dataset in various formats such as JSON, HTML, CSV, or Excel.

```json
{
  "name": "Apify",
  "universalName": "apify",
  "pageUrl": "https://www.linkedin.com/company/apify",
  "tagline": "Thousands of Actors to automate your business, get real-time web data, and integrate your apps and agents.",
  "website": "https://apify.com/",
  "industry": "Technology, Information and Internet",
  "companyType": "Privately Held",
  "companySize": { "min": 201, "max": 500, "raw": "201-500 employees" },
  "employeeCount": 256,
  "followerCount": 31896,
  "headquarters": {
    "city": "Prague",
    "region": null,
    "countryCode": "CZ",
    "postalCode": "11100",
    "streetAddress": "Vodickova 704/36",
    "raw": "Prague"
  },
  "founded": 2016,
  "specialties": ["Web scraping", "Browser automation", "AI agents", "API integration"],
  "locations": [
    { "line1": "Vodickova 704/36", "location": "Prague, 11100, CZ", "addressLines": ["Vodickova 704/36", "Prague, 11100, CZ"], "isPrimary": true },
    { "line1": "San Francisco, CA, US", "location": null, "addressLines": ["San Francisco, CA, US"], "isPrimary": false }
  ],
  "affiliatedPages": null,
  "similarCompanies": [
    { "name": "n8n", "subtitle": "Software Development", "url": "https://www.linkedin.com/company/n8n", "pageType": "company", "slug": "n8n", "logoUrl": "https://media.licdn.com/..." }
  ],
  "logoUrl": "https://media.licdn.com/dms/image/v2/.../apify_logo?...",
  "coverImageUrl": "https://media.licdn.com/dms/image/v2/.../apify_cover?...",
  "coverage": { "profile": "obtained", "founded": "obtained", "affiliated_pages": "absent" },
  "capture": {
    "captured_at_utc": "2026-08-20T17:25:00+00:00",
    "url": "https://www.linkedin.com/company/apify",
    "http_status": 200,
    "was_authenticated": false,
    "content_hash": "sha256:75c5add5..."
  },
  "scrapedAt": "2026-08-20T17:25:02+00:00"
}
```

Fields follow a **two-state discipline**: a value means *observed on the page*, `null` means *verifiably absent* — the `coverage` block reports this per field group. Failed companies appear as transparency items with `error` and `errorDescription` and are **never charged**.

### Data table

| Field | Description |
|---|---|
| `name`, `universalName`, `pageUrl` | Company name, LinkedIn slug, canonical page URL |
| `tagline`, `description` | Slogan and the full "About us" text |
| `website` | Company website, decoded from LinkedIn's redirect wrapper |
| `industry`, `companyType` | Industry label and legal type (e.g. "Privately Held", "Public Company") |
| `companySize` | LinkedIn's size bucket, typed: `min`, `max` (`null` for open-ended "10,001+"), plus the `raw` label |
| `employeeCount` | Members on LinkedIn, as a **number** (not a string) |
| `followerCount` | Page followers at capture time, as a number |
| `headquarters` | Structured HQ: `city`, `region`, `countryCode`, `postalCode`, `streetAddress`, plus the `raw` label |
| `founded` | Founding year as a number — `null` when LinkedIn doesn't show one |
| `specialties` | List of specialties |
| `locations` | All rendered office locations: address lines, `isPrimary` flag for the HQ entry |
| `affiliatedPages` | Affiliated LinkedIn pages (incl. showcase pages): name, subtitle, canonical URL, `pageType`, logo |
| `similarCompanies` | "Similar pages" recommendations in the same shape |
| `logoUrl`, `coverImageUrl` | LinkedIn CDN image URLs |
| `coverage` | Per-field-group status: `obtained` / `absent` |
| `capture` | Provenance: timestamp, URL, HTTP status, `was_authenticated: false`, SHA-256 content hash |

### Known limitations

We'd rather you know these up front:

- **Public pages only — some LinkedIn data is login-gated and is not included.** Funding rounds (Crunchbase data), phone numbers, employee insights (growth trends, headcount by function), and verification badges are not visible anonymously; this actor does not pretend otherwise and does not charge for them. Fields like this are not silently nulled — they are simply not part of the output.
- **No posts in v1.** Recent company posts are a separate job — use a dedicated LinkedIn posts scraper instead of bolting a half-solution onto company profiles.
- **`employeeCount` is the LinkedIn member count, not payroll headcount.** It counts profiles that list the company as their employer — typically lower than the real workforce for companies with many non-desk employees, and it lags hires/layoffs.
- **Followers and employee counts are snapshots.** They move daily; schedule recurring runs if you need a time series — the `capture.captured_at_utc` timestamp makes that audit-proof.
- **Logo/cover URLs live on LinkedIn's CDN** and carry expiry parameters; download and re-host images you need long-term.
- **One proxy country per run.** Split multi-country jobs into separate runs.
- **LinkedIn changes its guest-page markup from time to time.** When that happens, affected fields degrade to honest `absent` coverage rather than wrong values — open an issue and we'll adapt the parser.

### Tips and advanced options

- **Use `maxCompanies`** to cap run size and cost — it applies across both URL and slug inputs after deduplication.
- **Batch inputs.** One run with 100 slugs is far cheaper per company than 100 runs with one slug (one `actor-start` charge total).
- **Proxy fallback chain.** Each company is attempted in tiers: your `proxiesByCountry` pool first, then the bundled residential pool, then (if enabled) Apify datacenter and Apify residential. Retries only happen on bot-detection/transport failures — a 404 is final and free.
- **Schedule it.** For competitor tracking, schedule daily or weekly runs; every item's `capture` block (timestamp + SHA-256) doubles as evidence of what the page showed at that moment.

### FAQ

#### Will LinkedIn block me? Do I need proxies?

LinkedIn rate-limits anonymous traffic harder than most sites, which is why this actor ships with a **bundled residential proxy pool** and a tiered fallback chain (your proxies → bundled pool → Apify datacenter → Apify residential). Blocked requests surface as transparency items with `error` / `errorDescription` and are **never charged**.

#### Can I bring my own proxies?

Yes. Pin **geo-located proxies per country** with `proxiesByCountry` (e.g. US exits for `country: "US"`) — your pool is always tried first, ahead of the bundled one.

#### Why did some fields come back as `null`?

That is the honest-data design, not a bug: `null` means the field is verifiably absent on the page (e.g. Microsoft shows no founding year). The `coverage` block tells you which case applies per field group — no invented values.

#### Is scraping LinkedIn company data legal?

Web scraping is legal when you extract **publicly available data** that is not behind a login. This actor scrapes only anonymous, public company pages (`was_authenticated` is always `false` in the provenance block) — no cookies, no account, no CAPTCHA bypass. Company profiles can still reference personal data (e.g. employee counts); personal data is protected by regulations such as GDPR in the EU — you should have a legitimate reason to process it. If you are unsure, consult a lawyer. Also review LinkedIn's Terms of Service before scraping. Apify is not liable for how you use the extracted data.

#### Something isn't working — where do I report it?

Open the **Issues** tab on the actor's page in Apify Console and describe the problem, ideally with the failing company URL and run ID. Error items in the dataset (`error` / `errorDescription`) already tell you what went wrong for individual companies.

#### Can you build a custom LinkedIn data solution?

Yes — if you need different fields, monitoring setups, or a fully managed pipeline, reach out via the Issues tab and ask about a custom solution.

# Actor input Schema

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

LinkedIn company page URLs (https://www.linkedin.com/company/<slug>). The slug is extracted from each URL. Provide `companyUrls` and/or `companySlugs`.

## `companySlugs` (type: `array`):

LinkedIn company slugs (the part after /company/, e.g. "microsoft"). Combined with `companyUrls`, deduplicated.

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

Global cap on companies scraped per run, across both URL and slug inputs. Default 10.

## `country` (type: `string`):

ISO alpha-2 country code for the proxy exit (e.g. "US", "DE", "GB"). Picks the geo-pinned pool and the Apify proxy country. Default "US".

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

Optional Apify proxy settings. The bundled residential pool is used first; enable Apify proxies as extra fallback tiers if your plan allows. Datacenter proxies are often enough for LinkedIn company pages.

## `proxiesByCountry` (type: `object`):

Optional geo-pinned custom proxies per country, e.g. {"US": \["http://user:pass@host:port"]}. Tried first, ahead of the bundled pool and the Apify tiers. The `country` input selects which list is used.

## Actor input object example

```json
{
  "companyUrls": [
    {
      "url": "https://www.linkedin.com/company/apify"
    }
  ],
  "companySlugs": [
    "microsoft"
  ],
  "maxCompanies": 10,
  "country": "US",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `dataset` (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": [
        {
            "url": "https://www.linkedin.com/company/apify"
        }
    ],
    "companySlugs": [
        "microsoft"
    ],
    "country": "US"
};

// Run the Actor and wait for it to finish
const run = await client.actor("cyprusapi/linkedin-company").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": [{ "url": "https://www.linkedin.com/company/apify" }],
    "companySlugs": ["microsoft"],
    "country": "US",
}

# Run the Actor and wait for it to finish
run = client.actor("cyprusapi/linkedin-company").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": [
    {
      "url": "https://www.linkedin.com/company/apify"
    }
  ],
  "companySlugs": [
    "microsoft"
  ],
  "country": "US"
}' |
apify call cyprusapi/linkedin-company --silent --output-dataset

```

## MCP server setup

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

```

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/zIjrCvM6lSTeAdhpS/builds/35JeSxzTbkjKY5htS/openapi.json