# LinkedIn Profile Scraper - Email Finder, No Login (`hasnainnisar67/linkedin-profile-scraper`) Actor

Scrape public LinkedIn profiles by URL, slug, or search query: name, headline, job title, company, location, education & languages. Built-in email finder with MX validation. No login, no Sales Navigator, no API key.

- **URL**: https://apify.com/hasnainnisar67/linkedin-profile-scraper.md
- **Developed by:** [Hasnain Nisar](https://apify.com/hasnainnisar67) (community)
- **Categories:** Lead generation, Social media
- **Stats:** 5 total users, 2 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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

Scrape public [LinkedIn](https://www.linkedin.com) profiles by URL, slug, or people-search query — and optionally find each person's corporate email. This LinkedIn Profile Scraper extracts name, headline, job title, current company, location, education, and languages with **no LinkedIn login, no Sales Navigator, and no third-party API key**. The #1 use case: build B2B prospect and recruiting lists complete with name, title, company, and verified email candidates, ready to export to CSV or your CRM.

### What does the LinkedIn Profile Scraper Actor do?

The LinkedIn Profile Scraper is a tool that harvests public LinkedIn profile metadata at scale and, on request, generates and validates likely corporate email addresses for each person. It reads the profile data LinkedIn embeds in every public page — Open Graph meta tags and JSON-LD Person schema — so it works on the anonymous "auth wall" HTML without ever logging in. Supply direct profile URLs, bare slugs, or a free-form people-search query (resolved through DuckDuckGo's `site:linkedin.com/in` search), and the actor returns clean, structured records you can drop straight into a sales or recruiting workflow.

- **Scrape LinkedIn profiles** by URL, slug, or search query
- **Find LinkedIn emails** — generate corporate email candidates and validate them by MX lookup
- **Extract job title, company, and headline** for every profile
- **Get location, country, education, and languages** from JSON-LD
- **Bulk-scrape up to 100 profiles per run**
- **Search LinkedIn people without login** (e.g. "CTO fintech London")
- **No LinkedIn account or Sales Navigator subscription** required
- **Enrich a CRM** with title, company, and location for existing contacts

### What data can I extract from a LinkedIn profile?

Each profile record can include the following fields:

| Field | Description |
|---|---|
| `type` | Record type (`profile`) |
| `slug` | LinkedIn profile slug |
| `url` | Full profile URL |
| `name` | Full name (from JSON-LD or Open Graph) |
| `headline` | Current professional headline |
| `summary` | About-section excerpt |
| `location` | City |
| `country` | Country code |
| `image_url` | Profile photo URL |
| `company` | Current employer (from `worksFor`) |
| `company_slug` | LinkedIn company-page identifier |
| `job_title` | Current job title |
| `education` | Alma maters |
| `languages` | Languages spoken (array) |
| `email` | Best email candidate (only when `doEmail=true`) |
| `email_candidates` | Array of candidate emails with `mx_valid`, `deliverable_score`, and `verdict` (only when `doEmail=true`) |

When `doEmail=false`, the `email` and `email_candidates` keys are omitted.

### How to scrape LinkedIn profiles (step-by-step)

1. Open the actor and go to the **Run** tab in the Apify console.
2. Add input one of three ways: paste **profile URLs**, enter **bare slugs**, or type a **people-search query** like "CTO fintech London".
3. Set **Max profiles** (1–100).
4. Toggle **Find emails** on to generate and MX-validate corporate email candidates.
5. Click **Start** and watch profiles stream into the dataset.
6. Export the results to CSV, Excel, JSON, or Google Sheets, or pull them via the Apify API.

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `urls` | array | `[]` | Direct profile URLs (`linkedin.com/in/<slug>`). |
| `slugs` | array | `[]` | Bare profile slugs (e.g. `williamhgates`). |
| `query` | string | `""` | Free-form people-search query, resolved via DuckDuckGo `site:linkedin.com/in`. |
| `maxResults` | integer | `50` | Maximum profiles to scrape (1–100). |
| `doEmail` | boolean | `false` | Generate likely corporate email candidates and validate them via MX records. |

```json
{
    "urls": [
        "https://www.linkedin.com/in/williamhgates",
        "https://www.linkedin.com/in/satyanadella"
    ],
    "query": "CTO fintech London",
    "maxResults": 50,
    "doEmail": true
}
````

### Output example

```json
{
    "type": "profile",
    "slug": "williamhgates",
    "url": "https://www.linkedin.com/in/williamhgates",
    "name": "Bill Gates",
    "headline": "Co-chair, Bill & Melinda Gates Foundation",
    "summary": "Co-chair of the Bill & Melinda Gates Foundation. Founder of Breakthrough Energy …",
    "location": "Seattle",
    "country": "US",
    "image_url": "https://media.licdn.com/dms/image/…",
    "company": "Bill & Melinda Gates Foundation",
    "company_slug": "bill-&-melinda-gates-foundation",
    "job_title": "Co-chair",
    "education": "Harvard University, Lakeside School",
    "languages": ["English"],
    "email": "bill.gates@billandmelindagatesfoundation.com",
    "email_candidates": [
        { "email": "bill.gates@billandmelindagatesfoundation.com", "mx_valid": true, "deliverable_score": 65, "verdict": "probable-deliverable" },
        { "email": "billgates@billandmelindagatesfoundation.com",  "mx_valid": true, "deliverable_score": 65, "verdict": "probable-deliverable" }
    ]
}
```

### Use cases

- **B2B sales outreach** — build prospect lists with name, title, company, and email for cold campaigns.
- **Recruiter sourcing** — find passive candidates by job title and location using people-search queries.
- **CRM enrichment** — fill in title, company, and location for existing contacts at scale.
- **Investor research** — qualify founders and executives before a meeting.
- **Account-based marketing** — build target contact lists for specific companies.
- **PR and media outreach** — find journalists by employer and title.
- **Competitive intelligence** — see who works at your competitors.

### Pricing

This actor runs on Apify's usage-based pricing — you pay for the compute units each run consumes. It is lightweight: memory stays under 256 MB and no Playwright browser is needed. Expect roughly 1–3 seconds per profile without email enrichment, or 3–6 seconds per profile with email finding (extra MX lookups per candidate). See the actor's **Pricing** tab for current details.

### Why use this LinkedIn Profile Scraper instead of Sales Navigator or a paid API?

Sales Navigator and most LinkedIn data APIs require a paid subscription, an authenticated session, or per-credit billing, and they rarely hand you a ready-to-use corporate email. This actor needs **no LinkedIn login and no Sales Navigator seat** — it reads only the public JSON-LD and Open Graph metadata LinkedIn already serves to anonymous visitors, supports URL, slug, and search-query input, and includes a built-in email finder. The trade-off: it returns public-profile fields only and depends on LinkedIn's anonymous HTML, so private or heavily-restricted profiles yield less data.

### FAQ

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

This actor collects only public profile data. Public profile data is generally considered public, and the 2022 *hiQ Labs v. LinkedIn* ruling (US 9th Circuit) found that scraping publicly accessible profiles does not violate the Computer Fraud and Abuse Act. You remain responsible for complying with LinkedIn's User Agreement and laws like GDPR and CCPA when storing personal data, and should consult your legal team for production use.

#### Do I need a LinkedIn account or API key?

No. No LinkedIn login, Sales Navigator subscription, or third-party API key is required.

#### How much does it cost?

Cost scales with usage — the number of profiles and whether email enrichment is on — under Apify's usage-based pricing. There is no fixed per-profile fee from the actor.

#### How accurate is the email finder?

The actor generates the most common corporate-email patterns (`first.last@`, `flast@`, `firstl@`, `first@`) and validates that the domain has a valid MX record. It does not run an SMTP probe; for high-confidence verification, run the results through the Email Verifier actor.

#### Does it work on private profiles?

Public profiles only. Profiles behind privacy restrictions, "Open to work/hire" walls, or premium badges may return less metadata.

#### Will LinkedIn block my Apify IP, and does it use proxies?

Profiles are loaded one at a time at modest concurrency. LinkedIn's anonymous rate-limit (HTTP 999) is detected and reported per profile. For large batches, run in chunks of 50 with a few minutes between runs.

#### Can I export to CSV, Excel, JSON, or Google Sheets?

Yes. Records land in an Apify dataset that exports to CSV, Excel, JSON, or Google Sheets, or via the Apify API and client SDKs.

### Related actors

- [Email Verifier](https://apify.com/hasnainnisar67/email-verifier) — add an SMTP probe to the email candidates for high-confidence verification.
- [Google Maps Leads Scraper](https://apify.com/hasnainnisar67/google-maps-leads-scraper) — build local-business lead lists with emails and phones.
- [Twitter / X Scraper](https://apify.com/hasnainnisar67/twitter-scraper) — bulk tweet and profile scraping for prospect research.
- [Facebook Page Scraper](https://apify.com/hasnainnisar67/facebook-page-scraper) — extract contact info from Facebook business pages.

### Support

Found a bug or need a tweak? Open an issue on the actor's **Issues** tab. Custom lead-generation and enrichment solutions are available on request.

# Actor input Schema

## `urls` (type: `array`):

Direct profile URLs - linkedin.com/in/<slug>

## `slugs` (type: `array`):

Just the slug part of profile URLs (e.g. 'williamhgates' instead of the full URL).

## `query` (type: `string`):

Free-form people-search query (e.g. 'CTO fintech London'). Resolved via DuckDuckGo site:linkedin.com/in - returns up to maxResults profiles.

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

Maximum number of profiles to scrape.

## `doEmail` (type: `boolean`):

If true, generate likely corporate email candidates for each profile and validate via MX records.

## Actor input object example

```json
{
  "urls": [
    "https://www.linkedin.com/in/williamhgates"
  ],
  "slugs": [],
  "query": "",
  "maxResults": 50,
  "doEmail": false
}
```

# 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 = {
    "urls": [
        "https://www.linkedin.com/in/williamhgates"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("hasnainnisar67/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 = { "urls": ["https://www.linkedin.com/in/williamhgates"] }

# Run the Actor and wait for it to finish
run = client.actor("hasnainnisar67/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 '{
  "urls": [
    "https://www.linkedin.com/in/williamhgates"
  ]
}' |
apify call hasnainnisar67/linkedin-profile-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "LinkedIn Profile Scraper - Email Finder, No Login",
        "description": "Scrape public LinkedIn profiles by URL, slug, or search query: name, headline, job title, company, location, education & languages. Built-in email finder with MX validation. No login, no Sales Navigator, no API key.",
        "version": "0.1",
        "x-build-id": "waPDWPmql8hyolCaj"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/hasnainnisar67~linkedin-profile-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-hasnainnisar67-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/hasnainnisar67~linkedin-profile-scraper/runs": {
            "post": {
                "operationId": "runs-sync-hasnainnisar67-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/hasnainnisar67~linkedin-profile-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-hasnainnisar67-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": {
                    "urls": {
                        "title": "LinkedIn profile URLs",
                        "type": "array",
                        "description": "Direct profile URLs - linkedin.com/in/<slug>",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "slugs": {
                        "title": "Profile slugs",
                        "type": "array",
                        "description": "Just the slug part of profile URLs (e.g. 'williamhgates' instead of the full URL).",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "query": {
                        "title": "People search query",
                        "type": "string",
                        "description": "Free-form people-search query (e.g. 'CTO fintech London'). Resolved via DuckDuckGo site:linkedin.com/in - returns up to maxResults profiles.",
                        "default": ""
                    },
                    "maxResults": {
                        "title": "Max profiles",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Maximum number of profiles to scrape.",
                        "default": 50
                    },
                    "doEmail": {
                        "title": "Find emails",
                        "type": "boolean",
                        "description": "If true, generate likely corporate email candidates for each profile and validate via MX records.",
                        "default": false
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
