# LinkedIn Company by Domain - Verified Finder API (`george.the.developer/linkedin-company-by-domain`) Actor

Find the LinkedIn company page for any website domain. Resolve LinkedIn company by domain with verified matching: a row bills only when the site and the LinkedIn page agree. Employee count, followers, free 30-day cache, free monitoring diffs. Batch up to 50,000 domains. No login.

- **URL**: https://apify.com/george.the.developer/linkedin-company-by-domain.md
- **Developed by:** [George Kioko](https://apify.com/george.the.developer) (community)
- **Categories:** Lead generation, AI
- **Stats:** 1 total users, 1 monthly users, 100.0% 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.

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 by Domain - Verified Finder API

[LinkedIn Company by Domain](https://apify.com/george.the.developer/linkedin-company-by-domain) is an Apify Actor that resolves any website domain to its official LinkedIn company page and returns the match with a verified confidence score, employee count and follower count, without logins, cookies or manual URL guessing.

> Every billed row carries mutual evidence. The domain's own website points at the LinkedIn page AND the page agrees back. Rows that cannot prove it are free.

Batch up to 50,000 domains. Verified confidence scoring. Free 30 day resolution cache. Free monitoring diffs on scheduled runs. MCP ready for AI agents.

### Pricing (Pay Per Event)

| Event | Price |
|---|---|
| Actor start | $0.002 per run |
| Verified company resolved | $0.0075 per row ($7.50 per 1,000) |

You pay $7.50 per 1,000 resolved domains and $0 for anything unresolved, cached within 30 days, or low confidence. A 1,000 domain run that resolves 850 costs $6.38, not $7.50.

#### Cost math vs doing it manually

Manual lookup takes about a minute per domain at $30 per hour, which is $0.50 per domain or $5,000 of labor for 10,000 domains. This actor resolves the same 10,000 domains for $75 in minutes. That is a 98.5 percent cost reduction on the same work.

### Quick start

curl

```bash
curl -X POST "https://api.apify.com/v2/acts/george.the.developer~linkedin-company-by-domain/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"domains": ["stripe.com", "vercel.com", "gitlab.com"]}'
```

Node.js (npm install apify-client)

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const { items } = await client.actor('george.the.developer/linkedin-company-by-domain')
    .call({ domains: ['stripe.com', 'vercel.com'] });
console.log(items);
```

Python (pip install apify-client)

```python
from apify_client import ApifyClient

client = ApifyClient("MY_APIFY_TOKEN")
run = client.actor("george.the.developer/linkedin-company-by-domain").call(
    run_input={"domains": ["stripe.com", "vercel.com"]}
)
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)
```

Runnable copies live in [examples/](examples/).

### What data you get per domain

```json
{
  "domain": "deathwishcoffee.com",
  "linkedinUrl": "https://www.linkedin.com/company/death-wish-coffee/",
  "companyName": "Death Wish Coffee",
  "confidence": "high",
  "method": "homepage-sameas",
  "employeeCount": 213,
  "followers": 45600,
  "websiteStatus": "live",
  "cached": false,
  "charged": true
}
```

### What is NOT returned

Honest limits, stated up front.

- No email addresses. Email finding was measured against live B2B infrastructure and does not produce verifiable results at acceptable cost, so we do not sell unverifiable rows.
- No individual employee profiles. This actor resolves companies. Use [our employees scraper](https://apify.com/george.the.developer/linkedin-company-employees-scraper) downstream on the linkedinUrl field.
- No social media URLs other than LinkedIn.
- Low confidence guesses are labeled confidence low and charged $0. They are never silently mixed into billed rows.

### How verification works (why wrong company rows do not happen)

Most domains are resolved in this order, stopping as soon as proof is sufficient.

1. The company's own website declares its LinkedIn page in JSON-LD sameAs data or footer links. Free.
2. Slug probe checks linkedin.com/company/{your-domain-name} directly through a residential session.
3. Wikidata gives an authoritative brand name lookup by official website. Free.
4. Google search restricted to linkedin.com/company, used only when cheaper rungs are inconclusive.
5. A rendered page pass for JavaScript only websites.

A candidate page then has to agree with the site that nominated it (name match or a reference to your domain) before it bills at high or medium confidence. Disagreement means a free low confidence row.

### Use cases

1. CRM enrichment. Turn the website column of your lead list into clean LinkedIn company URLs for Clay, HubSpot or Pipedrive.
2. Investment and sales research batches. Resolve 10,000 portfolio or prospect domains in one scheduled run. Only new or stale entries ever cost money thanks to the cache.
3. Company change monitoring. Schedule weekly runs in monitor mode and receive free diffs covering headcount changes, renames, new and removed companies.

### How to use

1. Paste domains (anything from stripe.com to full URLs) into Website Domains.
2. Choose resolve for a one shot run or monitor for diffs against your previous run.
3. Run. Read rows from the dataset or plug the dataset URL straight into n8n, Clay or Make.

#### Input parameters

| Parameter | Type | Default | Description |
|---|---|---|---|
| domains | array | required | Websites to resolve; duplicates collapsed automatically |
| mode | select | resolve | resolve or monitor |
| monitorBatchId | string | default | Named batch for monitor diffs |
| forceRefresh | boolean | false | Ignore cache and re-resolve everything |
| cacheTtlDays | integer | 30 | How long resolutions stay cached |
| includeUnresolved | boolean | true | Emit free rows for unresolved domains |
| maxDomains | integer | 1000 | Hard cap per run (max 50,000) |
| concurrency | integer | 10 | Parallel domains |

### Call it from the Apify MCP server

AI agents can reach this actor through the Apify MCP server.

```
https://mcp.apify.com/?tools=george.the.developer/linkedin-company-by-domain
```

### Integration snippets

Clay, as an HTTP API enrichment column

```
POST https://api.apify.com/v2/acts/george.the.developer~linkedin-company-by-domain/run-sync-get-dataset-items?token=YOUR_TOKEN
{ "domains": ["{{website}}"] }
```

n8n and Make use the Apify node. Set the actor to linkedin-company-by-domain, pass domains from your sheet and iterate dataset items.

### FAQ

#### How is this different from other domain to LinkedIn actors?

They bill every attempt from a single discovery source. This one requires two independent sources to agree before billing, caches results for 30 days free of charge and never charges an unresolved domain.

#### What happens when a domain cannot be matched?

You get one row explaining why in the qualityState field, charged $0. Turn includeUnresolved off if you want billed rows only.

#### Does this need my LinkedIn account or cookies?

No. The actor reads public pages and never logs in.

#### Can I monitor headcount changes over time?

Yes. Set mode to monitor and schedule weekly runs. Each run emits one free diff summary covering new companies, headcount changes and renames. Snapshots live in your own account.

#### What does cached mean on a row?

The same domain resolved within the TTL window. Cached rows return instantly and are always free. Repeat runs only pay for genuinely new work.

### Changelog

0.1 (2026-08-23). Initial release. Five source resolution waterfall, verified confidence scoring, free monitoring diffs, 30 day resolution cache, batch up to 50k domains.

### Related actors

- [LinkedIn Company Employees Scraper](https://apify.com/george.the.developer/linkedin-company-employees-scraper) feeds resolved linkedinUrls in and gets verified employee profiles out.
- [LinkedIn Post Engagers Scraper](https://apify.com/george.the.developer/linkedin-post-engagers-scraper) turns post reactions and comments into ICP matched leads.

### License

MIT, see [LICENSE](LICENSE). The hosted actor on the [Apify Store](https://apify.com/george.the.developer/linkedin-company-by-domain) is the supported, managed way to run this.

### Support

Found a bug or need a feature? Open an issue on [GitHub](https://github.com/the-ai-entrepreneur-ai-hub/linkedin-company-by-domain/issues) or message george.the.developer on Apify.

# Actor input Schema

## `domains` (type: `array`):

Websites to resolve, with or without protocol/paths (e.g. stripe.com, https://www.vercel.com/about). Duplicates are collapsed automatically. Maximum 50,000 per run.

## `mode` (type: `string`):

resolve: find each domain's LinkedIn page once. monitor: same, then diff against your previous run (new companies, headcount and name changes) for free. Monitoring snapshots live in a named key-value store in your account.

## `monitorBatchId` (type: `string`):

Named group of domains to monitor together when mode is 'monitor' (e.g. 'prospects-q4'). Runs with the same batch id diff against each other.

## `forceRefresh` (type: `boolean`):

Ignore the resolution cache and re-resolve every domain. Cached resolutions from the last 30 days are normally returned instantly and free of charge.

## `cacheTtlDays` (type: `integer`):

How long a resolved mapping is reused before it is refreshed automatically.

## `includeUnresolved` (type: `boolean`):

Emit one row per unresolved domain (confidence=low, charged $0) so you can see coverage. Turn off to receive only billed rows.

## `maxDomains` (type: `integer`):

Hard cap on domains processed in this run. Split larger lists into multiple runs.

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

Domains processed in parallel. Higher is faster; above 25 some sites start rate-limiting.

## `useVpsRender` (type: `boolean`):

Allow the optional VPS lane (JavaScript-rendered pages and persistent cache). The actor works fully without it; this only adds coverage for SPA homepages.

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

Optional. Uses Apify Proxy automatically (GOOGLE\_SERP + RESIDENTIAL groups). Override only if you have a specific requirement.

## Actor input object example

```json
{
  "domains": [
    "stripe.com",
    "vercel.com",
    "gitlab.com"
  ],
  "mode": "resolve",
  "monitorBatchId": "default",
  "forceRefresh": false,
  "cacheTtlDays": 30,
  "includeUnresolved": true,
  "maxDomains": 1000,
  "concurrency": 10,
  "useVpsRender": true,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

One row per domain: verified confidence (high/medium/low), resolution method, company name, LinkedIn URL, employee count and followers. Unresolved domains emit free rows carrying a qualityState explaining why. Monitor mode adds free diff-summary rows.

# 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 = {
    "domains": [
        "stripe.com",
        "vercel.com",
        "gitlab.com"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("george.the.developer/linkedin-company-by-domain").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 = {
    "domains": [
        "stripe.com",
        "vercel.com",
        "gitlab.com",
    ],
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("george.the.developer/linkedin-company-by-domain").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 '{
  "domains": [
    "stripe.com",
    "vercel.com",
    "gitlab.com"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call george.the.developer/linkedin-company-by-domain --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,george.the.developer/linkedin-company-by-domain"
        }
    }
}

```

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/0reNPvdycTAAOpOYQ/builds/1fjZ8Z4sRSna9hb7c/openapi.json