# LinkedIn Company Enrichment - Firmographics & Company Data (`thirdwatch/linkedin-company-enrichment-scraper`) Actor

Turn a LinkedIn company URL, slug, company name, or domain into a firmographic record — industry, size band, employees, followers, HQ, offices, founded year, specialties, website, and logo. No login required.

- **URL**: https://apify.com/thirdwatch/linkedin-company-enrichment-scraper.md
- **Developed by:** [Thirdwatch](https://apify.com/thirdwatch) (community)
- **Categories:** Lead generation
- **Stats:** 11 total users, 5 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $7.00 / 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 Enrichment Scraper

> Turn a LinkedIn company URL, company name, or website domain into a structured firmographic record with industry, size, followers, headquarters, locations, specialties, and website details.

### What you get

Provide one or many companies and receive exactly one terminal record per accepted input query. `terminal_status` is one of `resolved`, `no_match`, `fetch_failed`, or `duplicate_slug`; resolved and duplicate rows also carry the company fields below. LinkedIn URLs and slugs are the most precise inputs; names and domains are useful when you are enriching an existing account list.

### Output fields

| Field | Description |
|---|---|
| `query_id` / `query_index` | Stable input identity and order |
| `terminal_status` | `resolved`, `no_match`, `fetch_failed`, or `duplicate_slug` |
| `failure_kind` | Retry reason on `fetch_failed` rows only |
| `duplicate_of_query_id` | Earlier input owning the same slug on `duplicate_slug` rows |
| `name` | Company name |
| `slug` / `company_id` | LinkedIn identifiers |
| `linkedin_url` | Canonical company-page URL |
| `tagline` / `description` | Public positioning and About text |
| `industry` | LinkedIn industry label |
| `company_size` | Published employee-size band |
| `employee_count_min` / `employee_count_max` | Parsed size-band bounds |
| `employees_on_linkedin` | Members who publicly list the company as employer |
| `follower_count` | Company-page followers |
| `founded_year` / `company_type` | Founding year and organization type |
| `specialties` | Self-declared specialties |
| `website` / `website_domain` | Company website details |
| `headquarters` | Formatted headquarters address |
| `hq_street`, `hq_city`, `hq_region`, `hq_postal_code`, `hq_country` | Headquarters components |
| `locations` / `locations_count` | Published office locations |
| `logo_url` / `banner_image_url` | Public brand images |
| `recent_post_count` / `latest_post_at` | Recent public activity signals |
| `source_query` / `scraped_at` | Input and collection timestamp |

### Example output

```json
{
  "name": "HashiCorp",
  "slug": "hashicorp",
  "linkedin_url": "https://www.linkedin.com/company/hashicorp/",
  "industry": "Software Development",
  "company_size": "1001-5000 employees",
  "employee_count_min": 1001,
  "employee_count_max": 5000,
  "follower_count": 250000,
  "founded_year": 2012,
  "company_type": "Public Company",
  "website": "https://www.hashicorp.com",
  "headquarters": "San Francisco, California, United States",
  "source_query": "hashicorp.com"
}
```

### Domain → LinkedIn company page

Give the actor a bare domain (`stripe.com`, `getpostman.com`, `https://acme.io/pricing`)
and it resolves the LinkedIn company page for you, then enriches it. Resolution
is tried in this order, and the winning path is reported on the row as
`resolution`:

| `resolution` | How the page was found |
| --- | --- |
| `website_link` | The domain's own homepage links to a LinkedIn company page. First-party and authoritative, so it is accepted directly. |
| `domain_guess_website_match` | The slug guessed from the domain label, confirmed by the LinkedIn page's own website field. |
| `typeahead_website_match` | LinkedIn's public company typeahead, confirmed by the website field. |
| `domain_guess_name_match` / `typeahead_name_match` | Confirmed by the LinkedIn page's display name instead, when the website field is empty or a redirector. |

The homepage probe goes out **direct, not through your proxy** — third-party
sites do not rate-limit us, and a proxied homepage would cost more bandwidth than
the enriched row is priced at. A domain that never corroborates any candidate
returns `no_match` rather than a guessed, possibly-wrong company.

### Input parameters

| Parameter | Required | Description |
|---|---|---|
| `companies` | Yes | LinkedIn company URLs, slugs, company names, or website domains (`stripe.com`, `https://stripe.com`). |
| `queryRecords` | API alternative | Bound objects with `queryId`, `companyName`, optional `countryCode`, and optional `companyKeys`. Do not combine with `companies`. |
| `maxResults` | No | Maximum input queries accepted. The run fails instead of truncating if this is smaller than the input. Default `10`. |
| `concurrency` | No | Companies processed at the same time. Default `10`. |
| `proxyConfiguration` | No | Connection settings. Keep the preconfigured default for most runs. |

### Use cases

- **Sales operations**: Fill missing firmographic fields in CRM account records.
- **Market research**: Compare industries, size bands, locations, and specialties across company cohorts.
- **Recruiting intelligence**: Segment target employers by size, industry, and geography.
- **Data teams**: Normalize mixed company names, domains, and LinkedIn URLs into one schema.

### Limitations

- Website-domain resolution is best-effort. It is strongest when the domain's own homepage links to its LinkedIn page (see below); use LinkedIn URLs or slugs when precision has to be guaranteed.
- Common company names can resolve to a larger organization with the same name.
- Optional fields such as specialties, founded year, and employee counts are absent when the company has not published them.
- Only public company-page data is supported. Private and member-only information is out of scope.

### Compared to alternatives

- **vs. other LinkedIn company enrichment actors**: This actor accepts a mixed list of LinkedIn URLs, names, and domains and returns a compact firmographic record intended for account enrichment.
- **vs. LinkedIn Company Employees actors**: This actor returns company-level facts, not employee profiles. Pair the two when you need both account and people data.

### FAQ

**Which input is most reliable?**
A full LinkedIn company URL or exact slug. Names and domains are best-effort discovery inputs.

**Does it require a LinkedIn login?**
No. It collects fields published on public company pages.

**Can I process a mixed input list?**
Yes. URLs, slugs, names, and domains can appear in the same `companies` list.

### Related Actors

- [LinkedIn Company Employees Scraper & New Hire Monitor](https://apify.com/thirdwatch/linkedin-company-employees-scraper) — Thirdwatch
- [LinkedIn Profile Scraper](https://apify.com/thirdwatch/linkedin-profile-scraper) — Thirdwatch
- [LinkedIn Email Finder](https://apify.com/thirdwatch/linkedin-email-finder-scraper) — Thirdwatch

Last verified: 2026-07

More company-data actors at [thirdwatch.dev](https://thirdwatch.dev).

# Actor input Schema

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

One company per line. Accepts LinkedIn company URLs (https://www.linkedin.com/company/hashicorp/), bare LinkedIn slugs (hashicorp), company names (HashiCorp), or website domains (hashicorp.com). LinkedIn URLs and slugs resolve exactly; names and domains are resolved best-effort.

## `queryRecords` (type: `array`):

Structured queries for resumable pipelines. Every record produces exactly one dataset row carrying the same queryId and one terminal status. Do not combine with companies.

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

Maximum number of input queries accepted. The run fails instead of truncating when more queries are supplied, so every accepted input receives one terminal row.

## `concurrency` (type: `integer`):

How many companies to process at the same time. The default is recommended for most runs.

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

Connection settings for reliable company-page collection. Keep the preconfigured default unless you have a specific requirement.

## Actor input object example

```json
{
  "companies": [
    "https://www.linkedin.com/company/hashicorp/"
  ],
  "maxResults": 10,
  "concurrency": 10,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `results` (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 = {
    "companies": [
        "https://www.linkedin.com/company/hashicorp/",
        "stripe.com",
        "Datadog"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("thirdwatch/linkedin-company-enrichment-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/hashicorp/",
        "stripe.com",
        "Datadog",
    ] }

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

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,thirdwatch/linkedin-company-enrichment-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/ZMZXSaoniBwaHAelG/builds/0UTBrhN2hdIgCT6pO/openapi.json