LinkedIn Company Scraper 🔗

foXLabs LinkedIn series: Company 360 · Jobs · Hiring signals · Ad tracker · Ad discovery

🎉 Turn public LinkedIn company pages into clean, structured data — no login, no API key, one row per company, with industry, size, headquarters, followers and specialties. Built for B2B sales, recruiting and competitive intelligence.

🔍 What is the LinkedIn Company Scraper — and when should you use it?

Give this actor LinkedIn company URLs or handles and it returns one row per company from its public LinkedIn page — as clean, deduplicated rows you can filter, export or feed to an AI agent. A plain company name also works as a best-effort guess (see Input below). Every run reads the source live.

Use it when you need: a company list for outreach; a quick profile before a call; or a starting point for account research.

Use something else when: you need the official registry filing — this is a LinkedIn profile, not a government registry.

🤖 Use with AI agents

Already on the Apify MCP server? Ask for this Actor by name: foxlabs/linkedin-company-scraper.

Your agent can pay for its own runs. This Actor is pay-per-event with agentic payments, so an agent can discover it, run it and settle the bill over x402 (USDC on Base) or Skyfire — no Apify account or API token of its own. Billing is the same either way: per delivered record, never for errors.

Otherwise paste this into Claude, ChatGPT, Cursor or any MCP-enabled assistant:

I want to pull company records using the Apify Actor `foxlabs/linkedin-company-scraper`.
Input: `companies` is a list of LinkedIn company URLs or handles (required; a plain company name is only a best-effort guess); `maxResults` caps how many companies are returned; `includeJobCount` and `includeOwnership` toggle the extra lookups.
Start with: {"companies":["microsoft","https://www.linkedin.com/company/stripe/"],"maxResults":1000}
Ask me what to look up, run the Actor, then summarise the rows as a table.

The machine-readable API, MCP config and OpenAPI definition live at apify.com/foxlabs/linkedin-company-scraper.md.

📋 Overview

Everything you need to turn public LinkedIn company pages into clean, structured data — in one actor, with no login, cookies or API key.

Why teams pick this actor:

• ✅ Many companies, one call — paste LinkedIn company URLs or handles, get one clean row per company.
• 🧹 No empty-promise columns — only fields LinkedIn actually fills; degenerate columns are removed.
• 🔗 Stable identifiers — every row carries the LinkedIn handle (slug) and URL, ready to join across runs and to other Fox Labs actors.
• 💰 Per-row pricing — a minimal price per delivered row, no subscription.
• 🤖 Agent-ready — MCP + x402 agentic payments.

✨ Features

• 🔍 URL or handle lookup — reads the company page you point to. A plain company name is turned into LinkedIn's usual handle and kept only if the page's name matches; matchedBy on every row says how the page was found.
• 🏢 Firmographic profile — industry, size band, exact LinkedIn member count, followers, HQ address, website, specialties, founded year and open-jobs count.
• 🧹 Clean schema — deduplicated camelCase rows, ready for CSV/Excel/JSON.

🎬 Quick Start

curl -X POST "https://api.apify.com/v2/acts/foxlabs~linkedin-company-scraper/runs?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"companies":["microsoft","https://www.linkedin.com/company/stripe/"],"maxResults":1000}'

🚀 Getting Started (3 steps)

1. Choose your targets — LinkedIn company URLs or handles (a plain name works as a best-effort guess).
2. Set the cap — maxResults limits how many companies are returned (default 1000).
3. Run and export — get a clean dataset as JSON, CSV or Excel.

📥 Input

{"companies":["microsoft","https://www.linkedin.com/company/stripe/"],"maxResults":1000}

Field	Type	Description
companies	array	Required. LinkedIn company URLs or handles, one per line; a line with several comma-separated companies is split. A plain company name is a best-effort guess: it becomes LinkedIn's usual handle (Goldman Sachs → goldman-sachs) and the row is kept only if the page's name matches. The URL is the surest input.
maxResults	integer	Most companies returned in one run (default 1000).
includeJobCount	boolean	Also fetch the number of open roles on the company page (default on).
includeOwnership	boolean	Also resolve parent / affiliated companies (default on).
proxyConfiguration	object	Apify proxy settings (default: Apify proxy, automatic selection).

Not looked up — these lines are listed in FAILED_LOOKUPS with the reason, no request is sent and nothing is charged: numeric company IDs (linkedin.com/company/1035), Sales Navigator links, person profiles (/in/), school (/school/) and showcase (/showcase/) pages, website URLs (https://…, www.…), empty lines, lines without Latin letters, and URLs with a broken %-encoding. A bare domain such as booking.com is tried once as a handle, because some companies use one (Booking.com does).

Run time and big lists — companies are read one after another: about 4–6 seconds each with the default options (measured 2026-10-02: median 4.2 s, mean 5.9 s per company) and about 2–3 seconds with includeJobCount and includeOwnership off. The default 1-hour run timeout therefore fits roughly 600–850 companies; for a longer list raise the timeout in the run options (about 2 hours per 1,000 companies). About 45 seconds before the timeout the actor stops by itself, keeps every row it delivered and lists the companies it did not reach in the UNPROCESSED key-value record — paste them into a new run.

📤 Output

One row per company, saved to the dataset. Every row carries scrapedAtIso and matchedBy. Lines that do not lead to a company are reported in the run log and in the FAILED_LOOKUPS record in the key-value store (input exactly as you gave it, handle tried, linkedinUrl, reason, cause, httpStatus) — they are not written to the dataset, so no result is charged for them (from 17 October 2026 a line that was looked up costs the $0.0005 lookup fee — see Pricing).

How a run ends. If at least one company is delivered, the run succeeds. If nothing could be delivered because of the input (no public page under that handle, a name whose page belongs to another organisation, an unsupported line), the run still ends SUCCEEDED, its status message names the reasons and FAILED_LOOKUPS lists every line — no result is charged (from 17 October 2026 each company that was looked up costs the $0.0005 lookup fee). It ends FAILED only when nothing was delivered and LinkedIn could not be reached or read (cause: actor: network errors, HTTP 429/5xx, HTTP 999 on several handles, a page that loaded without company data).

Field	Description
slug	Slug
linkedinUrl	Linkedin Url
matchedBy	How the page was found: url, handle or name-guess (a company name turned into a handle and kept because the page's name matches)
name	Name
website	Website
websiteHost	Website Host
websiteUrl	Website Url
industry	Industry sector as shown on the source — not a NACE or SIC code
companyType	Company Type
companySize	Company Size
specialties	Specialties
specialtiesText	Specialties Text
description	Description
about	About
employeeCount	Employee Count
employeeCountFormatted	Employee Count Formatted
employeeCountCompact	Employee Count Compact
companySizeBucket	Company Size Bucket
companySizeBucketSource	Company Size Bucket Source
followers	Followers
followersCompact	Followers Compact
jobsSearchUrl	Jobs Search Url
addressStreet	Address Street
addressLocality	Address Locality
addressRegion	Address Region
addressPostalCode	Address Postal Code
addressCountry	Address Country
headquarters	Headquarters
logoUrl	Logo Url
source	Source
sourceCountry	Source Country
jobCount	Job Count
jobCountText	Job Count Text
jobCountIsLowerBound	Job Count Is Lower Bound
scrapedAtIso	Scraped At Iso
founded	Founded
slogan	Slogan

💼 Use cases

1. Account research — profile target companies from LinkedIn. Input: company URLs or handles. Output: industry + size + HQ. Use: an account brief.

2. List enrichment — attach LinkedIn firmographics to a list. Input: company URLs. Output: firmographics + followers. Use: an enriched list.

3. Competitive intel — track competitors’ size and growth signals. Input: company URLs. Output: size + followers. Use: a competitor sheet.

🔗 Integration

JavaScript / Node.js

import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: 'YOUR_TOKEN' });
const run = await client.actor('foxlabs/linkedin-company-scraper').call({"companies":["microsoft","https://www.linkedin.com/company/stripe/"],"maxResults":1000});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items[0]);

Python

from apify_client import ApifyClient
client = ApifyClient('YOUR_TOKEN')
run = client.actor('foxlabs/linkedin-company-scraper').call(run_input={"companies":["microsoft","https://www.linkedin.com/company/stripe/"],"maxResults":1000})
for item in client.dataset(run['defaultDatasetId']).iterate_items():
    print(item)

Automation (n8n / Zapier / Make): schedule or webhook → HTTP request to the actor API with your input list → handle the JSON dataset → push to a sheet, CRM or dashboard.

📊 Pricing

Pay-per-event.

Until 16 October 2026: $0.004 per row written to the dataset (one row = one delivered company). Lookups that fail are not written to the dataset — they go to the run log and the FAILED_LOOKUPS record in the key-value store — so they are not charged. A run that delivers nothing costs only the Actor-start event.

From 17 October 2026 (15:00 UTC): a delivered company costs the same $0.004, now split into a $0.0005 company-lookup and a $0.0035 result row. A company you asked for that we looked up and that is certainly not deliverable because of the input — no public page under that handle (HTTP 404) or a name whose page belongs to another organisation — costs only the $0.0005 lookup: finding that out still takes a request. A handle LinkedIn refuses (HTTP 999) stays free, because it can also be LinkedIn blocking us. Lines that are never looked up (empty, numeric IDs, Sales Navigator / person / school / showcase links, website URLs, broken links), inputs not reached before the run timeout, and failures on our side (LinkedIn unreachable or blocking) stay free. Apify notifies users of the change in advance.

❓ FAQ

Do I need an account, login or API key? No. This reads public LinkedIn company pages.

What do I search by? LinkedIn company URLs or handles. A plain company name is a best-effort guess: it becomes LinkedIn's usual handle and the row is kept only if the page's name matches. There is no name search and no numeric-ID lookup.

My run succeeded with 0 rows — why? Nothing in the input led to a public LinkedIn company page. The status message names the reasons and the FAILED_LOOKUPS record lists every line; no result was charged (from 17 October 2026 each company that was looked up costs the $0.0005 lookup fee).

When does a run fail? Only when nothing was delivered and LinkedIn could not be reached or read (network errors, HTTP 429/5xx, HTTP 999 on several handles, pages without company data). Try again later.

How current is the data? Every run reads public LinkedIn company pages live, so results are as current as the source.

What company fields are returned? Industry, company size, headquarters, follower count, specialties and links from the public LinkedIn page.

Can I export to CSV / Excel / JSON? Yes — directly from the Apify dataset.

🐛 Troubleshooting

• Fewer rows than expected — raise maxResults, or refine the input.
• A name returns the wrong company — a page whose name matches can still be a namesake (a small page with the same name). Rows found from a name carry matchedBy: name-guess; paste the company's LinkedIn URL to be sure.
• No row for a name — its guessed handle has no public LinkedIn page, or the page there belongs to another organisation (see FAILED_LOOKUPS); open the company on LinkedIn and paste its URL.
• The run stopped before the end — it reached the run timeout; the companies it did not reach are in the UNPROCESSED record. Re-run them or raise the timeout (see Run time and big lists).

⚖️ Is it legal to scrape this data?

This actor reads publicly available LinkedIn company-page data. Results can still contain personal data (e.g. a person’s name); personal data is protected by the GDPR and similar laws, so only process it with a legitimate basis. See Apify’s blog post on the legality of web scraping.

🤝 Support & contact

• 🌐 Website: data.foxlabs.com.tr
• 📧 Email: info@foxlabs.com.tr
• 🐛 Issues: open a ticket in the Actor’s Issues tab
• 🧰 More clean B2B data actors: Fox Labs on Apify

Changelog

0.2.22 — 2026-10-02 — lookup fee narrowed before it starts: HTTP 999 stays free

• The lookup fee announced in 0.2.21 (from 17 October 2026) will not apply to a handle LinkedIn refuses with HTTP 999 — that answer can also mean LinkedIn is blocking us, and failures on our side are free. Charged: delivered companies and handles that certainly lead nowhere (HTTP 404/410) or to another organisation's page.

0.2.21 — 2026-10-02 — lookup fee announced for 17 October 2026

• Pricing change from 17 October 2026 (15:00 UTC): every company looked up costs a $0.0005 company-lookup, and a delivered row drops from $0.004 to $0.0035 — a delivered company costs $0.004 as before. A company looked up but not delivered because of the input (HTTP 404, another organisation's page, a refused handle) costs only the $0.0005 lookup. Lines never looked up, inputs not reached before the timeout and failures on our side stay free. The code is live now and charges nothing extra until the new price takes effect.

0.2.20 — 2026-10-02 — clear reasons instead of failed runs; names checked; no crash on one bad line

• A run that delivers nothing because of the input now ends SUCCEEDED (since 0.2.19 it ended FAILED), with a status message that names the reasons and every line in FAILED_LOOKUPS; nothing is charged per company. It ends FAILED only when nothing was delivered and LinkedIn could not be reached or read (network errors, HTTP 429/5xx, HTTP 999 on several handles, a page that loaded without company data).
• Names are checked. A company name is still turned into LinkedIn's usual handle, but the row is kept only if the page's name matches the name you typed; otherwise the line goes to FAILED_LOOKUPS ("belongs to a different organisation") and is not charged. Before this fix "Arçelik" returned a 1-employee page called "karbank" and was charged. Turkish ı and ß, ø, ł, æ are now transliterated (Yapı Kredi is guessed as yapi-kredi, no longer yap-kredi).
• New output field matchedBy on every row: url, handle or name-guess.
• Lines that cannot work are reported, not looked up or silently dropped: numeric company IDs, Sales Navigator links, person / school / showcase pages, website URLs, empty lines and lines without Latin letters — each is listed in FAILED_LOOKUPS with the reason, without a request. Empty and non-Latin lines used to vanish without a trace. A line with several comma-separated companies is now split (a legal form such as ", Inc." is not split off).
• One broken URL no longer fails the whole run. A malformed %-sequence used to stop every run it appeared in with "URI malformed", even when the other companies were fine.
• Dead lines fail fast. A page that does not exist (HTTP 404) is no longer retried (it was retried 5 times, 2–29 s per line); HTTP 999 is tried at most twice. Ownership lookups give up after 15 s.
• Nothing is lost at the timeout. FAILED_LOOKUPS is saved at least every 10 s while the run goes on and always before it ends, and about 45 s before the run timeout the actor stops on its own, keeps what it delivered and lists the companies it did not reach in the new UNPROCESSED record.
• { "url": "…" } entries are read. Request-list objects sent through the API are taken as their URL instead of being rejected.
• FAILED_LOOKUPS entries changed: input is now the line exactly as you gave it (it was the handle); the handle that was tried is in handle; new fields cause (input or actor) and httpStatus.
• README: removed "relevance-ranked name search or exact registry-ID lookup" and the registry-style profile claims (status, legal form, formation date) — the actor never did either; added run-time guidance for big lists. scrapedAt corrected to scrapedAtIso.

0.2.19 — 2026-09-29 — failed lookups are no longer charged; names work

• Billing fix. A lookup that could not be read (for example a handle with no public page) was written to the dataset as an error row — and, because pricing is per dataset row, charged like a company. That contradicted this README, which since 0.2.18 said failed lookups are never charged. They now go only to the run log and the FAILED_LOOKUPS record in the key-value store, and are not charged. Price per delivered company is unchanged.
• Company names are accepted. A line like Goldman Sachs used to be rejected, and a list made only of names failed the whole run with "No valid companies". A name is now turned into LinkedIn's usual handle (goldman-sachs); if that page does not exist, the lookup is listed in FAILED_LOOKUPS.
• A run that delivers nothing ends as failed, with the reasons in its status message, instead of succeeding with only error rows.

0.2.18 — 2026-09-20 — README corrected against the real input schema

• Every code example was broken. The AI-agent, cURL, JavaScript and Python examples used keys that do not exist in this Actor's input schema (queries, maxResultsPerQuery) with a literal placeholder string instead of a real value, and the input table listed those phantom fields instead of the real ones. Anyone who copied an example got a failing run. All examples now match the schema prefill exactly.
• Removed promises the Actor does not keep: "formation / status monitoring", "a canonical registry record for KYB and due diligence", and "every row carries query" (there is no query field). Fixed a duplicated word in the intro.
• Billing wording corrected. The README said "empty/failed lookups are never billed" without saying why. Failed lookups are not written to the dataset at all — they are reported in the run log and in the FAILED_LOOKUPS record in the key-value store — so there is no row to charge. Stated plainly instead of implied.
• No code, output field or pricing change.

0.2 — 2026-09-07

• Enabled AI-agent payments (x402) + rebuilt the README to the full standard (What-is / when, AI-agents + x402 agentic payments + MCP, Overview, Features, Use cases, Integration, FAQ, Troubleshooting, Support & contact).

0.0

• Initial release: data from public LinkedIn company pages by name or registry ID.