# LinkedIn Company Scraper - Profiles, Websites & Size (`benthepythondev/linkedin-company-scraper`) Actor

Extract public LinkedIn company profiles with strict URL and company ID matching, industry, website, employee range and follower counts. No login or API key.

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

## Pricing

from $3.20 / 1,000 companies

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?

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

## LinkedIn Company Scraper

Get public company profiles from exact LinkedIn company URLs. Each result identifies the requested company before exporting its description, industry, website and audience metrics. Export to JSON, CSV or Excel, run on a schedule, call via API, or connect to Make, Zapier or n8n.

**Enrich a known company list:** use exact LinkedIn `/company/` URLs; search by company name and personal `/in/` profiles are outside this Actor. Free-plan result events cost **$4 per 1,000 companies**, plus the start event. Missing public fields remain null.

### Quick start

Start with a tested example for verified company snapshots:

- [Microsoft and GitHub company profiles with verified URLs](https://apify.com/benthepythondev/linkedin-company-scraper/examples/verified-microsoft-github-company-profiles)

Open the example and choose **Try for free** to copy its input into your account. Check the input and set a maximum run charge before starting; Actor fees still follow the pricing below. When the run finishes, open the run's dataset and select the **Overview** view and download JSON for nested fields or CSV/Excel for a table.

| Your goal | Input to use |
|---|---|
| Enrich a known employer list | Supply exact `/company/` URLs |
| Compare later observations | Join by `company_id`, retaining `scraped_at` |

The [real output example](#example-output) shows the record shape. The [Python workflow](#python-api-workflow) saves your own export to a local JSON file with a $0.05 maximum Actor charge.

### What does this scraper extract?

The Actor reads the public company page directly, without a LinkedIn login, personal session cookies or another provider's API key. It checks the page's canonical URL, primary Organization record and company ID before returning a row. Related companies and organizations mentioned in posts are not accepted as the target.

The export contains company information that LinkedIn makes available to logged-out visitors. Public visibility varies. Missing optional fields remain null; the Actor does not guess an address, website or employee count. Company names and descriptions come from the source without rewriting or truncating the text.

Use this for company research, keeping a business directory current, enriching an existing list of company URLs, and comparing public company snapshots over time. It works well alongside a job feed when you already know which employer you want to research.

### Input

| Input | Default | Behavior |
|---|---|---|
| `companyUrls` | \["https://www.linkedin.com/company/microsoft/"] | Exact public /company/ URLs. Names, personal profiles and fuzzy searches are rejected. Numeric company URLs are checked against the primary company ID. |
| `maxResults` | 10 | Maximum distinct verified companies to export. |
| `proxyConfiguration` | {"useApifyProxy": false} | Optional caller-selected proxy; direct requests are the default. |

#### Example input

```json
{
  "companyUrls": [
    "https://www.linkedin.com/company/microsoft/",
    "https://www.linkedin.com/company/github/"
  ],
  "maxResults": 2
}
```

Paste company URLs into `companyUrls`, choose a small result limit, and run. Canonical duplicates are removed before fetching. Numeric redirect URLs are rejected; use the named public company URL. A country-specific LinkedIn hostname is normalized to the public www hostname. Tracking query parameters do not create another company.

Names such as `Microsoft`, external websites, personal `/in/` profiles, company search pages and `/posts/` URLs are rejected. The Actor never turns these into a fuzzy company search. Supply a company's main `/company/<slug>/` URL. A renamed slug that redirects to a different canonical company slug fails the identity check; update the input to the current canonical URL after checking it.

### Example output

One complete record from a verified September 9, 2026 cloud run. Values and public media URLs can change or expire; this is a dated sample.

```json
{
  "company_id": "1418841",
  "name": "GitHub",
  "url": "https://www.linkedin.com/company/github",
  "requested_url": "https://www.linkedin.com/company/github",
  "description": "As the global home for all developers, GitHub is the complete AI-powered developer platform to build, scale, and deliver secure software. Over 100 million people, including developers from 90 of the Fortune 100 companies, use GitHub to build amazing things together across 330+ million repositories. With all the collaborative features of GitHub, it has never been easier for individuals and teams to write faster, better code.\n",
  "industry": "Software Development",
  "website": "https://github.com",
  "headquarters": "San Francisco, CA",
  "address": {
    "type": "PostalAddress",
    "streetAddress": "88 Colin P Kelly Jr St",
    "addressLocality": "San Francisco",
    "addressRegion": "CA",
    "postalCode": "94107",
    "addressCountry": "US"
  },
  "company_size": "501-1,000 employees",
  "linkedin_employee_count": 6864,
  "followers": 6610616,
  "company_type": "Privately Held",
  "founded": "2008",
  "specialties": null,
  "logo_url": "https://media.licdn.com/dms/image/v2/D560BAQGxQRyEwD643g/company-logo_200_200/B56Z3045ErGgAI-/0/1777930048179/github_logo?e=2147483647&v=beta&t=VOSw99XrRMs2tz1Eqlkfz0kOuUlusjpBLk46CxqfeUI",
  "identity_verified": true,
  "scraped_at": "2026-09-09T19:39:11.312796+00:00"
}
```

All output fields:

| Field | Meaning |
|---|---|
| `company_id`, `name`, `url` | Primary organization ID, displayed company name and canonical source URL. |
| `requested_url`, `identity_verified` | Normalized requested URL and a true value after the identity checks pass. |
| `description` | Full company description from the public Organization record. |
| `industry`, `website` | Public industry label and source-published website URL. |
| `headquarters`, `address` | Headquarters text and structured source address, when present. |
| `company_size` | LinkedIn's displayed company-size range, kept as text. |
| `linkedin_employee_count` | Count of LinkedIn-associated members in the source record, not independently verified workforce size. |
| `followers` | Public follower count when an exact number is available. |
| `company_type`, `founded`, `specialties` | Optional public company attributes; specialties remain source text. |
| `logo_url`, `scraped_at` | Source logo URL and UTC extraction timestamp. |

Company-size ranges and associated-member counts can disagree. They describe different source metrics and are deliberately separate columns. An address may describe a headquarters rather than every operating location. A website is a link published on LinkedIn; this Actor does not crawl that website or verify its ownership independently.

The default dataset provides the rows, including an `overview` table. The `SUMMARY` record in the run's key-value store records requested and unique URLs, exported companies and the stop reason. The Output tab links to both. Source or storage failures mark the run failed; inspect any partial dataset and `SUMMARY.failed_url` before retrying a batch. Successfully written rows remain available.

### Pricing and limits

On the Free plan, each exported company costs **$0.004**, equivalent to **$4 per 1,000 companies**, plus a **$0.00005 start event** at the default 512 MB. Bronze is $3.60/1,000, Silver $3.40, and Gold, Platinum and Diamond are $3.20/1,000 at the currently saved rates. The start event is $0.000045 on Bronze, $0.000040 on Silver, and $0.000035 on Gold, Platinum and Diamond. The Store pricing panel is authoritative.

A two-company Free-tier export at default memory is $0.00805 in Actor events. No email/contact add-on or third-party scraping subscription is required. An optional proxy can affect run costs; inspect the run usage and current Apify pricing. Use the maximum charge control as an additional budget bound. A spending cap can return fewer companies than requested.

Input is limited to 100 URLs per run and the default maximum output is ten companies. Requests run sequentially with bounded retries. Large batches or slow proxy routes may need a longer run timeout; splitting a list into small batches makes failed URLs easier to retry.

### Python API workflow

Copy the first input JSON above into `input.json` and save this code as `export.py`. In a Python virtual environment, install `apify-client` with `python -m pip install apify-client`. Set `APIFY_TOKEN` to your own Apify token in your environment, then run `python export.py`. Keep the token out of source files and shared screenshots.

```python
import json
import os
from decimal import Decimal
from pathlib import Path

from apify_client import ApifyClient

client = ApifyClient(os.environ["APIFY_TOKEN"])
run = client.actor("benthepythondev/linkedin-company-scraper").call(
    run_input=json.loads(Path("input.json").read_text(encoding="utf-8")),
    max_total_charge_usd=Decimal("0.05"),
    memory_mbytes=512,
    timeout_secs=300,
)
if not run or run["status"] != "SUCCEEDED":
    raise RuntimeError(f"Inspect the run before retrying: {run and run['id']}")

rows = list(client.dataset(run["defaultDatasetId"]).iterate_items())
Path("linkedin-companies.json").write_text(
    json.dumps(rows, ensure_ascii=False, indent=2), encoding="utf-8"
)
print(f"Saved {len(rows)} records from run {run['id']}")
```

This starts a run in your account, waits for completion and saves `linkedin-companies.json`. The $0.05 limit bounds Actor charges; it is not a promised bill or result count. Check the printed run ID and server log if the result is shorter than expected. If your client loses its connection, inspect the existing run in Console before starting another one. See the [official Python client](https://docs.apify.com/api/client/python/) for other run options.

Use `company_id` for directory upserts, or keep ID plus `scraped_at` for history. Store `company_size`, `linkedin_employee_count` and `followers` separately: a reported size range, associated LinkedIn members and audience size measure different things. No employee list is included.

For recurring runs without writing a scheduler, copy a tested public Task into your account and attach an Apify Schedule to that copy. Keep its maximum-charge limit and avoid overlapping runs when using monitor state. The Python example above is also suitable for an existing scheduler; run it from the directory containing `input.json` and provide the token through that scheduler's secret settings.

### FAQ

**Does this search for companies by name?** No. It verifies exact company URLs. This avoids silently returning a similarly named organization.

**Can I scrape people or a company's employee list?** No. The output describes the company. It does not enumerate employees, personal profiles or private information.

**Does it need a LinkedIn account?** No account is supplied to this Actor. A page that requires authentication or remains blocked cannot be exported through this public route.

**Does a successful identity check verify every company claim?** No. It verifies that the extracted source identity matches your input. LinkedIn's public fields may still be incomplete, outdated or self-reported.

**Are emails and phone numbers included?** This Actor has no invented contact discovery. It exports the company fields documented above. Use the published website with a separate contact extractor if your workflow needs public business contacts.

**Why did a URL fail?** Check that it is a main company URL and still publicly available. Blocked pages, mismatched identities and missing primary organization records fail clearly instead of becoming an empty successful export.

**Can I schedule this?** Yes. Use an Apify Task and schedule, then compare rows by `company_id` in your own database. This Actor exports current snapshots; it does not maintain a company-change history itself.

**Can I export to a spreadsheet or API?** Yes. The dataset supports JSON, CSV and Excel, and Apify exposes the dataset through its API. Nested `address` data is easiest to preserve in JSON.

**How should I use the data?** Follow applicable law, platform terms and your organization's data rules. Public availability does not grant unrestricted permission for every downstream use.

### Related Actors

[LinkedIn Jobs](https://apify.com/benthepythondev/linkedin-jobs-scraper) returns public job postings with descriptions and only-new monitoring. [Facebook Pages](https://apify.com/benthepythondev/facebook-pages-scraper) extracts public organizational Page information and published contacts. [Website Contact Extractor](https://apify.com/benthepythondev/website-contact-extractor) reads contact details from business websites.

**Keywords:** LinkedIn company scraper, company URLs, company profile data, business research, company industry, headquarters, company size, employee count, LinkedIn followers, company website, B2B data, organization ID, company enrichment, JSON export, CSV export, scheduled company data.

# Actor input Schema

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

Exact public /company/ URLs. Names, personal profiles and fuzzy searches are rejected. Use named company URLs; numeric redirect URLs are rejected.

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

Maximum distinct verified companies to export.

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

Optional caller-selected proxy; direct requests are the default.

## Actor input object example

```json
{
  "companyUrls": [
    "https://www.linkedin.com/company/microsoft/"
  ],
  "maxResults": 10,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `results` (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/microsoft/"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("benthepythondev/linkedin-company-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/microsoft/"] }

# Run the Actor and wait for it to finish
run = client.actor("benthepythondev/linkedin-company-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/microsoft/"
  ]
}' |
apify call benthepythondev/linkedin-company-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,benthepythondev/linkedin-company-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/8Hdu2c2C2Ins46uct/builds/gZLzYTYJA0eLX5abI/openapi.json