# LinkedIn Company Finder & B2B Lead Generator (`scraping_solutions/linkedin-company-finder`) Actor

Find LinkedIn companies by keyword, country, and industry. Build clean, deduplicated B2B lead lists with company names, LinkedIn URLs, industries, locations, logos, and IDs. No login or cookies required.

- **URL**: https://apify.com/scraping_solutions/linkedin-company-finder.md
- **Developed by:** [Scraping Solutions](https://apify.com/scraping_solutions) (community)
- **Categories:** Lead generation, Social media, Developer tools
- **Features:** Limited permissions
- **Stats:** 26 total users, 1 monthly users, 96.9% runs succeeded, 0 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $1.10 / 1,000 results

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?

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 Search Scraper & B2B Lead Finder

Discover LinkedIn companies by keyword, country, and industry, then export a deduplicated company list to CSV, Excel, or JSON. Use basic search results for account discovery, or enable company enrichment for websites, descriptions, employee counts, and other available public business information.

No LinkedIn login, cookies, or account session is required. This Actor finds **companies**, not individual decision-makers or personal email addresses.

### Quick start: find your first 10 companies

1. Open the **Input** tab and enter a market, product, or company keyword.
2. Set **Results per search** to `10` and turn **Enrich company details** off for a basic discovery run.
3. Optionally select countries and industries, then start the Actor.
4. Open the dataset when results arrive and export it in your preferred format.

Equivalent JSON input:

```json
{
  "searchTerms": ["B2B SaaS"],
  "resultsPerSearch": 10,
  "enrichCompanyDetails": false
}
```

**The input form defaults to 20 results per search with enrichment enabled.** Set `enrichCompanyDetails` explicitly to `false` when you want discovery-only pricing. Configure your spending limit in Apify's **Run options**, not in the input JSON. The Actor checks the planned workload against the available budget before starting, so an extremely low spending limit can prevent a run.

### Choose discovery or enriched company data

| Mode | Use it for | Available data | Charge events |
| --- | --- | --- | --- |
| Discovery: `enrichCompanyDetails: false` | Build an account list, collect company URLs, explore a market | Company identity, LinkedIn URL, and available search fields such as industry and location | One result event per saved company row |
| Enrichment: `enrichCompanyDetails: true` | Research accounts, qualify companies, prepare CRM imports | Search fields plus available website, description, headquarters, employee information, followers, specialties, and other company details | Result events plus successful company-enrichment events |

Field availability varies by company. A failed enrichment does not generate an enrichment event. Its basic search record can still be saved when strict qualification does not exclude it.

### Example: search companies in a target market

Discover ecommerce companies in the United States using the country selector:

```json
{
  "searchTerms": ["ecommerce"],
  "locationIds": ["103644278"],
  "resultsPerSearch": 20,
  "enrichCompanyDetails": false
}
```

Use several keywords to explore related segments in one run, for example `"ecommerce analytics"` and `"retail software"`. Companies are deduplicated across pages and queries within that run. The same company can appear again in a later run.

### Example: qualify companies by country and employee size

Search for software companies in Colombia, enrich the candidates, and keep companies whose available location and employee-size evidence passes the requested checks:

```json
{
  "searchTerms": ["software"],
  "locationIds": ["100876405"],
  "resultsPerSearch": 20,
  "enrichCompanyDetails": true,
  "minimumEmployeeCount": 200,
  "maximumEmployeeCount": 5000,
  "strictLocationFiltering": true,
  "strictEmployeeFiltering": true
}
```

Search-time location and industry filters narrow discovery. Strict filters perform an additional check on the returned company data after enrichment. A search location match alone is not a guarantee that a company is headquartered in that country.

Both strict options require enrichment. Strict location filtering also requires a recognized country selection; an arbitrary city or region ID alone is insufficient. Strict employee filtering rejects companies whose size cannot be confirmed under the Actor's employee qualification rules. Public LinkedIn employee counts and company-size ranges are indicators, not audited headcounts.

**Filtering can reduce the final number of rows.** `resultsPerSearch` limits discovered candidates; it does not guarantee that this many companies will survive qualification. Successfully enriched companies still incur the enrichment event when a later strict filter excludes them.

### Input reference

| Field | Default | Description |
| --- | --- | --- |
| `searchTerms` | `["B2B SaaS"]` | Required list of 1–50 market, product, industry, or company keywords. The form's prefilled example may contain additional terms. |
| `locationIds` | `[]` | Select countries by name in the form. JSON uses numeric LinkedIn location IDs as strings. Advanced city or region IDs can be used for search filtering. |
| `industryIds` | `[]` | Select LinkedIn industries in the form; JSON uses industry IDs as strings. |
| `resultsPerSearch` | `20` | Maximum discovered companies per query. The input form accepts 1–750. Actual availability, deduplication, filters, and run limits can reduce output. |
| `enrichCompanyDetails` | `true` | Retrieve additional company details. Adds a charge for each successful enrichment. |
| `minimumEmployeeCount` | Not set | Optional lower employee bound, used by qualification. |
| `maximumEmployeeCount` | Not set | Optional upper employee bound; must not be below the minimum. |
| `strictLocationFiltering` | `false` | Retain only companies that pass the country qualification check. Requires enrichment and a recognized selected country. |
| `strictEmployeeFiltering` | `false` | Retain only companies that pass the employee-size check. Requires enrichment. |

Employee bounds without strict filtering provide qualification information rather than automatically excluding every nonmatching company. Start with a small sample to inspect the available evidence before enabling strict filters.

### Output and exports

Each dataset row represents one company. This shortened, illustrative discovery record shows the shape of a result; it is not a live company record:

```json
{
  "companyName": "Example Analytics",
  "linkedinUrl": "https://www.linkedin.com/company/example-analytics/",
  "industry": "Software Development",
  "location": "United States",
  "sourceQuery": "B2B SaaS",
  "icpScore": null,
  "icpScoreReasons": []
}
```

Depending on the available data, enriched rows can also include `website`, `description`, `employeeCount`, `employeeCountRange`, and `headquarters`. Qualification fields such as `locationMatch` and `employeeSizeMatch` help explain whether a company meets your targeting rules.

Missing optional values are generally omitted; do not assume every row has every field. The score fields remain present even when no scoring rules apply. Build imports around company identifiers and allow optional fields to be absent.

Download **CSV, Excel, or JSON** from the Apify dataset. For Google Sheets or a CRM, import the export or configure an integration. The Actor does not create a CRM record or a spreadsheet automatically.

### Pricing: results and optional enrichment

The current event rates are shown below. Check the Actor's [Pricing tab](https://apify.com/scraping_solutions/linkedin-company-finder/pricing) for the rates that apply to your Apify plan.

| Apify plan | 1,000 saved company rows | 1,000 successful enrichments, additional | 1,000 rows with 1,000 enrichments |
| --- | ---: | ---: | ---: |
| Free / Bronze | $1.30 | $6.00 | $7.30 |
| Silver | $1.20 | $6.00 | $7.20 |
| Gold / Platinum / Diamond | $1.10 | $5.00 | $6.10 |

The configured startup event is $0.00005 per GB of run memory, with a minimum of one unit when charged. The table excludes this startup event and any separate platform charges applicable to your account.

For example, at Free/Bronze event rates:

- **100 discovery rows:** $0.13 in result events.
- **100 saved rows and 100 successful enrichments:** $0.73 in result and enrichment events.
- **100 successful enrichments but only 30 rows pass strict filters:** $0.639: $0.60 enrichment plus $0.039 results.

Result events are named `apify-default-dataset-item`; successful enrichments use `company-enrichment`. Duplicates removed within a run do not generate an additional result row or result charge. Failed enrichment attempts do not generate successful-enrichment charges. A run with zero saved results may still have enrichment charges if strict filters excluded successfully enriched companies, and the startup event can still apply.

### Practical limits and data coverage

- Results depend on available public company data and search coverage. A keyword search is not a complete census of every company in a market.
- The result limit applies per query before post-enrichment filtering. Overlapping queries can produce fewer unique rows.
- Unpaid Apify accounts have an additional cap of 50 companies per run. This is an output restriction, not an exemption from configured event charges.
- Strict country and employee rules can reject incomplete records. Turn them off when exploring a market and inspect qualification fields first.
- Enrichment takes additional requests and time. Begin with a small sample before scheduling larger runs.
- This Actor accepts search terms, not a dedicated list of company URLs for direct enrichment. It does not extract company posts, employee profiles, or personal contact lists.

### Common workflows

- **B2B account discovery:** search a niche and export company URLs for further research.
- **Account-based marketing:** combine market keywords with country and employee-size qualification.
- **Competitor and market research:** compare company descriptions, industries, and public positioning.
- **CRM preparation:** export firmographic fields and map them to your CRM's company records.
- **Scheduled monitoring:** save an input as an Apify task and schedule repeat runs. Deduplicate across runs in your destination system if needed.

For programmatic use, open the Actor's [API tab](https://apify.com/scraping_solutions/linkedin-company-finder/api) for integration examples. Use the same input fields shown here and keep your Apify token in a secret or environment variable.

### FAQ

#### Do I need LinkedIn cookies or a paid LinkedIn account?

No. You do not supply a LinkedIn session, login, or cookies.

#### Why did I get fewer companies than requested?

The search may have fewer matches; repeated companies are removed within a run; strict qualification can exclude candidates; and budget or account limits can stop collection. The limit is a maximum, not a guaranteed result count.

#### Can I search by country without memorizing IDs?

Yes. Select countries by name in the input form. IDs are needed when constructing the JSON input directly.

#### Can I get only companies that match my employee range?

Enable enrichment, set the bounds, and enable `strictEmployeeFiltering`. Missing or inconsistent size evidence can exclude a company. Successful enrichment is charged even when the subsequent check rejects it.

### Support and responsible use

If a run behaves unexpectedly, open an [issue](https://apify.com/scraping_solutions/linkedin-company-finder/issues) with the **run ID**, expected outcome, and a sanitized input example. Never include API tokens, cookies, or other credentials.

Use exported data responsibly and comply with applicable privacy requirements and platform terms. Review data quality and relevance before importing it into a production workflow.

# Changelog

This Actor's version history is a separate document: https://apify.com/scraping_solutions/linkedin-company-finder/changelog.md

# Actor input Schema

## `searchTerms` (type: `array`):

Add one market, product, industry, or company keyword per line.

## `locationIds` (type: `array`):

Select one or more countries by name. Advanced users can also enter a numeric LinkedIn location ID for a city or region.

## `industryIds` (type: `array`):

Select one or more active LinkedIn industries by name. Advanced users can also enter a numeric LinkedIn industry ID.

## `resultsPerSearch` (type: `integer`):

Maximum for each search term. The provider exposes 50 companies per page and up to 15 pages (750 companies). Add multiple search terms when you need more than 1,000 combined results.

## `enrichCompanyDetails` (type: `boolean`):

Fetch additional LinkedIn company details such as website, description, follower count, employee data, specialties, and other available public metadata. Each successfully enriched company is charged separately.

## `minimumEmployeeCount` (type: `integer`):

Optional qualification limit. Employee count and LinkedIn's reported company-size range are evaluated separately after enrichment.

## `maximumEmployeeCount` (type: `integer`):

Optional qualification limit. Leave empty when no maximum should be applied.

## `strictLocationFiltering` (type: `boolean`):

After enrichment, publish only companies whose headquarters matches a country selected above. Unknown or conflicting locations are excluded. Enrichment is still charged for profiles checked before exclusion.

## `strictEmployeeFiltering` (type: `boolean`):

After enrichment, publish only companies that satisfy the employee limits. Records with missing or contradictory employee data are excluded. Enrichment is still charged for profiles checked before exclusion.

## Actor input object example

```json
{
  "searchTerms": [
    "B2B SaaS",
    "ecommerce analytics"
  ],
  "locationIds": [],
  "industryIds": [],
  "resultsPerSearch": 20,
  "enrichCompanyDetails": true,
  "strictLocationFiltering": false,
  "strictEmployeeFiltering": false
}
```

# Actor output Schema

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

Company records in the default dataset, ready for JSON, CSV, Excel, or API export.

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

Counts, provider request usage, and estimated external API cost.

# 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 = {
    "searchTerms": [
        "B2B SaaS",
        "ecommerce analytics"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("scraping_solutions/linkedin-company-finder").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 = { "searchTerms": [
        "B2B SaaS",
        "ecommerce analytics",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("scraping_solutions/linkedin-company-finder").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 '{
  "searchTerms": [
    "B2B SaaS",
    "ecommerce analytics"
  ]
}' |
apify call scraping_solutions/linkedin-company-finder --silent --output-dataset

```

## MCP server setup

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

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/6SAvw5enM2Hfp4f5q/builds/fyxQBtmAiN1UrQW4g/openapi.json
