# LinkedIn Company Scraper (No Login) - $2.8 per 1,000 (`transparent_meteorite/linkedin-company-scraper`) Actor
Scrape public LinkedIn company pages with no login: industry, size, employees, followers, HQ address, website, specialties, all offices, similar companies and recent posts. Paste URLs, names or domains. $2.8 per 1,000; not-found free.
- **URL**: https://apify.com/transparent_meteorite/linkedin-company-scraper.md
- **Developed by:** [Detroit Web Agent - Open Data](https://apify.com/transparent_meteorite) (community)
- **Categories:** Lead generation, Social media
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet
## Pricing
from $2.10 / 1,000 company scrapeds
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 Scraper - public company pages, no login, no cookies ($2.80 per 1,000)
[](https://console.apify.com/actors/yVYB33dk7KyUPodl3/input)
| Price per 1,000 companies | Free plan | Starter | Scale | Business |
|---|---|---|---|---|
| **This Actor** | **$2.80** | **$2.80** | **$2.45** | **$2.10** |
| Most-used alternative | $4.00 | $4.00 | $3.50 | $3.00 |
Pay per event, no monthly rental. Prices read from each Actor's public Apify pricing on 2026-10-13; check the Pricing tab for the current figure.
- **In short:** LinkedIn Company Scraper (Apify actor `transparent_meteorite/linkedin-company-scraper`) turns LinkedIn company page URLs, slugs, company names or website domains into clean company rows: industry, company size, employees on LinkedIn, followers, headquarters and full address, website, specialties, founded year, every office location, similar companies, affiliated pages and recent posts with likes and comments.
- **Who it is for:** sales and lead-generation teams enriching account lists, RevOps and CRM owners, recruiters mapping employers, investors and analysts tracking companies, marketers watching competitors.
- **Input:** a list of LinkedIn company URLs, slugs, company names or website domains (mix freely), posts per company, which sections to include.
- **Output:** one row per company, plus a free `not_found` row for anything we could not match.
- **Price:** $0.0028 per company delivered. Not-found, blocked and duplicate inputs are free. No subscription, no LinkedIn account.
- **Limits:** public company pages only. No people profiles, no employee lists, no emails, no company keyword search (LinkedIn does not offer that without login).
**Key facts**
- Actor ID: `transparent_meteorite/linkedin-company-scraper`
- Data source: LinkedIn's public (logged-out) company pages, the same page anyone sees without signing in
- Login, cookies or LinkedIn account needed: no
- Pricing model: pay per event (`apify-actor-start` $0.00005, `company-scraped` $0.003)
- Output formats: JSON, CSV, Excel, XML, HTML table (Apify dataset)
- Access: Apify Console, REST API, JavaScript and Python clients, schedules, webhooks, Apify MCP server
- Also known as: LinkedIn company data extractor, LinkedIn company info scraper, LinkedIn firmographics API, LinkedIn company enrichment, company domain to LinkedIn
- Last updated: 2026-10-13
### Run in 30 seconds
1. Click **Try for free** (or **Start**). The input is already filled with HubSpot and Stripe.
2. Press **Start**. Two companies finish in about 10 seconds.
3. Open the **Overview** tab of the output, or export to CSV, Excel or JSON.
Swap in your own list: paste one company per line, in any of these forms.
```
https://www.linkedin.com/company/hubspot
stripe
openai.com
Notion
```
### Why choose this actor
- **No login, no cookies, no account risk.** It reads the public company page LinkedIn shows to everyone. Your LinkedIn account is never involved.
- **Cheaper than the leading LinkedIn company scrapers.** $2.80 per 1,000 companies, and you pay nothing for inputs we could not find.
- **Paste anything.** Company URLs (any country subdomain, `/about/`, `/posts/`, `/showcase/`, `/school/`), bare slugs, company names or website domains. Domains are matched against the website listed on the LinkedIn page, so `stripe.com` returns Stripe, not a lookalike.
- **More per row.** Besides the standard company card you get every listed office address, LinkedIn's "Similar pages" (ready-made lookalike lists), affiliated and showcase pages, and up to 10 recent posts with dates, likes, comments and media.
- **Name lookups pick the real company.** When several pages share a name (there are two "Notion" pages), it returns the one with the most followers and lists the others in `otherMatches`.
### Input
| Field | Type | Default | What it does |
|---|---|---|---|
| `companies` | list of strings | HubSpot, Stripe | Company URLs, slugs, names or website domains, one per line. |
| `startUrls` | URL list | empty | Same as `companies`, for tools that send a URL list. |
| `domains` | list of strings | empty | Website domains to match, e.g. `hubspot.com`. |
| `maxPostsPerCompany` | integer 0-10 | 5 | Recent public posts to include per company. 0 turns posts off. |
| `includeLocations` | boolean | true | Every office address on the page. |
| `includeSimilarPages` | boolean | true | LinkedIn's "Similar pages": name, URL, industry, location. |
| `includeAffiliatedPages` | boolean | true | Subsidiaries and showcase pages. |
| `includeNotFound` | boolean | true | Free row with status `not_found` for anything we could not match. |
| `maxCompanies` | integer | 1000 | Stop after this many inputs. |
| `maxConcurrency` | integer 1-10 | 4 | Pages fetched in parallel. |
| `proxyConfiguration` | proxy | Apify Proxy | Datacenter proxy is enough. Use RESIDENTIAL only if you see sign-in-wall warnings. |
Example API input:
```json
{
"companies": ["https://www.linkedin.com/company/hubspot", "stripe", "openai.com", "Notion"],
"maxPostsPerCompany": 3
}
```
### Output
| Field | Example | Notes |
|---|---|---|
| `name` | Stripe | Company name |
| `linkedinUrl` | https://www.linkedin.com/company/stripe | Canonical page URL |
| `universalName` | stripe | LinkedIn slug |
| `companyId` | 2135371 | Numeric LinkedIn company ID, when shown |
| `pageType` | company | company, showcase or school |
| `tagline`, `description` | | Short tagline and the full "About" text |
| `website`, `websiteDomain` | https://stripe.com, stripe.com | Listed website |
| `industry` | Technology, Information and Internet | |
| `companySize` | 5,001-10,000 employees | Size band as shown |
| `employeeCountMin`, `employeeCountMax` | 5001, 10000 | Numeric size band |
| `employeesOnLinkedIn` | 16694 | Members who list this employer |
| `followers` | 1765821 | |
| `headquarters` | South San Francisco, CA | |
| `address` | `{street, city, region, postalCode, country}` | Structured HQ address |
| `organizationType` | Privately Held | |
| `foundedYear` | 2010 | When listed |
| `specialties` | \["Payments", ...] | When listed |
| `logoUrl`, `coverImageUrl` | | Image URLs |
| `jobsUrl` | | Public job search for this company |
| `locations`, `locationsCount` | `[{isPrimary, address, lines}]` | Every listed office |
| `similarPages` | `[{name, url, industry, location}]` | Lookalike companies |
| `affiliatedPages` | `[{name, url, industry, location}]` | Subsidiaries, showcase pages |
| `recentPosts`, `recentPostsCount`, `lastPostAt` | `[{postUrl, publishedAt, text, likes, comments, mediaType, imageUrls, isReshare, articleUrl}]` | Latest public posts |
| `otherMatches` | `[{name, linkedinUrl, followers}]` | Other pages with the same name (name lookups only) |
| `matchedBy` | website, name | How a name or domain input was matched: the page lists that website, or (domain inputs) the page name equals the domain's brand when the listed website differs |
| `input`, `inputType`, `status`, `scrapedAt` | stripe, slug, ok | Traceability. `status` is `ok`, `not_found` or `blocked` |
The dataset has three views: **Overview**, **Firmographics for CRM**, and **Recent posts** (one row per post).
### Pricing
| Event | Price | When |
|---|---|---|
| `company-scraped` | $0.0028 | Once per company delivered |
1,000 companies cost about $2.80. Not-found, blocked and duplicate inputs are never charged. Set **Maximum cost per run** in the run options and the actor stops cleanly when it is reached.
### How to run
#### API
```bash
curl -X POST "https://api.apify.com/v2/acts/transparent_meteorite~linkedin-company-scraper/run-sync-get-dataset-items?token=YOUR_TOKEN" \
-H "Content-Type: application/json" \
-d '{"companies":["stripe.com","hubspot"]}'
```
#### Python
```python
from apify_client import ApifyClient
client = ApifyClient("YOUR_TOKEN")
run = client.actor("transparent_meteorite/linkedin-company-scraper").call(run_input={"companies": ["stripe.com", "hubspot"]})
for row in client.dataset(run["defaultDatasetId"]).iterate_items():
print(row["name"], row["industry"], row["employeesOnLinkedIn"])
```
#### n8n, Make, Zapier and MCP
- **n8n:** Apify node, "Run actor and get dataset", actor `transparent_meteorite/linkedin-company-scraper`.
- **Make:** Apify module "Run an Actor", then "Get Dataset Items".
- **Zapier:** Apify app, action "Run Actor", then send rows to Google Sheets or your CRM.
- **AI agents (MCP):** add the Apify MCP server (`https://mcp.apify.com`) with this actor enabled, then ask, for example, "get LinkedIn industry, size and HQ for stripe.com and hubspot.com".
### Limits and honest caveats
- **Public company pages only.** No people profiles, employee lists, emails or phone numbers. People profile URLs are skipped with a warning.
- **No company keyword search.** LinkedIn only offers company search to logged-in members, so this actor does not do it. Give it names or domains instead; we resolve them to pages.
- **Name lookups are best effort.** We try common slug patterns (`notion`, `notionhq`, `notion-inc` and so on) and keep exact name matches. Unusual slugs may come back `not_found` (free); use the URL or website domain for those.
- **Fields only appear when the company lists them.** Microsoft lists no founded year, Stripe lists no specialties.
- **Posts:** the public page shows up to 10 recent posts. For more posts, keyword search and full comments, see LinkedIn Posts Search from the same publisher.
- **Counts** (followers, employees) are what the public page shows at run time.
### Use cases
- **CRM and account enrichment.** A sales or RevOps team has a list of domains and needs industry, size band, headquarters and the LinkedIn URL on every account. Paste the domains, export CSV, and map `industry`, `employeeCountMin`, `employeeCountMax` and `headquarters` to CRM fields. The "Firmographics for CRM" view is laid out for this.
- **Territory and segment building.** Filter the output by `companySize`, `industry` or `address.country` to split a list of accounts by segment before an outbound campaign.
- **Lookalike lists.** `similarPages` returns the companies LinkedIn itself groups with the one you looked up, with name, URL, industry and location. Feed those URLs back into the actor to grow a list one step outward.
- **Competitor tracking.** Schedule the actor weekly on a fixed set of competitors and compare `followers`, `employeesOnLinkedIn` and `lastPostAt` between runs to see growth and posting activity.
- **Recruiting research.** `employeesOnLinkedIn`, `locations` and `jobsUrl` show how large an employer looks on LinkedIn, where its offices are, and where its public job search lives.
- **Investor and analyst screening.** `foundedYear`, `organizationType`, `specialties` and `description` give a quick company card for a watch list.
### Input guide
The fields are listed in the Input table above. This section covers how they behave.
- **`companies`** accepts four kinds of value in the same list, so a mixed export can be pasted as it is: a company URL, a slug, a company name, or a website domain. Each line is classified automatically and the result is reported in `inputType`.
- **`startUrls`** exists for tools that can only send a URL list. Its entries are treated exactly like entries in `companies`.
- **`domains`** is the same lookup restricted to website domains. A page is returned only when the website it lists matches the domain, or, as a fallback, when the page name equals the brand of the domain. The `matchedBy` field says which rule applied.
- **`maxPostsPerCompany`** ranges from 0 to 10. The public page shows at most 10 recent posts, so 10 is the real ceiling. Use 0 when posts are not needed; the row is smaller and the **Recent posts** view stays empty.
- **`includeLocations`, `includeSimilarPages`, `includeAffiliatedPages`** switch whole sections of the row on or off. Turning all three off gives a compact row suited to CRM import.
- **`includeNotFound`** adds a row with status `not_found` or `blocked` and the slugs that were tried (`slugsTried`), so a missed input can be traced instead of silently disappearing. These rows are never charged.
- **`maxCompanies`** stops the run after that many inputs, from 1 to 10,000. Use a small number for a first test on a new list.
- **`maxConcurrency`** is the number of pages fetched at once, from 1 to 10. If the log shows sign-in-wall warnings, lower it before changing anything else.
- **`proxyConfiguration`** uses Apify Proxy by default. Switch the proxy group to RESIDENTIAL only if a run reports sign-in walls for many inputs.
### Worked examples
**Enrich a list of domains**
```json
{
"companies": ["stripe.com", "hubspot.com", "notion.so"],
"maxPostsPerCompany": 0,
"includeSimilarPages": false,
"includeAffiliatedPages": false
}
```
**Build a lookalike seed list**
```json
{
"companies": ["https://www.linkedin.com/company/hubspot"],
"maxPostsPerCompany": 0,
"includeLocations": false,
"includeAffiliatedPages": false,
"includeSimilarPages": true
}
```
**Check what a competitor is posting**
```json
{
"companies": ["stripe"],
"maxPostsPerCompany": 10,
"includeLocations": false,
"includeSimilarPages": false
}
```
### Sample output record
An abbreviated row for a slug input. Real rows contain every field the company lists on its page; the values below are shortened.
```json
{
"input": "stripe",
"inputType": "slug",
"status": "ok",
"name": "Stripe",
"linkedinUrl": "https://www.linkedin.com/company/stripe",
"universalName": "stripe",
"pageType": "company",
"website": "https://stripe.com",
"websiteDomain": "stripe.com",
"industry": "Technology, Information and Internet",
"companySize": "5,001-10,000 employees",
"employeeCountMin": 5001,
"employeeCountMax": 10000,
"employeesOnLinkedIn": 16694,
"headquarters": "South San Francisco, CA",
"organizationType": "Privately Held",
"foundedYear": 2010,
"scrapedAt": "2026-10-13T12:00:00.000Z"
}
```
### Reading the status field
- **`ok`** means the public page was found and parsed. The row is delivered and counted for billing.
- **`not_found`** means no public page matched the input, for example a misspelled slug or a name with no matching page. The row is free.
- **`blocked`** means LinkedIn showed a sign-in wall on every attempt. The row is free. Re-run just those inputs with a lower `maxConcurrency` or a RESIDENTIAL proxy group.
### Tips to reduce cost and runtime
- Prefer a URL or domain over a bare name. Names need several slug guesses, and a domain resolves to the page that lists that website.
- Turn off `maxPostsPerCompany`, similar pages and affiliated pages when only firmographics matter. Rows are smaller and downstream imports are simpler.
- Deduplicate the list before running. Duplicate inputs are not charged.
- Run a 10-company sample before a large list and check the share of `not_found` rows. A high share usually means names that need to be replaced by domains.
- Split very large lists into several runs of a few thousand companies, so a failed batch is cheap to repeat.
### Additional questions
**What does the actor do with a LinkedIn people URL?** It skips it and logs a warning. Only company, showcase and school pages are supported.
**Does it return employee names or emails?** No. Only the company page is read, and it carries no employee list or contact details.
**Which countries are supported?** Company URLs on country subdomains (for example `de.linkedin.com`) are accepted.
**What is the difference between `companySize` and `employeesOnLinkedIn`?** `companySize` is the band the company selected, for example 5,001-10,000. `employeesOnLinkedIn` is the number of LinkedIn members who list the company as their employer. The two often differ.
**Why are some fields empty for a company?** A field is filled only when the company lists it on its page. An empty `foundedYear` or `specialties` means the page does not show one.
**Can I pass several pages with the same name?** For name inputs, the page with the most followers is returned and the others appear in `otherMatches`. Pass the exact URL to pick a specific page.
**How do I load the results into a spreadsheet?** Export the dataset as CSV or Excel from the Output tab, or fetch it from the dataset API in the format you need. Use JSON when you need nested lists such as `locations` and `similarPages` kept structured.
### FAQ
**Do I need a LinkedIn account or cookies?** No. Nothing is logged in, and no account of yours is used.
**Is it legal to scrape LinkedIn company pages?** This actor reads only public, logged-out company pages (business information companies publish about themselves). It collects no personal profiles. You are responsible for how you use the data under your local law and LinkedIn's terms.
**Why did a company come back `blocked`?** LinkedIn sometimes shows a sign-in wall instead of the public page. The actor retries on fresh IPs; anything still blocked is free. Re-run those inputs or set the proxy group to RESIDENTIAL.
**Can I find a company's LinkedIn page from its website?** Yes. Put the domain (`acme.com`) in `companies` or `domains`. We return the page that lists that website. If none does, we fall back to the page whose name matches the domain's brand (figma.com to Figma) and mark it `matchedBy: "name"` so you can review it.
**How fast is it?** About 1-2 seconds per company at the default 4 in parallel; 1,000 companies take roughly 10 minutes.
**Can I schedule it?** Yes. Save a task with your list and add a schedule to track followers and new posts over time.
### Support
Found a bug or need a field? Open an issue on the **Issues** tab with your run URL. We reply there.
New to Apify? [Create a free account](https://console.apify.com/sign-up?fpr=rnmakg) and run this Actor in under a minute. Some links are affiliate links.
# Actor input Schema
## `companies` (type: `array`):
One per line. Any of: a LinkedIn company URL (https://www.linkedin.com/company/stripe, also /about/, /posts/, country subdomains, /showcase/ and /school/ pages), a slug (stripe), a company name (Stripe), or a website domain (stripe.com). Names and domains are matched to the page whose name or website matches; anything we cannot match is returned free with status not_found.
## `startUrls` (type: `array`):
Same as Companies, for tools that pass a URL list. Paste LinkedIn company page URLs.
## `domains` (type: `array`):
Find a company's LinkedIn page from its website, e.g. hubspot.com. Only pages whose listed website matches the domain are returned.
## `maxPostsPerCompany` (type: `integer`):
How many of the company's latest public posts to include (text, date, likes, comments, media). LinkedIn's public page shows up to 10. 0 = no posts.
## `includeLocations` (type: `boolean`):
Every address listed on the page (the public page shows them all, not just HQ).
## `includeSimilarPages` (type: `boolean`):
LinkedIn's 'Similar pages' list: name, URL, industry and location. Handy for building lookalike lists.
## `includeAffiliatedPages` (type: `boolean`):
Subsidiaries and showcase pages linked from the company page.
## `includeNotFound` (type: `boolean`):
Adds a free row with status not_found for each input we could not match, so you can see what was missed. Never charged.
## `maxCompanies` (type: `integer`):
Stop after this many inputs.
## `maxConcurrency` (type: `integer`):
Pages fetched at once. Lower it if you see sign-in-wall warnings.
## `proxyConfiguration` (type: `object`):
Apify Proxy (datacenter) is enough for public company pages. Switch to RESIDENTIAL only if a run reports sign-in walls.
## Actor input object example
```json
{
"companies": [
"https://www.linkedin.com/company/hubspot",
"https://www.linkedin.com/company/stripe"
],
"maxPostsPerCompany": 5,
"includeLocations": true,
"includeSimilarPages": true,
"includeAffiliatedPages": true,
"includeNotFound": true,
"maxCompanies": 1000,
"maxConcurrency": 4,
"proxyConfiguration": {
"useApifyProxy": true
}
}
```
# Actor output Schema
## `overview` (type: `string`):
No description
## `posts` (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 '' with your token
const client = new ApifyClient({
token: '',
});
// Prepare Actor input
const input = {
"companies": [
"https://www.linkedin.com/company/hubspot",
"https://www.linkedin.com/company/stripe"
],
"proxyConfiguration": {
"useApifyProxy": true
}
};
// Run the Actor and wait for it to finish
const run = await client.actor("transparent_meteorite/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 '' with your token.
client = ApifyClient("")
# Prepare the Actor input
run_input = {
"companies": [
"https://www.linkedin.com/company/hubspot",
"https://www.linkedin.com/company/stripe",
],
"proxyConfiguration": { "useApifyProxy": True },
}
# Run the Actor and wait for it to finish
run = client.actor("transparent_meteorite/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/hubspot",
"https://www.linkedin.com/company/stripe"
],
"proxyConfiguration": {
"useApifyProxy": true
}
}' |
apify call transparent_meteorite/linkedin-company-scraper --silent --output-dataset
```
## MCP server setup
```json
{
"mcpServers": {
"apify": {
"type": "http",
"url": "https://mcp.apify.com/?tools=fetch-actor-details,transparent_meteorite/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 ` 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/yVYB33dk7KyUPodl3/builds/bg8znxyxMWhhfjSQB/openapi.json