# LinkedIn Company Search Scraper (`automation-lab/linkedin-company-search-scraper`) Actor

Find public LinkedIn company pages by keyword or search URL and export identity, industry, location, size, logo, follower count, and summary.

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

## Pricing

Pay per event

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 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 Search Scraper

Discover public LinkedIn company pages by keyword or a LinkedIn company search URL and export clean company records.

This LinkedIn company search Actor returns company identity, profile URL, industry, headquarters, employee-size text, follower count, logo, website, and public summary.
It is designed for recurring market mapping, account research, CRM preparation, and company-list exports.

No LinkedIn account or cookie is required.
The Actor uses public web discovery and public company profile data.

### What can LinkedIn Company Search Scraper do?

- Search for companies with one or more keyword queries.
- Accept a public LinkedIn `/search/results/companies/` URL containing keywords.
- Verify readable industry, location, and company-size filters against public company pages.
- Normalize every result to a canonical LinkedIn company URL.
- Deduplicate companies found by multiple queries.
- Export structured records to JSON, CSV, Excel, XML, or RSS through Apify datasets.
- Run on a schedule for repeatable market snapshots.
- Connect results to Make, Zapier, n8n, webhooks, or your own API client.

The Actor does not log in to LinkedIn and does not scrape private or member-only data.

### Who is this Actor for?

**Sales and account-based marketing teams** can build company lists around a segment, market, or product category.

**Market researchers** can map companies across industries and compare scheduled dataset exports.

**Recruiting teams** can identify employers in a location or employee-size range before researching open roles.

**Investors and analysts** can collect public company identity and firmographic context for screening.

**Data teams** can feed canonical company URLs into enrichment, matching, or warehouse pipelines.

### Why use this company search Actor?

LinkedIn's normal company search is designed for interactive browsing.
This Actor turns public company discovery into repeatable dataset rows.

Important differences:

- No user cookies or LinkedIn credentials.
- Filters are applied to extracted public company fields, not merely added to a search phrase.
- Every saved row includes provenance: source query, source search URL, result page, and rank.
- Invalid opaque LinkedIn filter IDs fail with an actionable message instead of producing misleading matches.
- Only verified company pages are charged and saved.

Coverage follows publicly indexed pages and can differ from LinkedIn's logged-in search results.

### What data does it extract?

| Field | Meaning |
| --- | --- |
| `companyId` | Public organization identifier when available, otherwise the company slug |
| `universalName` | Stable slug from the LinkedIn company URL |
| `name` | Public company name |
| `linkedinUrl` | Canonical LinkedIn company profile URL |
| `industry` | Industry shown on the public company page |
| `location` | Public headquarters or primary location |
| `companySize` | Public LinkedIn employee-size range |
| `followerCount` | Public follower count when available |
| `summary` | Public company description or discovery summary |
| `logo` | Public company logo URL |
| `website` | Public company website when available |
| `sourceQuery` | Query that discovered the company |
| `sourceSearchUrl` | Original LinkedIn search URL, or `null` for direct queries |
| `searchResultRank` | Approximate rank in public discovery results |
| `searchPage` | Public discovery page number |
| `scrapedAt` | ISO 8601 extraction timestamp |

LinkedIn does not expose every field for every company.
Nullable values are normal and remain `null` rather than being guessed.

### How to get started

1. Open the Actor input page.
2. Add at least one search query, such as `software companies`.
3. Optionally add readable industries, locations, or company-size bands.
4. Set the maximum number of companies.
5. Run the Actor.
6. Open the **Companies** dataset view.
7. Export the rows or connect the dataset to your workflow.

A useful first input is:

```json
{
  "searchQueries": ["software companies"],
  "maxItems": 10,
  "maxPagesPerQuery": 2
}
```

### Input parameters

#### `searchQueries`

An array of plain-language company searches.
Examples include:

- `workflow software`
- `renewable energy`
- `developer tools`
- `cybersecurity companies london`

Up to 20 queries can be supplied in one run.

#### `searchUrls`

An array of public LinkedIn company search URLs.
Each URL must use the company-search path and contain a `keywords` parameter.

Supported example:

```text
https://www.linkedin.com/search/results/companies/?keywords=renewable%20energy
```

LinkedIn URLs containing opaque location or industry IDs are rejected.
Use the readable `locations` and `industries` fields so the Actor can verify each result.

#### `industries`

Optional readable industry values, such as `Software Development`.
A row is saved only if its extracted public industry matches at least one supplied value.

#### `locations`

Optional readable headquarters values, such as `London`, `New York`, or `California`.
A row is saved only if its extracted public location matches at least one supplied value.

#### `companySizes`

Optional LinkedIn employee-size text.
Supported values are:

- `1 employee`
- `2-10 employees`
- `11-50 employees`
- `51-200 employees`
- `201-500 employees`
- `501-1,000 employees`
- `1,001-5,000 employees`
- `5,001-10,000 employees`
- `10,001+ employees`

#### `maxItems`

Maximum matching companies saved across all searches.
The allowed range is 1 to 1,000.

#### `maxPagesPerQuery`

Maximum public discovery pages inspected for each query.
The allowed range is 1 to 20.
Raise it when strict filters reject many candidates.

### Real output example

The following abridged record is based on a local run for a renewable energy LinkedIn search URL; the summary and expiring logo query string are shortened for readability:

```json
{
  "companyId": "atlasrenewableenergy",
  "universalName": "atlasrenewableenergy",
  "name": "Atlas Renewable Energy",
  "linkedinUrl": "https://www.linkedin.com/company/atlasrenewableenergy/",
  "industry": "Renewable Energy Power Generation",
  "location": "Miami, FL",
  "companySize": "201-500 employees",
  "followerCount": 114665,
  "summary": "Atlas Renewable Energy delivers clean energy at scale. We help our partners accelerate their energy transitions and accomplish their sustainability goals.",
  "logo": "https://media.licdn.com/dms/image/v2/D4E0BAQEfmg6XLugh8A/company-logo_200_200/company-logo_200_200/0/1664470890340/atlasrenewableenergy_logo",
  "website": "http://www.AtlasRenewableEnergy.com",
  "sourceQuery": "renewable energy",
  "sourceSearchUrl": "https://www.linkedin.com/search/results/companies/?keywords=renewable%20energy",
  "searchResultRank": 1,
  "searchPage": 1,
  "scrapedAt": "2026-08-02T03:07:15.092Z"
}
```

Counts, descriptions, image URLs, and other public fields can change over time.

### How much does it cost to find LinkedIn companies?

The Actor uses pay-per-event pricing:

- **$0.001** once when a run starts.
- One `item` event for each matching company saved.
- No item charge for rejected, duplicate, blocked, or empty candidates.

The company event uses Apify subscription tiers:

| Tier | Price per company |
| --- | ---: |
| Free | $0.001840 |
| Bronze | $0.001600 |
| Silver | $0.001248 |
| Gold | $0.000960 |
| Platinum | $0.000640 |
| Diamond | $0.000448 |

At the Free-tier item price, approximate totals are:

| Matching companies | Approximate total |
| ---: | ---: |
| 1 | $0.00284 |
| 10 | $0.01940 |
| 100 | $0.18500 |

These examples include the one-time start event.
Actual infrastructure usage is billed separately by Apify according to the user's plan.

### Search and filter behavior

Keyword discovery finds publicly indexed LinkedIn company pages.
The Actor then opens each public company page and extracts current visible metadata.

Readable filters are verified after extraction:

- Multiple values within one filter use **OR** logic.
- Different filter groups use **AND** logic.
- A company with a missing filtered field is not accepted.
- Filters apply equally to direct queries and LinkedIn search URL inputs.

This avoids claiming that an unverified snippet is an exact filter match.

### Pagination, limits, and deduplication

Discovery is paginated independently for each query.
The Actor stops when it reaches `maxItems`, exhausts the configured pages, or reaches the user's spending limit.

Canonical LinkedIn company URLs are used as deduplication keys.
A company found by multiple queries is saved once per run.
The first successful discovery query is retained in the row's provenance fields.

### Recurring market mapping workflow

A practical recurring workflow is:

1. Create a Task with two or more related queries.
2. Add a verified industry filter.
3. Set a useful item and page limit.
4. Schedule the Task weekly or monthly.
5. Export each dataset to your warehouse or spreadsheet.
6. Compare canonical `linkedinUrl` values between snapshots.

The Actor produces snapshots; it does not itself calculate historical changes or send alerts.
Use schedules, webhooks, or your downstream system for comparisons.

### Export and integration patterns

**Spreadsheet research**

Export the dataset as CSV or Excel and group companies by industry, location, or size.

**CRM preparation**

Use `linkedinUrl` as a stable matching key before adding records to an account list.

**Enrichment pipeline**

Send canonical URLs to another public company or employee enrichment workflow.

**Scheduled monitoring**

Trigger a webhook after each run and compare the new dataset with your previous snapshot.

**AI analysis**

Pass summaries and firmographic fields to an LLM for classification while retaining source URLs for verification.

### Run with the Apify API using cURL

Replace `YOUR_APIFY_TOKEN` with your token:

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~linkedin-company-search-scraper/runs?token=YOUR_APIFY_TOKEN&waitForFinish=120" \
  -H "Content-Type: application/json" \
  -d '{
    "searchQueries": ["workflow software"],
    "industries": ["Software Development"],
    "maxItems": 10,
    "maxPagesPerQuery": 3
  }'
```

Fetch dataset items from the returned run's `defaultDatasetId`.

### Run with JavaScript

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });

const run = await client.actor('automation-lab/linkedin-company-search-scraper').call({
    searchQueries: ['workflow software', 'developer tools'],
    industries: ['Software Development'],
    maxItems: 25,
    maxPagesPerQuery: 5,
});

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

### Run with Python

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ["APIFY_TOKEN"])

run = client.actor("automation-lab/linkedin-company-search-scraper").call(run_input={
    "searchUrls": [{
        "url": "https://www.linkedin.com/search/results/companies/?keywords=renewable%20energy"
    }],
    "maxItems": 25,
    "maxPagesPerQuery": 5,
})

items = client.dataset(run["defaultDatasetId"]).list_items().items
print(items)
```

### Use with MCP and AI assistants

Add this Actor to Claude Code through Apify MCP:

```bash
claude mcp add --transport http apify \
  "https://mcp.apify.com?tools=automation-lab/linkedin-company-search-scraper"
```

**Claude Desktop**, **Cursor**, and **VS Code** can use the equivalent remote MCP configuration below. Add it to the MCP settings for the client you use:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/linkedin-company-search-scraper"
    }
  }
}
```

Example prompts:

- "Find 20 public LinkedIn company pages for workflow software companies."
- "Run the renewable energy LinkedIn company search URL and return company sizes and headquarters."
- "Build a Software Development company list from workflow software and developer tools queries."

### Reliability and troubleshooting

The Actor classifies temporary LinkedIn blocks and retries with a fresh bounded proxy session.
It does not silently treat login pages or anti-bot responses as valid empty company pages.

If a run returns fewer companies than requested:

- Increase `maxPagesPerQuery`.
- Broaden the query.
- Remove one strict filter.
- Check whether matching company pages are publicly indexed.
- Remember that missing public filter fields cause a candidate to be rejected.

If a LinkedIn search URL is rejected:

- Confirm the path is `/search/results/companies/`.
- Confirm it includes a non-empty `keywords` parameter.
- Move location and industry filters from opaque URL IDs into the readable input fields.

If all LinkedIn detail requests are blocked, retry later rather than repeatedly launching identical runs.

### Limitations

- Results are based on publicly indexed LinkedIn company pages, not a logged-in LinkedIn search session.
- Result ordering and coverage can differ from LinkedIn's native search.
- The Actor does not promise every company in a market.
- Opaque LinkedIn industry and geography IDs are not resolved.
- Public fields can be absent, stale, localized, or changed by the company.
- Follower counts and media URLs can change after extraction.
- The Actor does not scrape people, posts, jobs, private profiles, or member-only fields.
- Strict filters can legitimately produce zero rows.

### Responsible and legal use

Use this Actor only for lawful purposes and public data you are permitted to process.
Follow applicable privacy, database, intellectual-property, marketing, and platform rules.

Do not use the output for harassment, discrimination, spam, surveillance, or decisions that require protected or private information.
Apply appropriate retention, security, and deletion policies to exported data.

This Actor is independent and is not affiliated with or endorsed by LinkedIn.
LinkedIn is a trademark of its respective owner.

### FAQ

#### Does it need LinkedIn cookies?

No.
The Actor does not request a LinkedIn account, password, or session cookie.

#### Does it reproduce logged-in LinkedIn search exactly?

No.
It discovers publicly indexed company pages and verifies their public details.
Coverage and ranking can differ from logged-in LinkedIn search.

#### Can I search more than one market segment?

Yes.
Add up to 20 queries and set one overall `maxItems` limit.

#### Are filters exact?

They are case-insensitive readable-text matches against extracted public company fields.
Multiple values in a group use OR logic; industry, location, and size groups combine with AND logic.

#### Why is a field null?

LinkedIn does not publish every field for every company.
The Actor leaves unavailable data null instead of inventing a value.

#### Do empty results cost per company?

No.
Only matching company rows saved to the dataset produce an item event.
The one-time start event still applies.

#### Can I schedule it?

Yes.
Save the input as an Apify Task and attach a schedule.
Use dataset exports or a downstream system to compare runs.

### Related automation-lab Actors

- [LinkedIn Company Scraper](https://apify.com/automation-lab/linkedin-company-scraper) — extract richer public details from known company URLs.
- [LinkedIn Company Employees Scraper](https://apify.com/automation-lab/linkedin-company-employees-scraper) — continue from company discovery into public employee research where supported.
- [LinkedIn Public Profile Search Scraper](https://apify.com/automation-lab/linkedin-public-profile-search-scraper) — discover public person profile URLs by query.

Use LinkedIn Company Search Scraper first when you need to discover companies rather than process a known list of profile URLs.

# Actor input Schema

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

Keywords describing companies to find, such as software companies or renewable energy startups.

## `searchUrls` (type: `array`):

Optional public LinkedIn /search/results/companies/ URLs containing a keywords parameter. Opaque LinkedIn location and industry IDs are rejected; use the readable filters below instead.

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

Optional readable industry names. A company is saved only when its public LinkedIn industry contains one of these values.

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

Optional readable headquarters locations, for example London or California. A company is saved only when its public location matches one value.

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

Optional LinkedIn employee-size bands. A company is saved only when its public company-size text matches one selected band.

## `maxItems` (type: `integer`):

Maximum number of matching company records to save across all searches.

## `maxPagesPerQuery` (type: `integer`):

Maximum public search-result pages to inspect for each query. Raise this when strict filters reject many candidates.

## Actor input object example

```json
{
  "searchQueries": [
    "software companies"
  ],
  "maxItems": 10,
  "maxPagesPerQuery": 5
}
```

# Actor output Schema

## `overview` (type: `string`):

Public LinkedIn company records returned by the search.

# 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 = {
    "searchQueries": [
        "software companies"
    ],
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/linkedin-company-search-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 = {
    "searchQueries": ["software companies"],
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/linkedin-company-search-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 '{
  "searchQueries": [
    "software companies"
  ],
  "maxItems": 10
}' |
apify call automation-lab/linkedin-company-search-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,automation-lab/linkedin-company-search-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/MGdq4nJ4mmhGyDshI/builds/uj1XtWtlv3WnxT6AF/openapi.json