How to Scrape LinkedIn Followers (2026)

I tried to pull a competitor’s LinkedIn followers the obvious way: open the company Page, find the follower list, export it. There is no list to export. LinkedIn shows the follower count on a public company page, but it never renders the names of who follows, and even a Page admin only gets aggregate analytics. So learning how to scrape LinkedIn followers really means two different jobs, and this guide covers both with the code I ran in July 2026.

The split matters because one job is easy and public and the other is walled and risky. The follower count is public firmographic data you can read without logging in. The named follower list, the actual people, is not on any logged-out page, so every route to it either stays inside your own Page or drives a logged-in account. I will show the status codes and the request shapes for each, and where a route is walled, I say so instead of pretending otherwise.

Can you scrape LinkedIn followers?

You can scrape LinkedIn followers, but reliably only the follower count, not the named list of who follows. The count is public: LinkedIn prints it on the logged-out company page and on creator profiles, so a scraper reads it like any other field. The named follower list is a different story, because LinkedIn does not expose it publicly and gives even a Page admin only aggregate follower analytics, never a downloadable list of member profiles.

That gap decides which route you need, and I measured both outcomes directly:

The honest headline is that “scrape LinkedIn followers” usually means one of two things, and people conflate them. If you want to track how many followers a set of companies has, that is public and quick. If you want the named audience of a page you do not own, you are reaching for data LinkedIn deliberately keeps behind a login. The next section maps exactly which follower fields sit on which side of that line.

What LinkedIn follower data can you actually get?

The LinkedIn follower data you can actually get falls into three tiers, and only the first is public. Sorting your goal into the right tier saves you from building a scraper for data that does not exist in the open.

• Follower counts (public). The total follower number on a company page, and the follower number on a creator profile. This is the backbone of competitor and audience-size tracking, and it is the one follower field you can collect at scale without a login.
• Aggregate follower demographics (your own page). As a Page admin, LinkedIn’s analytics export gives you follower growth over time plus breakdowns by job function, seniority, industry, company size, and location. It is real, useful data, but it is counts and percentages, not a list of people.
• Named followers (walled). The individual profiles that follow a page or a person, with name, headline, and profile URL. LinkedIn never renders this list logged out, so it is reachable only through your own Page tools or a logged-in session.

There is one sanctioned way to read counts programmatically, and it is worth knowing before you scrape. LinkedIn’s Marketing API exposes an Organization Follower Statistics endpoint that returns follower counts and segment breakdowns, but only for a Page you administer and only after Partner Program approval and OAuth. It will not return another company’s followers, and it will never return names. For anything outside your own Page, the public follower count is the ceiling of what is cleanly available, and the fastest way to collect it at volume is the company page itself.

How do you scrape a LinkedIn company’s follower count with Python?

You scrape a LinkedIn company’s follower count with Python by fetching the public company page and reading the count out of the rendered text, because LinkedIn prints it as plain text like 10,000,000 followers. The catch is the same one that shapes all LinkedIn scraping: a bare datacenter request gets denied. In my earlier tests a request with no User-Agent drew LinkedIn’s HTTP 999 “Request Denied” code, the same wall I document in my complete guide to scraping LinkedIn, so you need at least a real browser User-Agent and, in practice, a clean residential IP.

Here is the minimal Python that pulls the count when the real page renders:

import re
import requests

UA = ("Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 "
      "(KHTML, like Gecko) Chrome/126.0 Safari/537.36")
url = "https://www.linkedin.com/company/microsoft/"

r = requests.get(url, headers={"User-Agent": UA}, timeout=25)
print(r.status_code)                       # 200 with a browser UA, 999 without

# The follower count renders in the public page text as "N followers"
match = re.search(r"([\d,]+)\s+followers", r.text)
print(match.group(1) if match else "not found (likely the sign-in wall)")

Two things make this fragile in production. First, a datacenter IP often gets the sign-in wall instead of the real page, so the regex returns nothing even on a 200, and you cannot tell a genuinely zero-follower page from a blocked one. Second, LinkedIn condenses and re-labels its markup, so a selector that keys on class names rots fast, and the plain “N followers” text pattern is the most durable thing to match. For a handful of pages from a residential connection this works. Past that, the block rate climbs and you spend more time fighting 999s than parsing counts, which is the point where a managed endpoint earns its place.

How do you get a LinkedIn page’s follower list?

You get a LinkedIn page’s follower list only through a logged-in route, because the named list of followers is never on the public page. There is no public URL, no logged-out endpoint, and no official API that returns another page’s member-by-member followers. Every working route below authenticates as a real member, which is exactly what shifts the risk onto an account.

Your own page: analytics export and Sales Navigator

For your own Page, the safest routes stay inside LinkedIn’s own tools. The Page analytics export hands admins the aggregate follower report described above, and for named people the Sales Navigator “following your company” filter surfaces a searchable list of the members who already follow your page, which LinkedIn flags as warmer outreach targets. Both stay within LinkedIn’s rules and never get blocked, and both are scoped to a page you administer. Neither will give you a competitor’s followers, and that limitation is the whole reason the scraping routes exist.

A competitor’s page: the hidden Voyager API and its risks

For a page you do not own, the only route to a named follower list is LinkedIn’s hidden Voyager API, the same internal REST API that powers linkedin.com once you are logged in. Open-source tools like the Python linkedin-scraper by peak050423 drive it directly: you supply a logged-in li_at session cookie, point it at a company or a post, and it walks the follower or liker list into CSV. It works, and its own README is blunt that “scraping LinkedIn data may violate LinkedIn’s Terms of Service” and that these private endpoints “may stop working at any time.”

The tradeoff is unavoidable here. You are running your own authenticated account against a private API at machine speed, which is the precise pattern LinkedIn’s behavioral detection is built to catch, so a heavy pull risks a temporary restriction or a permanent ban. Cookie-based no-code tools carry the same exposure because they also drive your session. That is why, when the goal is public follower counts across many pages rather than a named competitor list, I move the fetch off my own account entirely.

How do you scrape LinkedIn follower data without getting blocked?

You scrape LinkedIn follower data without getting blocked by sending the company or profile URL to a scraper API that fetches the public page through its own residential proxies and returns parsed JSON, so no 999 reaches you and no account of yours is on the line. This is the clean route for follower counts at scale: one authenticated request per page, the count already parsed, and the proxy rotation and retries handled server-side. In my testing the ChocoData LinkedIn endpoints are shaped to return exactly this from a single call.

For a company’s follower count, the request is a plain GET with the company URL and your API key:

curl "https://chocodata.com/api/v1/linkedin/company?url=https://www.linkedin.com/company/microsoft&api_key=$CHOCO_API_KEY"

The Python version returns the full firmographic record, with follower_count sitting alongside industry, size, and headquarters, ready to write to a table:

import requests

resp = requests.get(
    "https://chocodata.com/api/v1/linkedin/company",
    params={
        "url": "https://www.linkedin.com/company/microsoft",
        "api_key": "YOUR_CHOCO_API_KEY",
    },
    timeout=30,
)
company = resp.json()
print(company["name"], "-", company.get("follower_count"), "followers")

To track follower counts across a competitor set, loop the same call over a list of company URLs and write each count to CSV. Because the rotation happens on the server, the requests are independent and you never touch a proxy or a cookie:

import csv
import requests

API_KEY = "YOUR_CHOCO_API_KEY"
companies = [
    "https://www.linkedin.com/company/microsoft",
    "https://www.linkedin.com/company/google",
    "https://www.linkedin.com/company/amazon",
]

with open("followers.csv", "w", newline="") as f:
    writer = csv.writer(f)
    writer.writerow(["company", "followers"])
    for url in companies:
        data = requests.get(
            "https://chocodata.com/api/v1/linkedin/company",
            params={"url": url, "api_key": API_KEY},
            timeout=30,
        ).json()
        writer.writerow([data.get("name"), data.get("follower_count")])

A person’s public follower count comes back the same way from the profile endpoint, so a creator’s audience size is one path swap away:

curl "https://chocodata.com/api/v1/linkedin/profile?url=https://www.linkedin.com/in/williamhgates&api_key=$CHOCO_API_KEY"

The honest boundary holds here too. This route returns the public follower counts and the public profile and company records you would use to enrich a list, at a median around 2.6 seconds per call, without your login in the loop. It does not conjure a competitor’s named follower list, because that data is not public and this API stays logged out by design. What it removes is the blocking work: the residential proxies, the 999 retries, and the account risk that the User Agreement’s automation ban makes real. For the wider set of LinkedIn objects and the tools that handle them, I keep a ranked roundup in the best LinkedIn scrapers of 2026.

Is it legal to scrape LinkedIn followers?

Scraping public LinkedIn follower data is generally treated as legal in the US, but the account and privacy risks are separate questions you carry. In hiQ v. LinkedIn the Ninth Circuit held that scraping publicly accessible data likely does not violate the Computer Fraud and Abuse Act, which is why reading a public follower count sits on firmer ground than reaching for the walled named list. That same case still ended with hiQ liable for breaching LinkedIn’s contract terms, so the User Agreement ban bites the account that does the scraping even when the CFAA does not.

Two limits matter in practice. LinkedIn’s robots.txt states that automated access without permission is “strictly prohibited” and disallows the profile and search paths, so ignoring it is part of what gets an IP flagged. And because follower profiles are personal data, rules like the GDPR apply to what you collect and especially to outreach, so treat scraped followers as public business information with a lawful basis and honor opt-outs. I walk through the full picture, including the User Agreement and the account risk, in is scraping LinkedIn legal. This is general information, not legal advice.