# LinkedIn People + Email Scraper (no cookies) (`myagizm/linkedin-people-scraper`) Actor

Bulk-scrape public LinkedIn profiles and find verified work emails — name, headline, company, location + SMTP-verified email. No login, no cookies, no API key.

- **URL**: https://apify.com/myagizm/linkedin-people-scraper.md
- **Developed by:** [MYM](https://apify.com/myagizm) (community)
- **Categories:** Jobs, Automation, Social media
- **Stats:** 2 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$8.00 / 1,000 linkedin person scrapeds

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/docs.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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 People Scraper — Scrape LinkedIn Profiles & Verified Work Emails (No API Key, No Login)

<p align="center">
Turn a list of public LinkedIn profile URLs into clean, structured people data <b>plus SMTP-verified work emails</b> — full name, headline, company, location, image, and email — in a single run. No login, no cookies, no account, and no API key required. Export scraped data to JSON, CSV, Excel, or XML, schedule runs via API, and integrate with your tools and AI workflows.
</p>

<p align="center">
<b>Built for AI agents:</b> call this actor straight from <b>Claude</b>, <b>ChatGPT / Codex</b>, and <b>Cursor</b> through the <a href="https://apify.com/apify/actors-mcp-server">Apify MCP server</a> to enrich leads and build contact lists conversationally.
</p>

<p align="center">
<a href="https://apify.com/myagizm/linkedin-people-scraper"><img src="https://img.shields.io/badge/Try%20Now-Apify-00b04f?style=for-the-badge" alt="Try Now"></a>
<a href="https://apify.com/myagizm/linkedin-people-scraper/input-schema"><img src="https://img.shields.io/badge/Input%20Schema-docs-2b7fff?style=for-the-badge" alt="Input Schema"></a>
<a href="https://apify.com/myagizm/linkedin-people-scraper/api"><img src="https://img.shields.io/badge/API-Reference-6c5ce7?style=for-the-badge" alt="API Docs"></a>
</p>

<p align="center">
<a href="#what-can-linkedin-people-scraper-do">What it does</a> ·
<a href="#use-linkedin-people-scraper-with-ai-agents-mcp">AI agents (MCP)</a> ·
<a href="#how-to-scrape-linkedin-people-and-emails">How to scrape</a> ·
<a href="#what-data-can-you-scrape-from-linkedin-people">Output fields</a> ·
<a href="#limits">Limits</a> ·
<a href="#output-example">Output example</a> ·
<a href="#how-much-does-it-cost-to-scrape-linkedin-people">Pricing</a> ·
<a href="#integrations">Integrations</a> ·
<a href="#faq">FAQ</a> ·
<a href="#want-other-linkedin-data">Other actors</a>
</p>

---

### What can LinkedIn People Scraper do? {#what-can-linkedin-people-scraper-do}

**LinkedIn People Scraper** takes a list of **public LinkedIn profile URLs** and returns structured people records — and, optionally, a **verified work email** for each person. It is built for sales, recruiting, and research teams who need to scrape LinkedIn people and enrich contacts **at scale** without touching a browser, a login, or a cookie.

Feed it profile URLs like `https://www.linkedin.com/in/williamhgates`, and it gives you back a clean JSON row per person: full name, headline, current company, location, profile image, and a work-email block with the best candidate, an SMTP verification status, and a ranked list of fallbacks. It only collects **publicly available data**, runs entirely in the cloud, and needs **no API key** and **no login** — **no cookies or account required**. Get your first results free in under 2 minutes.

- ✅ **Scrape LinkedIn people in bulk** — paste a handful of URLs or up to 500 per run.
- ✅ **Find & verify work emails** — SMTP-checked, with a confidence score.
- 🗂️ **Clean, structured records** — flat JSON ready for a CRM or spreadsheet.
- 💬 **Ranked email candidates** — fallbacks ready when the first send bounces.
- ⚡ **Zero setup** — no proxies, no session cookies, no external keys.
- 🚀 **Fast, fresh data** — parallel fetching finishes large lists in seconds.

#### ✅ Verified work-email discovery

For every profile, the LinkedIn People Scraper can derive the person's likely work email using company-domain pattern matching, then confirm it over SMTP. Each result carries an `emailStatus` of **verified**, **catch-all**, or **unverified**, plus an `emailConfidence` score, so you know exactly how much to trust each address before you send.

#### 🗂️ Clean, structured people records

No parsing HTML yourself. Each person comes back as a flat, predictable object — `fullName`, `firstName`, `lastName`, `headline`, `company`, `location`, `image`, and `profileUrl` — ready to drop straight into a CRM, spreadsheet, or database.

#### 💬 Ranked email candidates

Beyond the single best email, the actor returns an `emailCandidates` array of every plausible address pattern for the person and domain (for example `first.last@`, `firstlast@`, `flast@`). If your first send bounces, the fallbacks are already there.

#### 📊 Bulk mode — scrape LinkedIn people at scale

Point it at a handful of URLs or up to **500 profiles per run** in parallel "mass mode." Tune throughput with a single `concurrency` field. There are **no limitations on requests** — it is designed for enriching entire prospect lists in a single pass.

#### 🔄 Domain override for accuracy

Know the target company's email domain already? Pass `companyDomain` (e.g. `microsoft.com`) to force it for the whole run instead of auto-detecting per profile — perfect for enriching one company's org chart.

#### ⚡ Zero setup — no login, no cookies, no API key

There is nothing to configure. No LinkedIn account, no session cookies, no proxy setup, and no external API keys. The actor handles connectivity, rotation, and retries for you, so you can go **beyond the limitations of the official LinkedIn API**. Paste URLs, hit run.

---

### Use LinkedIn People Scraper with AI agents — Claude, ChatGPT & Cursor (MCP) {#use-linkedin-people-scraper-with-ai-agents-mcp}

This actor is fully compatible with the **[Apify MCP server](https://apify.com/apify/actors-mcp-server)**, so AI agents and assistants can call it as a tool and scrape LinkedIn people on demand.

- **Claude** (Desktop, Code, or the API) — add the Apify MCP server and ask Claude to *"enrich these 40 LinkedIn URLs and find verified emails."*
- **ChatGPT / Codex** — expose the actor as a tool and let the model build contact lists for you.
- **Cursor** — call the scraper from inside your editor while you build outreach automations.

Once the data lands in an Apify dataset, you can pipe it onward through MCP connectors and no-code tools — **Slack**, **Notion**, **Airtable**, **Google Sheets**, **Zapier**, **Make**, and **n8n** — to update your CRM, notify a channel, or trigger a sequence automatically.

---

### How to scrape LinkedIn people and emails {#how-to-scrape-linkedin-people-and-emails}

Scraping LinkedIn people takes a few clicks — no login and no API key:

1. Open the **[LinkedIn People Scraper](https://apify.com/myagizm/linkedin-people-scraper)** on Apify (or add it to your account for free).
2. Paste one or more **public LinkedIn profile URLs** into the `profileUrls` field.
3. Leave **`findEmail`** on (default) to also derive and SMTP-verify a work email for each person.
4. *(Optional)* Set **`companyDomain`** if you already know the company's email domain.
5. *(Optional)* Adjust **`maxItems`** (up to 500) and **`concurrency`** (up to 12) for large lists.
6. Click **▶ Start** / **Save & Run**.
7. When the run finishes, export the scraped data as **JSON, CSV, Excel, or XML**, or pull it via the API.

No account, no cookies, and no API key required — the actor takes care of everything.

---

### What data can you scrape from LinkedIn people? {#what-data-can-you-scrape-from-linkedin-people}

Each profile produces one dataset item with the following fields:

| Field | Type | Description |
|-------|------|-------------|
| `ok` | boolean | Whether the profile was processed successfully. |
| `fullName` | string | Person's full display name. |
| `firstName` | string | Parsed first name. |
| `lastName` | string | Parsed last name. |
| `headline` | string | LinkedIn headline / current role text. |
| `company` | string | Current company name. |
| `companyLinkedIn` | string / null | Company's LinkedIn URL, when available. |
| `location` | string | Person's location. |
| `image` | string / null | Profile image URL, when available. |
| `profileUrl` | string | Canonical LinkedIn profile URL. |
| `inputUrl` | string | The URL you supplied (for matching back to your list). |
| `found` | boolean | Whether a work email was found. |
| `email` | string | Best / recommended work email. |
| `emailStatus` | string | `verified`, `catch-all`, or `unverified`. |
| `emailConfidence` | string | Confidence in the chosen email (`high` / `medium` / `low`). |
| `emailDomain` | string | Domain used for email derivation. |
| `emailSource` | string | How the email was derived (e.g. `smtp-pattern`). |
| `emailCandidates` | array | Ranked list of all plausible email addresses. |

---

### Use cases for scraping LinkedIn people

- **B2B lead enrichment** — turn a list of prospect profile URLs into contactable records with verified emails.
- **Outbound sales prospecting** — build targeted contact lists for cold email and multichannel outreach.
- **Recruiting & sourcing** — enrich candidate shortlists with current role, company, location, and email.
- **CRM hygiene** — refresh stale contacts and fill in missing email addresses.
- **Account-based marketing** — enrich an entire target company's people using the `companyDomain` override.
- **Market & talent research** — collect structured people data across an industry or region.
- **Competitor analysis** — map the teams and hires behind competing companies.
- **Data appending** — append verified emails to existing spreadsheets of LinkedIn URLs.

---

### Input examples

All examples use the **real** input field names from the actor's schema.

#### Scrape a few LinkedIn people with email discovery (default)

```json
{
  "profileUrls": [
    "https://www.linkedin.com/in/williamhgates",
    "https://www.linkedin.com/in/satyanadella"
  ],
  "findEmail": true
}
````

#### Scrape LinkedIn people data only (skip email finding)

```json
{
  "profileUrls": [
    "https://www.linkedin.com/in/williamhgates"
  ],
  "findEmail": false
}
```

#### Force a specific company email domain

Use this when you are enriching people who all work at the same company:

```json
{
  "profileUrls": [
    "https://www.linkedin.com/in/satyanadella"
  ],
  "findEmail": true,
  "companyDomain": "microsoft.com"
}
```

#### Bulk mode — scrape a large list of LinkedIn people at once

```json
{
  "profileUrls": [
    "https://www.linkedin.com/in/williamhgates",
    "https://www.linkedin.com/in/satyanadella",
    "https://www.linkedin.com/in/jeffweiner08",
    "https://www.linkedin.com/in/reidhoffman"
  ],
  "findEmail": true,
  "maxItems": 500,
  "concurrency": 12
}
```

#### Balanced throughput for medium lists

```json
{
  "profileUrls": [
    "https://www.linkedin.com/in/williamhgates",
    "https://www.linkedin.com/in/satyanadella"
  ],
  "findEmail": true,
  "maxItems": 100,
  "concurrency": 8
}
```

***

### Input parameters reference

| Field | Type | Default | Description |
|-------|------|---------|-------------|
| `profileUrls` | array (required) | — | Public LinkedIn profile URLs to scrape. |
| `findEmail` | boolean | `true` | Derive and SMTP-verify a work email for each person. |
| `companyDomain` | string | *(auto)* | Force a specific company email domain for all profiles in the run. |
| `maxItems` | integer | `100` | Max profiles per run — up to 500 (mass mode, parallel). |
| `concurrency` | integer | `8` | How many profiles to fetch in parallel (1–12; higher = faster). |

***

### Limiting results {#limits}

- **`maxItems`** — caps how many profiles a single run will process. Default is **100**; you can raise it up to **500** for mass enrichment, or lower it to control cost on small tests.
- **`concurrency`** — controls how many profiles are fetched in parallel (1–12, default **8**). Higher values finish large lists faster.

To run a quick, cheap test, set `maxItems` to a small number and pass just one or two URLs.

***

### Output example {#output-example}

A single dataset item looks like this (real sample):

```json
{
  "ok": true,
  "email": "bill.gates@gatesfoundation.org",
  "found": true,
  "image": null,
  "company": "Gates Foundation",
  "fullName": "Bill Gates",
  "headline": "Chair, Gates Foundation and Founder, Breakthrough Energy",
  "inputUrl": "https://www.linkedin.com/in/williamhgates",
  "lastName": "Gates",
  "location": "Seattle",
  "firstName": "Bill",
  "profileUrl": "https://www.linkedin.com/in/williamhgates",
  "emailDomain": "gatesfoundation.org",
  "emailSource": "smtp-pattern",
  "emailStatus": "catch-all",
  "companyLinkedIn": null,
  "emailCandidates": [
    "bill.gates@gatesfoundation.org",
    "billgates@gatesfoundation.org",
    "bgates@gatesfoundation.org",
    "bill_gates@gatesfoundation.org",
    "b.gates@gatesfoundation.org",
    "gatesb@gatesfoundation.org",
    "bill@gatesfoundation.org"
  ],
  "emailConfidence": "low"
}
```

***

### How much does it cost to scrape LinkedIn people? {#how-much-does-it-cost-to-scrape-linkedin-people}

This actor uses a simple, **pay-per-result** model — you are billed for the profiles you enrich, not for idle compute time. Because it fetches profiles in parallel and returns compact structured records, runs are fast and cost-efficient even for large lists. **Get your first results free in under 2 minutes** on Apify's free plan.

To keep costs predictable:

- Start with a small `maxItems` value to validate your URLs.
- Turn off `findEmail` if you only need people data (email verification is the heavier step).
- Batch your list into a single run rather than many one-off runs.

See the live per-result price on the **[actor's Apify page](https://apify.com/myagizm/linkedin-people-scraper)**.

***

### Integrate LinkedIn people data with n8n, Zapier, and Make {#integrations}

Run the actor and get results directly from the Apify API. Use the actor path **`myagizm~linkedin-people-scraper`**.

#### Synchronous — run and get dataset items in one call

```bash
curl -X POST "https://api.apify.com/v2/acts/myagizm~linkedin-people-scraper/run-sync-get-dataset-items?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "profileUrls": [
      "https://www.linkedin.com/in/williamhgates"
    ],
    "findEmail": true
  }'
```

#### Asynchronous — start a run, then fetch results

```bash
## 1) Start a run
curl -X POST "https://api.apify.com/v2/acts/myagizm~linkedin-people-scraper/runs?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "profileUrls": [
      "https://www.linkedin.com/in/williamhgates",
      "https://www.linkedin.com/in/satyanadella"
    ],
    "findEmail": true,
    "maxItems": 100
  }'

## 2) Fetch the run's dataset items when it finishes
curl "https://api.apify.com/v2/datasets/DATASET_ID/items?token=YOUR_APIFY_TOKEN&clean=true&format=json"
```

You can wire these calls into **Make, Zapier, n8n, Slack, Airbyte, Gumloop, CrewAI, IFTTT, Lindy, GitHub, Google Sheets, and Google Drive** to enrich leads and push contacts automatically. AI agents can do the same through the **[Apify MCP server](https://apify.com/apify/actors-mcp-server)**.

***

### Support {#support}

Questions, edge cases, or a field you'd like added? Open an **Issue** on the actor's Apify page and we'll respond. We actively maintain the scraper and welcome feedback on new fields and improvements.

- **Actor page:** https://apify.com/myagizm/linkedin-people-scraper
- **Issues:** use the *Issues* tab on the actor page
- **API reference:** https://apify.com/myagizm/linkedin-people-scraper/api

***

### FAQ — scraping LinkedIn people {#faq}

#### Is it legal to scrape LinkedIn people?

The actor only accesses **publicly available** profile information. You are responsible for using the data in compliance with applicable laws (such as GDPR/CCPA) and LinkedIn's terms. Use it for legitimate business purposes like sales, recruiting, and research.

#### Do I need a LinkedIn account, login, or cookies to scrape LinkedIn people?

No. There is no login, no session cookie, and no API key. Paste public profile URLs and run — **no cookies or account required**.

#### Can I use LinkedIn People Scraper with the Apify API?

Yes. Start runs and fetch datasets through the Apify API using the actor path `myagizm~linkedin-people-scraper`. Sync and async examples are shown above.

#### Can I scrape LinkedIn people through an MCP server (AI agents)?

Yes. The actor works with the **Apify MCP server**, so Claude, ChatGPT, and Cursor can call it as a tool to scrape and enrich people on demand.

#### Do I need proxies to scrape LinkedIn people?

No. The actor handles connectivity, rotation, and retries for you — nothing to configure and no proxies to bring.

#### Can I integrate LinkedIn people data with other apps?

Yes. Push results into Make, Zapier, n8n, Slack, Google Sheets, Airtable, Notion, and more via the API, webhooks, or MCP connectors.

#### Can I export scraped LinkedIn people to CSV, Excel, or JSON?

Yes. Results are stored in an Apify dataset and can be exported to **JSON, CSV, Excel, or XML**, or pulled via the API.

#### Can I scrape multiple LinkedIn people at once?

Yes — up to **500** profiles per run via the `maxItems` field, processed in parallel. Set `concurrency` (up to 12) to control speed. There are no limitations on the number of runs.

#### Can I schedule the LinkedIn People Scraper?

Yes. Use Apify **Schedules** to run enrichment daily, weekly, or on any cron you like.

#### Can I scrape data from private LinkedIn accounts?

No. The actor only works with **public** LinkedIn `/in/` profiles. Private or restricted profiles may return limited or no data.

#### How accurate are the emails?

Each email carries an `emailStatus` (`verified`, `catch-all`, or `unverified`) and an `emailConfidence` score. **Verified** means the address was confirmed over SMTP. **Catch-all** means the domain accepts all addresses, so treat it as probable, not guaranteed. Always check these fields before sending.

#### What is the `emailCandidates` list for?

It's a ranked set of every plausible email pattern for the person and domain. If the primary `email` bounces, use the next candidate as a fallback.

#### Can I skip email finding and just get profile data?

Yes — set `findEmail` to `false`. This is faster and cheaper when you only need name, headline, company, and location.

#### Can I force a specific email domain?

Yes. Set `companyDomain` (e.g. `microsoft.com`) and it applies to every profile in the run, overriding auto-detection.

#### Can I match results back to my input list?

Yes — every item includes `inputUrl`, the exact URL you supplied, so you can join results back to your source rows.

#### How fast is it?

It fetches profiles in parallel, so large lists finish quickly. Increase `concurrency` for more throughput; lower it if you want gentler runs. **Fast, fresh data** every run — no caching.

***

### Want other LinkedIn data? {#want-other-linkedin-data}

Scrape more of LinkedIn with the rest of the **myagizm LinkedIn** family — same no-login, no-API-key approach:

- **[LinkedIn Profile Scraper](https://apify.com/myagizm/linkedin-profile-scraper)** — full, detailed single-profile data (experience, education, skills).
- **[LinkedIn Company Scraper](https://apify.com/myagizm/linkedin-company-scraper)** — company pages: size, industry, headquarters, and more.
- **[LinkedIn Profile Posts Scraper](https://apify.com/myagizm/linkedin-profile-posts-scraper)** — a person's recent posts and activity.
- **[LinkedIn Jobs Scraper](https://apify.com/myagizm/linkedin-jobs-scraper)** — job listings with titles, companies, locations, and links.

***

### Disclaimer

This is an independent tool and is not affiliated with, endorsed by, or sponsored by LinkedIn. All product names, logos, and brands are property of their respective owners. Use this actor only to collect publicly available data and in compliance with applicable laws and platform terms.

***

### Resources {#resources}

- **[Apify API reference](https://docs.apify.com/api/v2)** — run actors and fetch datasets programmatically.
- **[Apify MCP server](https://apify.com/apify/actors-mcp-server)** — connect this actor to Claude, ChatGPT, and Cursor.
- **[Dataset export docs](https://docs.apify.com/platform/storage/dataset)** — export results to JSON, CSV, Excel, and more.
- **[Apify Schedules](https://docs.apify.com/platform/schedules)** — automate recurring runs.
- **[Actor page](https://apify.com/myagizm/linkedin-people-scraper)** — try it now and get your first results free in under 2 minutes.

# Actor input Schema

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

Public LinkedIn profile URLs to scrape, one per line. Example: "https://www.linkedin.com/in/williamhgates". Paste as many as you like (up to the Max profiles limit) to enrich a whole list in one run.

## `findEmail` (type: `boolean`):

Also derive the person's work email (company-domain pattern matching) and verify it over SMTP. Returns emailStatus: verified / catch-all / unverified. Example: for a Microsoft profile it may return "satya.nadella@microsoft.com" with emailStatus "verified". Turn off for faster, cheaper profile-only runs.

## `companyDomain` (type: `string`):

Force a specific company email domain (e.g. "microsoft.com") instead of auto-detecting from the profile. Applies to all profiles in this run — ideal when enriching people who all work at the same company.

## `maxItems` (type: `integer`):

Profiles per run — up to 500 (mass mode, parallel). Example: set to 25 for a quick test, or 500 to enrich a full prospect list in one pass.

## `concurrency` (type: `integer`):

How many profiles to fetch in parallel (higher = faster, default 8). Example: set to 12 to finish a large list quickly, or 2 for gentler, slower runs.

## Actor input object example

```json
{
  "profileUrls": [
    "https://www.linkedin.com/in/williamhgates",
    "https://www.linkedin.com/in/satyanadella"
  ],
  "findEmail": true,
  "maxItems": 100,
  "concurrency": 8
}
```

# Actor output Schema

## `results` (type: `string`):

All scraped people as structured JSON — profile fields + verified email.

# 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/williamhgates",
        "https://www.linkedin.com/in/satyanadella"
    ],
    "findEmail": true,
    "maxItems": 100,
    "concurrency": 8
};

// Run the Actor and wait for it to finish
const run = await client.actor("myagizm/linkedin-people-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/williamhgates",
        "https://www.linkedin.com/in/satyanadella",
    ],
    "findEmail": True,
    "maxItems": 100,
    "concurrency": 8,
}

# Run the Actor and wait for it to finish
run = client.actor("myagizm/linkedin-people-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/williamhgates",
    "https://www.linkedin.com/in/satyanadella"
  ],
  "findEmail": true,
  "maxItems": 100,
  "concurrency": 8
}' |
apify call myagizm/linkedin-people-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "LinkedIn People + Email Scraper (no cookies)",
        "description": "Bulk-scrape public LinkedIn profiles and find verified work emails — name, headline, company, location + SMTP-verified email. No login, no cookies, no API key.",
        "version": "0.1",
        "x-build-id": "BhcjXVFTePxTeJhMp"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/myagizm~linkedin-people-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-myagizm-linkedin-people-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/myagizm~linkedin-people-scraper/runs": {
            "post": {
                "operationId": "runs-sync-myagizm-linkedin-people-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/myagizm~linkedin-people-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-myagizm-linkedin-people-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",
                "required": [
                    "profileUrls"
                ],
                "properties": {
                    "profileUrls": {
                        "title": "🔗 LinkedIn profile URLs",
                        "type": "array",
                        "description": "Public LinkedIn profile URLs to scrape, one per line. Example: \"https://www.linkedin.com/in/williamhgates\". Paste as many as you like (up to the Max profiles limit) to enrich a whole list in one run.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "findEmail": {
                        "title": "✅ $ Find & verify email",
                        "type": "boolean",
                        "description": "Also derive the person's work email (company-domain pattern matching) and verify it over SMTP. Returns emailStatus: verified / catch-all / unverified. Example: for a Microsoft profile it may return \"satya.nadella@microsoft.com\" with emailStatus \"verified\". Turn off for faster, cheaper profile-only runs.",
                        "default": true
                    },
                    "companyDomain": {
                        "title": "🌐 Company domain (optional)",
                        "type": "string",
                        "description": "Force a specific company email domain (e.g. \"microsoft.com\") instead of auto-detecting from the profile. Applies to all profiles in this run — ideal when enriching people who all work at the same company."
                    },
                    "maxItems": {
                        "title": "💯 Max profiles",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Profiles per run — up to 500 (mass mode, parallel). Example: set to 25 for a quick test, or 500 to enrich a full prospect list in one pass.",
                        "default": 100
                    },
                    "concurrency": {
                        "title": "⚡ Parallelism",
                        "minimum": 1,
                        "maximum": 12,
                        "type": "integer",
                        "description": "How many profiles to fetch in parallel (higher = faster, default 8). Example: set to 12 to finish a large list quickly, or 2 for gentler, slower runs.",
                        "default": 8
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
