# LinkedIn Company Scraper — Details, Search & Website Lookup (`inovaflow/linkedin-company-scraper`) Actor

Scrape LinkedIn company pages by URL, slug, website or company name, or search companies by keyword. One row per company: description, website, industry, size, headquarters, locations, founded, specialties, followers, affiliated and similar pages, recent posts. No login, no cookies.

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

## Pricing

from $1.00 / 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.

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

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

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

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

**LinkedIn company data as clean rows — by company page, website or name, or found by keyword search. No login, no cookies, $1 per 1,000 companies.**

If you build lead lists or keep a market map, LinkedIn's company pages are the best public source there is: the industry LinkedIn assigns, the size band, the headquarters and every office, the year founded, the specialties, follower and employee counts, the sister pages and the pages LinkedIn thinks are similar. Reading them one by one is slow, and the tools that read them for you usually want a logged-in account or charge four times what the page is worth.

We needed this for our own enrichment pipeline, so we built it to be boring and dependable: every company comes from LinkedIn's **public** page (what a logged-out visitor sees), read once through a rotating pool of proxy connections with nothing of yours involved. A website or a company name is looked up on Brave Search and confirmed on the LinkedIn page itself before it is delivered, so a wrong guess never lands in your data. Now we're sharing it.

### Who it's for

- **Sales and lead-gen teams** — *"Enrich these 500 domains from our CRM with industry, size, HQ and follower count."*
- **Market and competitive research** — *"Every fintech company in Berlin with 11–200 employees, as one table."*
- **Investors and analysts** — *"Founded after 2020, software, under 50 people — who are they?"*
- **Account-based marketing** — *"The sister pages and the look-alikes of our best customers."*
- **AI agents and pipelines** — *"Company facts for a list of names, as flat JSON, on a schedule."*

### What you can enter

| Input | Example | How it is read |
|---|---|---|
| **LinkedIn page URL** | `https://www.linkedin.com/company/apify/` (company, school or showcase) | Read directly |
| **Bare slug** | `microsoft` | Read directly; if no such page, treated as a name |
| **Website** | `stripe.com`, `www.deloitte.com` | The LinkedIn page whose website is that domain |
| **Company name** | `Deloitte`, `Czech Technical University in Prague` | The LinkedIn page named like that (exact name preferred) |
| **Keyword search** | `web scraping prague`, `"industrial automation"` | Every company page Brave Search lists for the query, read in full |

Mix them freely in one run. A company reached through several inputs is delivered once.

**Each row:** LinkedIn URL and numeric id, name, tagline, full description, website, industry, company size (LinkedIn band plus min/max), members on LinkedIn, headquarters (city, region, country code), every office address (street, city, region, postal code, country), company type, year founded, specialties, followers, logo and cover image, affiliated pages, similar companies, a sample of employees LinkedIn shows (name, headline, profile link), products, the number of posts on the page and when the newest was published, and optionally the latest posts themselves. Plus which input produced the row and how it was matched (`url`, `slug`, `website`, `name`, `search`).

### Filters

All filters apply to every row, whatever the input:

- **Industry contains** — words matched against LinkedIn's industry (`software`, `financial services`).
- **Company size** — LinkedIn's bands (`1-10` … `10001+`); **minimum / maximum employees** as numbers.
- **Headquarters or office location** — a country (`Germany`, `DE`) matches the country; any other text (`Prague`, `California`) is matched against the headquarters and office addresses.
- **Company type**, **minimum followers**, **founded after / before**.

Companies removed by a filter are never charged, so a search can cast wide and keep only what fits.

### How to set it up

1. Add companies (URLs, slugs, websites or names) and/or keyword searches.
2. Add filters if you want a narrower list; set the maximum companies per search query.
3. Run. Rows land in the dataset as each input finishes; the status message and the `OUTPUT` record list what every input returned and why anything could not be resolved or read.

### Pricing

Pay per result: **$0.001 per company** ($1 per 1,000), plus the platform's start fee ($0.005 per GB of memory, one unit at the default 512 MB). Pages that do not exist, inputs that cannot be resolved, duplicates and companies removed by your filters are never charged.

### Notes

- **No account, no cookies.** Everything comes from LinkedIn's public company pages.
- **Search is keyword-based.** Brave Search lists the company pages that match the words (up to ~20 per query, more with the quoted and "… company" variants). Only pages that really contain the query are delivered; the filters do the narrowing by place, size and industry.
- **Websites and names are confirmed on the page.** A website input is delivered only when the LinkedIn page lists that domain as its website; a name input only when the page's name matches (an exact match is preferred over a department or a subsidiary).
- **What a guest sees.** Phone numbers, the full employee list and funding data are not on the public page and are not guessed. The employee sample is the handful of people LinkedIn shows on the page.
- **Proxies.** Pages open through Apify's datacenter proxy; when an IP is rate-limited the request switches to the residential proxy by itself. Nothing to configure.

# Actor input Schema

## `companies` (type: `array`):

One per line, in any mix: a LinkedIn company, school or showcase URL (`https://www.linkedin.com/company/apify/`), a bare slug (`apify`), a website (`stripe.com`) or a company name (`Deloitte`). Websites and names are looked up on Brave Search and confirmed on the LinkedIn page itself (website match, else name match) — a wrong guess is never delivered.

## `searchQueries` (type: `array`):

Find company pages by what they are: `web scraping prague`, `fintech berlin`, `"industrial automation"`. Each query is searched on Brave Search (plus a quoted and a "… company" variant for more results) and every page found is read in full. Combine with the filters below.

## `maxCompaniesPerQuery` (type: `integer`):

Cap per keyword query. Brave Search lists about 20 company pages per query; the variants add more distinct ones.

## `industries` (type: `array`):

Keep only companies whose LinkedIn industry contains one of these words (`software`, `financial services`, `hospitals`). Case-insensitive.

## `companySizes` (type: `array`):

Keep only these LinkedIn size bands: `1-10`, `11-50`, `51-200`, `201-500`, `501-1000`, `1001-5000`, `5001-10000`, `10001+`.

## `locations` (type: `array`):

Keep only companies headquartered in, or with an office in, one of these places. A country name or code (`Germany`, `DE`, `United States`) matches the country; any other text (`Prague`, `California`) is matched against the headquarters and office addresses.

## `companyTypes` (type: `array`):

Keep only these types: `Privately Held`, `Public Company`, `Nonprofit`, `Partnership`, `Self-Employed`, `Sole Proprietorship`, `Government Agency`, `Educational`.

## `minFollowers` (type: `integer`):

Skip companies with fewer LinkedIn followers.

## `minEmployees` (type: `integer`):

Skip companies whose size band is entirely below this number (uses the members-on-LinkedIn count when the band is unknown).

## `maxEmployees` (type: `integer`):

Skip companies whose size band is entirely above this number.

## `foundedAfter` (type: `integer`):

Keep only companies founded in or after this year (companies without a founding year are skipped).

## `foundedBefore` (type: `integer`):

Keep only companies founded in or before this year.

## `includeRecentPosts` (type: `boolean`):

Add the latest posts shown on the page (link, time, first 500 characters, reactions, comments) as a `recentPosts` list. The post count and the newest post's time are always included.

## `maxConcurrency` (type: `integer`):

How many LinkedIn pages are read at the same time.

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

LinkedIn's public company pages open fine through Apify's datacenter proxy (the default). Whenever an IP is rate-limited the Actor switches that request to the residential proxy by itself, so there is normally nothing to change here.

## Actor input object example

```json
{
  "companies": [
    "https://www.linkedin.com/company/apify/",
    "microsoft",
    "stripe.com"
  ],
  "searchQueries": [],
  "maxCompaniesPerQuery": 20,
  "industries": [],
  "companySizes": [],
  "locations": [],
  "companyTypes": [],
  "minFollowers": 0,
  "includeRecentPosts": false,
  "maxConcurrency": 5,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `companies` (type: `string`):

One row per company: name, tagline, description, website, industry, size, headquarters, locations, type, founded, specialties, followers, affiliated and similar pages, employee sample, products, latest-post activity.

## `summary` (type: `string`):

Companies delivered and charged, the per-input report (what could not be resolved or read and why), filters applied, search and proxy statistics.

# 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 = {
    "companies": [
        "https://www.linkedin.com/company/apify/",
        "microsoft",
        "stripe.com"
    ],
    "searchQueries": [],
    "maxCompaniesPerQuery": 20,
    "industries": [],
    "companySizes": [],
    "locations": [],
    "companyTypes": [],
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("inovaflow/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 = {
    "companies": [
        "https://www.linkedin.com/company/apify/",
        "microsoft",
        "stripe.com",
    ],
    "searchQueries": [],
    "maxCompaniesPerQuery": 20,
    "industries": [],
    "companySizes": [],
    "locations": [],
    "companyTypes": [],
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("inovaflow/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 '{
  "companies": [
    "https://www.linkedin.com/company/apify/",
    "microsoft",
    "stripe.com"
  ],
  "searchQueries": [],
  "maxCompaniesPerQuery": 20,
  "industries": [],
  "companySizes": [],
  "locations": [],
  "companyTypes": [],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call inovaflow/linkedin-company-scraper --silent --output-dataset

```

## MCP server setup

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