LinkedIn Company About Scraper : Similar Companies & Affiliates

LinkedIn Company Scraper — Profiles, Similar Companies & Affiliates

LinkedIn Company About Scraper : Similar Companies & Affiliates turns a company's public LinkedIn About page into a single typed JSON row containing its full company profile, the "Similar pages" carousel, the "Affiliated pages" module (sibling companies plus Showcase pages), and a recent-posts preview — all from one page fetch, with zero extra requests. Unlike scraping frameworks that return raw HTML, this Actor returns typed JSON — ready for your model, your database, or your pipeline without any parsing. This guide covers every input and output field plus how teams deploy it for enrichment, monitoring, and bulk research.

🧭 What Does LinkedIn Company About Scraper : Similar Companies & Affiliates Do?

This Actor fetches a LinkedIn company's public About page and extracts three kinds of data from that single page load: the company's own profile fields, its on-page company network (similar companies plus affiliated companies and Showcase pages), and a preview of its most recent posts. It runs against LinkedIn's guest-visible pages — no LinkedIn account, login, or cookies are required, since the fetch uses a headless Chromium browser rather than an authenticated session. Capabilities:

• Resolves the "Similar pages" carousel into real company names and LinkedIn URLs (similar_companies)
• Resolves the "Affiliated pages" module into sibling/parent-group companies (affiliated_companies) and Showcase pages (affiliated_showcases) separately
• Extracts core firmographic fields: name, website, industry, employee-count range, headquarters, and description
• Extracts the numeric LinkedIn organization ID (company_urn) and a ready-to-use jobs-search deep link (jobs_search_url)
• Pulls a recent-activity/posts preview (recent_posts) embedded in the page's own structured data
• Caps each network list and the posts list independently, or returns everything the page renders
• Falls back to a residential proxy automatically if LinkedIn blocks the initial request

⚡ Features & Capabilities

The Actor's capabilities split into the core extraction logic and where it sits relative to the rest of the Scrapio LinkedIn lineup.

Core features

• Single-fetch company network resolution — similar_companies, affiliated_companies, and affiliated_showcases are all parsed out of the same About-page HTML the profile fields come from; no second request per company.
• Structured firmographic fields — company_name, domain, category, number_employees, associated_members, location, description are parsed from meta tags, JSON-LD, and page text with multiple fallback patterns each.
• Stable company identifier — company_urn (the numeric urn:li:organization:<id>) and a derived jobs_search_url for every successfully scraped company.
• Recent-posts preview — recent_posts reads DiscussionForumPosting nodes from the page's own ld+json @graph, kept as its own list separate from the network fields.
• Independent per-type caps — maxNetworkItemsPerType and maxRecentPosts cap each list independently, or 0 for however much the guest page renders.
• Consistent row shape on failure — a blocked or 404 company still returns every key (network and post fields empty), so downstream code never has to branch on which fields exist.
• Automatic residential proxy fallback — a 403/429/999 response triggers one automatic retry on a residential proxy before the row is marked failed.
• Backward-compatible input keys — startUrls, maxRetries, and requestDelay (the base Actor's original field names) are still read as fallbacks alongside the renamed companyProfileUrls, fetchRetryLimit, and requestPaceSeconds.

LinkedIn Company About Scraper : Similar Companies & Affiliates within the Scrapio data stack

This Actor covers company profiles plus each company's on-page network and recent posts. For employee-level contact cards at a given company, use LinkedIn Company Employees Scraper : Public Contact Info. For business email and phone discovery tied to LinkedIn profiles, use LinkedIn B2B Emails Scraper By Phone & Email Finder. For per-post reaction/comment/engagement analytics on a company page over time, use LinkedIn Scraper: Posts, Reactions, Comments & Engagement. For expanding an individual's own "People also viewed" network, use LinkedIn Profile Scraper By Similar Profile Finder.

Why do developers and data teams scrape LinkedIn?

LinkedIn's company pages are one of the few sources that combine self-reported firmographics with a platform-curated map of adjacent companies. The audiences below are the ones that genuinely use this kind of data.

🏢 Company and firmographic research

Sales, RevOps, and GTM teams feed a list of companyProfileUrls into a run to build or refresh an account database: category, number_employees, location, and domain populate firmographic fields, while similar_companies and affiliated_companies expand a single target account into a list of lookalike and sibling-company URLs for further prospecting. The output lands as one row per company, ready to join against a CRM on linkedin_url or domain.

📊 AI training data and RAG indexing

description, category, and the text field inside each recent_posts entry are the highest-information text fields for this entity — they carry the free-text detail a model needs to answer questions about what a company does and what it has recently talked about. For RAG, index description and recent_posts[].text per company so retrieval can surface a company's own words. For training data, number_employees, associated_members, and the _count fields (similar_companies_count, affiliated_companies_count, network_total_count) are structurally consistent across every row, making them reliable numeric features without per-row cleanup.

📱 Competitive and market intelligence

Re-running the Actor against a fixed watchlist of companyProfileUrls on a schedule lets a team track network_total_count, affiliated_showcases, and recent_posts over time — a new Showcase page appearing in affiliated_showcases, or a jump in recent_posts_count, signals a sub-brand launch or a change in posting activity worth a closer look.

🔬 Research and academic use

Researchers building a dataset of company-to-company relationships (similar-company graphs, parent/subsidiary structures via affiliated_companies) can use this Actor to construct a network dataset from publicly accessible pages, scoped strictly to what LinkedIn's guest view already renders.

🎥 Product and SaaS development

Teams building a firmographic enrichment API, a company directory product, or a competitor-monitoring dashboard can use this Actor as the ingestion layer: point it at a customer's domain-matched LinkedIn URL, store the returned row, and refresh it on whatever cadence the product needs.

🍚 Input Parameters

All parameters are optional — the Actor runs with defaults if only companyProfileUrls is supplied, and companyProfileUrls itself has no required: true flag in the schema (though an empty list means nothing is processed). Every parameter below is read directly from .actor/actor.json, in schema order:

Parameter	Required	Type	Description	Example Value
companyProfileUrls	No	array (stringList)	LinkedIn company URLs or bare usernames. The base Actor's original startUrls key is still accepted for backward compatibility.	["https://www.linkedin.com/company/microsoft", "google"]
includeSimilarCompanies	No	boolean	Resolve the "Similar pages" carousel into a similarCompanies list of real company names + LinkedIn URLs. Default: true.	true
includeAffiliatedCompanies	No	boolean	Resolve the "Affiliated pages" module into affiliatedCompanies (sibling/parent-group companies) and affiliatedShowcases (Showcase pages). Default: true.	true
maxNetworkItemsPerType	No	integer (min 0)	Cap entries kept per network list (similar / affiliated companies / affiliated showcases). LinkedIn's guest page renders at most ~10 per carousel anyway. 0 = unlimited. Default: 10.	10
includeRecentPosts	No	boolean	Extract the company's recent-activity/posts preview as its own recentPosts list, kept separate from the network lists. Default: true.	true
maxRecentPosts	No	integer (min 0)	Cap entries kept in recentPosts. LinkedIn's guest page embeds at most ~10. 0 = unlimited. Default: 10.	10
proxyConfiguration	No	object (proxy editor)	Choose which proxies to use. If LinkedIn rejects the proxy, a residential proxy is used as an automatic fallback.	{"useApifyProxy": false}
fetchRetryLimit	No	integer (0–10)	How many times to retry fetching a company's About page before giving up on it. The base Actor's maxRetries key still works too. Default: 3.	3
requestPaceSeconds	No	integer (0–30)	Base delay between company fetches (plus jitter) to keep pacing human-like. The base Actor's requestDelay key still works too. Default: 2.	2

Example input:

{
  "companyProfileUrls": [
    "https://www.linkedin.com/company/microsoft",
    "google"
  ],
  "includeSimilarCompanies": true,
  "includeAffiliatedCompanies": true,
  "maxNetworkItemsPerType": 10,
  "includeRecentPosts": true,
  "maxRecentPosts": 10,
  "proxyConfiguration": {
    "useApifyProxy": false
  },
  "fetchRetryLimit": 3,
  "requestPaceSeconds": 2
}

Supported URL types and input formats

companyProfileUrls (and its legacy alias startUrls) accepts three input shapes, normalized by the same to_company_url() function before any request is made:

1. Full company URL — https://www.linkedin.com/company/microsoft (any query string or trailing slash is stripped).
2. Bare username/slug — google, resolved to https://www.linkedin.com/company/google.
3. Partial path — company/openai or /company/openai/, with the company/ prefix stripped before the slug is re-assembled into a full URL.

Only the About page of a company is fetched; profile URLs (linkedin.com/in/...) and Showcase-page URLs (linkedin.com/showcase/...) are not valid inputs for this Actor.

📦 Output Format

Each run pushes one row per input company to the default dataset via Actor.push_data(result, charged_event_name="row_result"). Every row — success or failure — carries the same 21 keys, so downstream code never has to branch on which fields exist. Note that the row_result event is charged for every pushed row, including rows where success is false (a blocked or non-existent company page); filter on success == true after export if you only want to count or bill rows that returned real data.

Output for company profiles

{
  "company_name": "Microsoft",
  "linkedin_url": "https://www.linkedin.com/company/microsoft",
  "domain": "https://microsoft.com",
  "category": "Software Development",
  "number_employees": "10,001+ employees",
  "associated_members": "228,000",
  "location": "Redmond, Washington",
  "description": "Every company has a mission. What's ours? To empower every person and every organization on the planet to achieve more.",
  "company_urn": "1035",
  "jobs_search_url": "https://www.linkedin.com/jobs/search/?f_C=1035",
  "similar_companies": [
    { "name": "Google", "url": "https://www.linkedin.com/company/google" },
    { "name": "Amazon", "url": "https://www.linkedin.com/company/amazon" }
  ],
  "similar_companies_count": 2,
  "affiliated_companies": [
    { "name": "GitHub", "url": "https://www.linkedin.com/company/github" },
    { "name": "LinkedIn", "url": "https://www.linkedin.com/company/linkedin" }
  ],
  "affiliated_companies_count": 2,
  "affiliated_showcases": [
    { "name": "Microsoft Advertising", "url": "https://www.linkedin.com/showcase/microsoft-ads" },
    { "name": "Microsoft Learn", "url": "https://www.linkedin.com/showcase/microsoft-learn" }
  ],
  "affiliated_showcases_count": 2,
  "network_total_count": 6,
  "recent_posts": [
    {
      "url": "https://www.linkedin.com/posts/microsoft_activity-7123456789",
      "published_at": "2026-06-01T14:00:00.000Z",
      "text": "We're hiring across engineering, sales, and research — see open roles."
    }
  ],
  "recent_posts_count": 1,
  "success": true,
  "scraped_at": "2026-07-25T12:00:00.000000"
}

A failed fetch (blocked request or a genuine 404 on the company slug) still returns all 21 keys, with company_name, domain, category, number_employees, associated_members, location, and description as empty strings, every network/post list as [], every _count field as 0, success as false, and scraped_at set to the failure time.

Output for similar and affiliated companies

similar_companies, affiliated_companies, and affiliated_showcases share one nested item shape — { "name": string, "url": string } — resolved from the corresponding About-page section, or from a raw ?trk=similar-pages / ?trk=affiliated-pages link if a card didn't fully render (in which case name is left as an empty string rather than fabricated):

{ "name": "GitHub", "url": "https://www.linkedin.com/company/github" }

recent_posts entries use a separate shape — { "url": string, "published_at": string, "text": string } — read from the page's own DiscussionForumPosting structured-data nodes:

{
  "url": "https://www.linkedin.com/posts/microsoft_activity-7123456789",
  "published_at": "2026-06-01T14:00:00.000Z",
  "text": "We're hiring across engineering, sales, and research — see open roles."
}

Schema stability and export options

All 21 top-level keys are present on every row regardless of success, so a schema change on LinkedIn's front end degrades individual field values rather than removing keys from the row. The Actor pushes to the standard Apify dataset, which can be exported as JSON, CSV, Excel, HTML table, or RSS directly from the Apify Console or via the API — there is no separate export step to configure inside the Actor itself.

💡 LinkedIn Company About Scraper : Similar Companies & Affiliates Strategy Guide

🎯 Strategy 1: Real-time enrichment pipeline

Trigger a run whenever a new company record is created in your CRM or lead database. Pass that company's LinkedIn URL as the sole entry in companyProfileUrls, run the Actor, then read number_employees, category, domain, description, and similar_companies from the single returned row and write them back to the source record. Because every row carries the same keys whether the fetch succeeded or not, the write-back logic can check success once and skip the rest of the mapping on failure. This keeps a CRM's firmographic fields current without a human ever opening LinkedIn manually.

🎯 Strategy 2: Scheduled monitoring and alerting

The Actor itself has no built-in run-to-run diffing — each run is a fresh fetch. Use Apify's Schedule feature to trigger a run against a fixed watchlist of companyProfileUrls on a cron-style interval, store each run's dataset, and diff the current network_total_count, affiliated_showcases, and recent_posts_count against the previous run's values in your own code. Alert when a new entry appears in affiliated_showcases (a new sub-brand page) or when recent_posts_count jumps between runs.

🎯 Strategy 3: Bulk dataset build

Queue a large companyProfileUrls list in one run to build a research or firmographic dataset. The Actor processes company URLs sequentially within a single run, with a pacing delay (requestPaceSeconds) between fetches rather than fetching them in parallel — for large lists, either accept the sequential pace of one run or split the list across several concurrent Actor runs started via the Apify API. Either way, results land in the standard Apify dataset for export to CSV or JSON once complete, with similar_companies and affiliated_companies giving you a ready-made seed list for a second-pass run.

Strategy comparison at a glance

Strategy	Best for	Run pattern	Output format
Real-time enrichment	Appending firmographic data to a single new record	One Actor call per event, single-URL input	JSON row read via API
Scheduled monitoring	Tracking network/posting changes on a fixed watchlist	Scheduled run on a cron interval, external diffing	Dataset per run, diffed externally
Bulk dataset build	Building a firmographic or network research dataset	One run with a large URL list, or several parallel runs	CSV/JSON dataset export

🌴 Related LinkedIn Scrapers & Tools

Scraper Name	What it extracts
LinkedIn Company Employees Scraper : Public Contact Info	Employee contact cards (name, headline, public links) for a given company
LinkedIn B2B Emails Scraper By Phone & Email Finder	Business emails and phone numbers discovered from public LinkedIn profiles
LinkedIn Scraper: Posts, Reactions, Comments & Engagement	Per-post reactions, comments, media, and derived engagement analytics for a company page
LinkedIn Post Scraper By Keyword	Keyword and hashtag monitoring across LinkedIn company, profile, or post sources
LinkedIn Profile Scraper By Similar Profile Finder	"People also viewed" network expansion for individual LinkedIn profiles
Glassdoor Jobs Scraper : Employer Profile Details	Cross-platform employer profile data (CEO approval rating, HQ, awards) alongside open job listings

How to integrate LinkedIn Company About Scraper : Similar Companies & Affiliates with your stack

LinkedIn Company About Scraper : Similar Companies & Affiliates works with any language or tool that can call the Apify API — there is no separate REST API of its own outside the standard Apify run/dataset endpoints.

Python

import csv
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")

run_input = {
    "companyProfileUrls": [
        "https://www.linkedin.com/company/microsoft",
        "https://www.linkedin.com/company/google",
        "openai",
    ],
    "includeSimilarCompanies": True,
    "includeAffiliatedCompanies": True,
    "includeRecentPosts": True,
    "maxNetworkItemsPerType": 10,
}

run = client.actor("your-username/linkedin-company-about-scraper-similar-companies-affiliates").call(run_input=run_input)

rows = list(client.dataset(run["defaultDatasetId"]).iterate_items())

fieldnames = ["company_name", "linkedin_url", "domain", "category", "number_employees",
              "similar_companies_count", "affiliated_companies_count", "network_total_count", "success"]

with open("linkedin_companies.csv", "w", newline="", encoding="utf-8") as f:
    writer = csv.DictWriter(f, fieldnames=fieldnames)
    writer.writeheader()
    for row in rows:
        writer.writerow({k: row.get(k) for k in fieldnames})

print(f"Saved {len(rows)} rows to linkedin_companies.csv")

Node.js

import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: '<YOUR_APIFY_TOKEN>' });

const input = {
    companyProfileUrls: ['https://www.linkedin.com/company/microsoft', 'google'],
    includeSimilarCompanies: true,
    includeAffiliatedCompanies: true,
    includeRecentPosts: true,
};

const run = await client.actor('your-username/linkedin-company-about-scraper-similar-companies-affiliates').call(input);
const { items } = await client.dataset(run.defaultDatasetId).listItems();

for (const row of items) {
    console.log(row.company_name, row.category, row.similar_companies_count, row.affiliated_companies_count);
}

console.log(`Fetched ${items.length} rows`);

Async and scheduled pipelines

The Actor has no built-in webhook or scheduling logic of its own, so fire-and-forget large jobs by starting a run asynchronously via the API and polling client.run(runId).get() for status, or reading the dataset once the run finishes. For recurring monitoring, use Apify's Schedule feature to trigger runs on a cron-style interval against a fixed company list, and read each run's dataset via the API or Apify's run-finished webhooks configured at the platform level.

🎯 Who Needs LinkedIn Company About Scraper : Similar Companies & Affiliates? (Use Cases & Industries)

🏢 Company and firmographic research teams

A sales-ops analyst queues 500 target-account LinkedIn URLs, then uses category, number_employees, and domain to segment accounts by industry and size, and similar_companies to add adjacent lookalike accounts to the same outbound list.

📊 AI and ML teams

An AI team indexes description and recent_posts[].text into a vector store so a support or research agent can answer "what does this company do" questions grounded in the company's own public wording, and trains a firmographic classifier on category and number_employees — fields that stay structurally consistent across every company row.

📱 Competitive intelligence analysts

An analyst re-runs the Actor weekly against a competitor's LinkedIn URL and watches affiliated_showcases for new sub-brand launches and recent_posts_count for shifts in posting cadence, without needing a LinkedIn account of their own.

🔬 Researchers

Academic and market researchers building company-network datasets use similar_companies and affiliated_companies to construct a graph of publicly declared company relationships, scoped strictly to data LinkedIn's guest view already renders — no private or authenticated data is involved.

Is it legal to scrape LinkedIn?

Scraping publicly accessible LinkedIn pages is generally lawful in the United States: in hiQ Labs, Inc. v. LinkedIn Corp., the Ninth Circuit Court of Appeals held in 2019 (and reaffirmed on remand in 2022) that scraping data a website makes publicly available does not violate the Computer Fraud and Abuse Act. That precedent addresses one question — CFAA liability for accessing public data — and it does not resolve two separate ones. Violating LinkedIn's Terms of Service by scraping is a matter of civil contract risk between the scraper and LinkedIn, not a criminal one. Data protection law is largely not in play for this Actor's output: it returns company/business records (names, industry, network relationships) rather than personal data about individuals. LinkedIn Company About Scraper : Similar Companies & Affiliates returns only publicly accessible data. What you do with that data is your responsibility — consult legal counsel for commercial applications involving personal data.

❓ Frequently asked questions

Does LinkedIn Company About Scraper : Similar Companies & Affiliates work without a LinkedIn account?

Yes. The Actor fetches each company's guest-visible About page through a headless Chromium browser — no LinkedIn login, cookies, or session of any kind is used or required.

How does it handle LinkedIn's anti-scraping measures?

It fetches pages through a real Chromium browser (via Playwright) rather than a plain HTTP request, which reduces LinkedIn's HTTP 999 anti-bot responses. On a 403, 429, or 999 response it automatically retries once on a residential proxy, and retries the fetch up to fetchRetryLimit times (default 3) with an increasing delay between attempts.

Can I run it at scale without getting blocked?

The Actor paces requests with requestPaceSeconds (plus jitter) between company fetches and escalates to a residential proxy on a block, but there is no published uptime or success-rate guarantee. Company URLs within a run are processed sequentially, not in parallel, so very large lists take proportionally longer; splitting a large list across several concurrent runs is the documented way to add parallelism.

How fresh is the data it returns?

Every field is fetched live from LinkedIn's About page at run time — nothing is cached or served from a prior run. Re-run the Actor whenever you need current values.

What did hiQ Labs v. LinkedIn decide about scraping public LinkedIn data?

The Ninth Circuit ruled that accessing publicly available website data does not violate the Computer Fraud and Abuse Act, regardless of a cease-and-desist letter from the site owner. It did not rule on Terms of Service enforceability or on data protection obligations, which remain separate questions for anyone using the scraped data commercially.

Which fields work best for AI training and RAG indexing?

description and recent_posts[].text carry the richest free text for RAG retrieval. category, number_employees, and the _count fields (similar_companies_count, affiliated_companies_count, network_total_count) are the most structurally consistent fields for training features. Every field returns as a typed string, number, boolean, or list — no HTML parsing or normalization is needed before passing rows into an LLM context window.

Does it work with Claude, ChatGPT, and other AI agent tools?

There is no dedicated MCP server for this Actor. It is callable as an HTTP endpoint through the Apify API by any agent framework — every response is typed JSON, so an agent can read company_name, similar_companies, or recent_posts directly without parsing HTML or free text.

What's the difference between similar_companies and affiliated_companies?

similar_companies comes from LinkedIn's "Similar pages" carousel — lookalike companies LinkedIn's own algorithm suggests. affiliated_companies and affiliated_showcases come from the separate "Affiliated pages" module: formally linked sibling or parent/subsidiary companies (affiliated_companies) versus linked LinkedIn Showcase pages (affiliated_showcases).

Can recent_posts or the network lists come back empty?

Yes. If LinkedIn doesn't render a given module for a company, or a company has no recent posts, the corresponding list is [] and its _count field is 0 — never fabricated to look populated.

Do my existing base-actor input keys still work?

Yes. startUrls, maxRetries, and requestDelay — the original field names from the base LinkedIn Company About Scraper — are still read as fallbacks if a run's input doesn't set the renamed companyProfileUrls, fetchRetryLimit, or requestPaceSeconds keys.

ℹ️ Disclaimer

LinkedIn Company About Scraper : Similar Companies & Affiliates extracts only publicly available data from LinkedIn. This tool is intended for lawful use cases only. Users are responsible for complying with LinkedIn's terms of service and applicable data protection laws in their jurisdiction.