# LinkedIn Profile Scraper - Bulk Public Data, No Login (`themineworks/linkedin-profile-scraper`) Actor

Scrape public LinkedIn profiles in bulk - name, headline, location, experience, education, skills, connections & followers. No login or cookies. Bulk linkedin.com/in/ URLs to clean JSON. Works in Claude, ChatGPT & any MCP agent for B2B lead enrichment.

- **URL**: https://apify.com/themineworks/linkedin-profile-scraper.md
- **Developed by:** [The Mine Works](https://apify.com/themineworks) (community)
- **Categories:** Developer tools, Social media, MCP servers
- **Stats:** 9 total users, 7 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$4.00 / 1,000 linkedin profiles

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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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 Profile Scraper — Name, Headline, Experience & Skills (No Login)

Scrape public LinkedIn profiles in bulk. Give the actor a list of `linkedin.com/in/` URLs and get back structured data for each profile: name, headline, location, about section, full work experience, education history, skills, connection count, and follower count.

**No login. No cookies. No LinkedIn account required.**

---

### What It Does

LinkedIn makes public profiles visible to anyone on the web — no account needed. This actor uses a real Chromium browser (Playwright) routed through Apify's residential proxy network to load each profile page just like a real visitor would, then extracts every visible field into a clean JSON record.

LinkedIn's public pages are served as fully-rendered server-side HTML, so all the content is present without JavaScript execution tricks. The actor scrolls each page to trigger lazy-loaded sections (experience, education, skills) before extracting.

---

### Example Output

```json
{
  "profile_url": "https://www.linkedin.com/in/satyanadella",
  "name": "Satya Nadella",
  "headline": "Chairman and CEO at Microsoft",
  "location": "Redmond, Washington, United States",
  "about": "Hit Refresh is about the quest to find one's soul...",
  "experience": [
    {
      "title": "Chairman and Chief Executive Officer",
      "company": "Microsoft",
      "duration": "Feb 2014 - Present",
      "description": null
    }
  ],
  "education": [
    {
      "school": "University of Chicago Booth School of Business",
      "degree": "Master of Business Administration",
      "field": "MBA",
      "dates": "1994 - 1997"
    }
  ],
  "skills": ["Cloud Computing", "SaaS", "Enterprise Software", "Leadership"],
  "connections": "500+ connections",
  "followers": "12,000,000 followers",
  "scraped_at": "2026-06-23T10:00:00.000Z"
}
````

***

### Input Fields

| Field | Type | Description |
|---|---|---|
| **profileUrls** | array of strings | LinkedIn profile URLs to scrape. Use the format `https://www.linkedin.com/in/username`. Supports up to 500 URLs per run. |
| **maxResults** | integer | Maximum number of profiles to return (default: 10, max: 500). Use a small number like 1–3 for quick tests. |
| **proxy** | proxy config | Residential proxy configuration. Leave as default — datacenter IPs are blocked by LinkedIn. |

***

### Why a Real Browser Is Required

LinkedIn detects headless and bare HTTP clients via browser fingerprinting and immediately redirects them to `/authwall` (the login page). A real Chromium browser with residential proxies is the only reliable way to consistently access public profile pages without an account.

The actor uses `crawlee`'s `PlaywrightCrawler` with fingerprinting enabled (Chrome on Windows/macOS) and the `--disable-blink-features=AutomationControlled` flag to prevent `navigator.webdriver` detection. Each profile uses a fresh proxy session to avoid IP-level rate-limiting.

***

### Pricing

**First 25 profiles per Apify account are free — forever.** After the free allowance is used up, the actor charges $0.005 per successfully scraped profile via Apify's Pay-Per-Event model.

- Blocked profiles (authwall hits) are **never charged**
- Not-found / private profiles are **never charged**
- Only profiles with a name successfully extracted are charged

The free allowance is tracked per Apify account across all of your runs, not per individual run. So you can run the actor multiple times and you'll only use your 25 free profiles once.

***

### How Profiles Are Extracted

The actor uses multiple CSS selector fallbacks for every field so that changes to LinkedIn's class names degrade gracefully (missing one field) rather than crashing the entire run. The extraction hierarchy for each field:

- **Name** — `h1.text-heading-xlarge` and fallback h1 selectors
- **Headline** — `.text-body-medium.break-words` and professional headline variants
- **Location** — `.text-body-small.inline.t-black--light.break-words` and data-field attributes
- **About** — `#about` anchor then sibling content, including the `.visually-hidden` expanded-text span
- **Experience** — `#experience` anchor then `ul > li` items in the section
- **Education** — `#education` anchor then `ul > li` items in the section
- **Skills** — `#skills` anchor then `t-bold` span text items
- **Connections / Followers** — text-based regex scan of the visible page body + stat element fallbacks

***

### Handling Blocked and Private Profiles

The actor handles all failure cases gracefully — it never crashes the run and never charges for failed profiles:

- **Authwall** (`status: "blocked"`) — LinkedIn redirected to the login page. Usually means the exit IP was flagged. Retried up to 2 times with fresh proxy sessions automatically.
- **Not found** (`status: "not_found"`) — Profile URL returned a 404 or "Page Not Found" title. The profile was deleted or the URL is wrong.
- **No name** (`status: "no_name"`) — Page loaded but no name was found. Can indicate a private profile or a partially-loaded page.
- **Summary item** — The last item in every dataset is `{ "_type": "summary", "scraped": N, "blocked": N, ... }` giving run statistics.

***

### Rate Limiting and Proxy

LinkedIn rate-limits by IP. The actor uses **one profile per browser context** with a randomized 3–6 second delay between requests and a fresh residential proxy session for each profile. This is the same cadence a human user would achieve. Running at `maxConcurrency: 1` (sequential) is intentional — parallel browser sessions on the same account get flagged faster.

The `RESIDENTIAL` proxy group on Apify routes through real home/mobile IP addresses from the residential pool, which LinkedIn cannot distinguish from organic traffic.

***

### FAQ

**Can I scrape profiles without a LinkedIn account?**
Yes. Public LinkedIn profiles are accessible to anyone. This actor does not require you to supply your LinkedIn credentials or session cookies.

**Why do some profiles return "blocked"?**
A small percentage of residential IPs are pre-flagged by LinkedIn's bot detection. The actor automatically retries with up to 2 different IP sessions. If all retries fail, the profile is recorded as blocked and not charged. Success rates on residential proxy are typically 80–95%.

**What's the maximum throughput?**
With the default 1 concurrent browser and 3–6s per profile, expect roughly 10–15 profiles per minute. For 500 profiles, allow around 40–50 minutes.

**Does this work for private profiles?**
No. Private profiles require authentication and cannot be scraped without login. The actor will return a `not_found` or `no_name` status for private profiles.

**Can I integrate this with other actors?**
Yes. Pair it with the `linkedin-employees` actor: use `linkedin-employees` to find employee profile URLs for a company, then pass those URLs to this actor to get detailed data for each person.

***

### Built by The Mine Works

Production-grade web scrapers and data APIs. Pay only for results delivered. [themineworks.com](https://themineworks.com)

### Use in Claude, ChatGPT & any MCP agent

This actor is also a **Model Context Protocol (MCP) server tool** — call it directly from Claude, ChatGPT, Cursor, Windsurf, or any MCP-compatible AI agent. The agent only pays for results delivered (same pay-per-result model).

- Per-actor MCP endpoint: `https://mcp.apify.com/?tools=themineworks/linkedin-profile-scraper`
- Full Mine Works MCP server (all tools): `https://the-mine-works-mcp.hatchable.site/api/mcp`

```js
// Call this actor as a tool via apify-client (Node)
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: 'YOUR_APIFY_TOKEN' });
const run = await client.actor('themineworks/linkedin-profile-scraper').call({ /* input from the table above */ });
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

# Actor input Schema

## `profileUrls` (type: `array`):

List of LinkedIn profile URLs to scrape (e.g. https://www.linkedin.com/in/satyanadella). Supports up to 500 URLs per run.

## `maxResults` (type: `integer`):

Maximum number of profiles to return. Set to a small number (e.g. 3) for quick tests.

## `proxy` (type: `object`):

Residential proxy is required — LinkedIn rate-limits and blocks datacenter IPs. Leave as default.

## Actor input object example

```json
{
  "profileUrls": [
    "https://www.linkedin.com/in/satyanadella"
  ],
  "maxResults": 1,
  "proxy": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `results` (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 '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "profileUrls": [
        "https://www.linkedin.com/in/satyanadella"
    ],
    "maxResults": 1,
    "proxy": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("themineworks/linkedin-profile-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 '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "profileUrls": ["https://www.linkedin.com/in/satyanadella"],
    "maxResults": 1,
    "proxy": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("themineworks/linkedin-profile-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "profileUrls": [
    "https://www.linkedin.com/in/satyanadella"
  ],
  "maxResults": 1,
  "proxy": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call themineworks/linkedin-profile-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=themineworks/linkedin-profile-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "LinkedIn Profile Scraper - Bulk Public Data, No Login",
        "description": "Scrape public LinkedIn profiles in bulk - name, headline, location, experience, education, skills, connections & followers. No login or cookies. Bulk linkedin.com/in/ URLs to clean JSON. Works in Claude, ChatGPT & any MCP agent for B2B lead enrichment.",
        "version": "0.1",
        "x-build-id": "yKYg2h8cVlyLI76nM"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/themineworks~linkedin-profile-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-themineworks-linkedin-profile-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/themineworks~linkedin-profile-scraper/runs": {
            "post": {
                "operationId": "runs-sync-themineworks-linkedin-profile-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/themineworks~linkedin-profile-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-themineworks-linkedin-profile-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "profileUrls": {
                        "title": "LinkedIn Profile URLs",
                        "type": "array",
                        "description": "List of LinkedIn profile URLs to scrape (e.g. https://www.linkedin.com/in/satyanadella). Supports up to 500 URLs per run.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxResults": {
                        "title": "Max results",
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum number of profiles to return. Set to a small number (e.g. 3) for quick tests.",
                        "default": 10
                    },
                    "proxy": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Residential proxy is required — LinkedIn rate-limits and blocks datacenter IPs. Leave as default."
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```