# Linkedin B2b Email Scraper (`scrapers-hub/linkedin-b2b-email-scraper`) Actor

LinkedIn B2B Email Scraper extracts business emails by keyword and country without cookies - email, email domain, profile title, description, URL and source. 🤝 Reliable B2B prospecting, sales outreach and recruitment sourcing.

- **URL**: https://apify.com/scrapers-hub/linkedin-b2b-email-scraper.md
- **Developed by:** [Scrapers Hub](https://apify.com/scrapers-hub) (community)
- **Categories:** Lead generation, Automation, Social media
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.99 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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 B2B Email Scraper – Extract Business Emails, Leads & Company Contacts

The **LinkedIn B2B Email Scraper** finds publicly indexed business email addresses associated with LinkedIn profiles, company pages, posts and Pulse articles, then returns them as clean, deduplicated lead records. You supply keywords describing the audience you want — an industry, a job title, a niche — and the actor runs targeted search queries scoped to LinkedIn URL patterns, extracts any business email addresses exposed in the indexed content, and writes one dataset item per unique contact.

This LinkedIn email scraper is aimed squarely at B2B lead generation: agencies building prospect lists, sales development teams filling a pipeline, recruiters sourcing candidates, and market researchers mapping who is active in a vertical. Every result carries the keyword that produced it, the LinkedIn URL it came from, the email address, its domain, and the LinkedIn surface it was discovered on — enough context to qualify a lead before anyone writes an outreach line.

***

### 📊 What Data Can You Extract with This LinkedIn Email Scraper?

Each dataset item is a single discovered contact, described by the following groups of fields.

| Category | Fields | What you get |
|---|---|---|
| 📧 Contact data | `email`, `email_domain` | The business email address found, plus its domain isolated for filtering and company matching |
| 🔗 Source attribution | `url`, `scrape_from` | The LinkedIn URL the email was discovered on and the LinkedIn surface type it came from |
| 🏷️ Page context | `title`, `description` | The indexed page title and the surrounding description text, useful for inferring role and company |
| 🎯 Search provenance | `keyword` | The exact keyword from your input that produced this result |
| 🌍 Geography | `country` | The country locale the search was run against |

The pairing that matters most for B2B lead generation is `email_domain` with `title`. The domain tells you which company the contact belongs to and whether it is a corporate address rather than a free consumer mailbox, while the indexed title usually carries the person's headline or the company name — together they let you qualify and segment a raw list without opening a single profile.

***

### 🌟 Key Features of the LinkedIn B2B Email Scraper

| Feature | Description |
|---|---|
| 🎯 Keyword-driven targeting | Supply any number of keywords — industries, job titles, technologies — and each is searched independently |
| 🧭 Surface-level scoping | `scrapeFrom` narrows the hunt to LinkedIn profiles, company pages, posts or Pulse articles, or searches all of them |
| 🏢 B2B-focused extraction | Search patterns are tuned for business domains rather than generic consumer mailboxes |
| 🌍 Country targeting | Set `country` to run searches against a specific national locale for geographically relevant leads |
| 🚫 Automatic deduplication | Emails are tracked globally across the run, so the same address never appears twice in the dataset |
| 🔢 Hard result cap | `maxEmails` stops the run once your target number of unique contacts is reached |
| ⚡ Two engine modes | The `cost-effective` engine runs concurrent asynchronous requests; the `legacy` engine runs sequentially |
| 🧠 Adaptive stopping | The scraper backs off after consecutive pages that yield no new emails instead of grinding through dead pagination |
| 🔄 Automatic proxy rotation | Proxy selection and rotation are handled inside the actor — no proxy configuration is required from you |

***

### 🚀 Why Choose This LinkedIn Email Scraper?

**Every lead arrives with its evidence.** A bare email list is hard to trust. Each record here carries the `url` it was found on, the `title` and `description` of that page, and the `keyword` that surfaced it, so you can sanity-check a contact before it enters your CRM.

**Precise control over which LinkedIn surfaces you mine.** Profile pages, company pages, posts and Pulse articles attract very different kinds of contact data. `scrapeFrom` lets you target the one that fits your motion — company pages for account-based outreach, profiles for individual prospecting.

**Deduplication is built in, not bolted on.** The actor keeps a global set of seen addresses for the whole run, so scraping five keywords across four LinkedIn surfaces still produces a clean list with one row per unique email.

**It stops when it stops being productive.** Rather than paginating blindly, the scraper watches for consecutive pages that return no new emails and ends that branch of the search. That keeps runs short and avoids burning resources on exhausted queries.

***

### 📥 Input

```json
{
  "keywords": ["fitness"],
  "country": "United States",
  "scrapeFrom": "All",
  "maxEmails": 100,
  "engine": "cost-effective"
}
```

#### 🔧 LinkedIn Email Scraper Input Fields

| Field | Type | Required | Default | Description |
|---|---|---|---|---|
| `keywords` | array | No | `["fitness"]` | Search terms describing the audience or niche to find business emails for. Each keyword is searched separately. |
| `country` | string | No | `United States` | Country name used to set the search locale; it is mapped to a country code internally and returned in the `country` output field. |
| `scrapeFrom` | string | No | `All` | Which LinkedIn surface to search: `All`, `Profiles`, `Companies`, `Posts` or `Pulse`. `All` searches each surface in turn. |
| `maxEmails` | integer | No | `100` | Maximum number of unique email addresses to collect before the run stops. |
| `engine` | string | No | `cost-effective` | Scraping engine: `cost-effective` runs concurrent asynchronous requests, `legacy` runs sequentially. |

#### 💡 Input Examples

Build a focused list of SaaS founders from LinkedIn profiles:

```json
{
  "keywords": ["saas founder", "b2b software ceo"],
  "scrapeFrom": "Profiles",
  "maxEmails": 200
}
```

Target company pages in a specific market:

```json
{
  "keywords": ["logistics", "freight forwarding"],
  "country": "Germany",
  "scrapeFrom": "Companies",
  "maxEmails": 150
}
```

Mine long-form Pulse articles for thought-leader contacts:

```json
{
  "keywords": ["cybersecurity", "zero trust"],
  "scrapeFrom": "Pulse",
  "maxEmails": 100,
  "engine": "cost-effective"
}
```

***

### 📤 Output

```json
{
  "keyword": "fitness",
  "title": "Sarah Whitfield - Head of Partnerships - Northline Fitness | LinkedIn",
  "url": "https://www.linkedin.com/in/example-profile",
  "description": "Head of Partnerships at Northline Fitness. Contact: partnerships@northlinefitness.com for collaboration enquiries.",
  "email": "partnerships@northlinefitness.com",
  "email_domain": "northlinefitness.com",
  "country": "us",
  "scrape_from": "linkedin.com"
}
```

#### 🧾 LinkedIn B2B Email Output Fields

| Field | Type | Description |
|---|---|---|
| `keyword` | string | null | Keyword that produced this item. |
| `title` | string | null | Title of the indexed LinkedIn page the email was found on. |
| `url` | string | null | Canonical URL of the scraped item. |
| `description` | string | null | Long-form description text surrounding the match. |
| `email` | string | null | Email address found for the item. |
| `email_domain` | string | null | Email domain of the item. |
| `country` | string | null | Country locale the search was run against. |
| `scrape_from` | string | null | The LinkedIn source domain the result was scraped from. |

***

### 💻 How to Use the LinkedIn B2B Email Scraper (Step by Step)

#### Step 1: Define the keywords that describe your ideal customer

Everything starts with `keywords`. Think in the language your prospects use about themselves rather than the language you use about them — job titles, product categories, industry terms, technologies. Several narrow keywords almost always outperform one broad one, because each is searched independently and a vague term returns generic pages with few extractable business emails.

#### Step 2: Choose the LinkedIn surface to target

`scrapeFrom` decides where the LinkedIn email scraper looks. `Profiles` restricts the search to individual profile URLs, which suits person-level prospecting. `Companies` targets organisation pages, which fits account-based outreach. `Posts` and `Pulse` cover published content, where authors frequently include a contact address. `All` sweeps every surface in turn, which finds more but takes longer.

#### Step 3: Set the country locale

`country` accepts a country name such as "United States" or "Germany" and is mapped internally to a search locale. This matters more than people expect: search results are localised, so setting the right country substantially changes which companies and profiles surface. The resolved code is echoed back in each record's `country` field.

#### Step 4: Cap the run with maxEmails

`maxEmails` is a hard ceiling on unique addresses. The run ends as soon as it is reached, regardless of how many keywords remain. For a first pass, set something modest — 50 to 100 — confirm the quality of what comes back, then raise it once you know your keywords are pulling the right audience.

#### Step 5: Pick an engine

`cost-effective` is the default and runs several requests concurrently, which is the right choice for most jobs. `legacy` runs sequentially and uses a different proxy strategy; keep it in reserve for cases where the default engine returns unusually thin results for a particular market.

#### Step 6: Run the scraper and read the log

Start the run and follow the log. It reports each keyword and surface combination as it is processed, how many new emails each page yielded, and when it stops a branch because consecutive pages produced nothing new. A keyword that reports zero new emails across several pages is telling you it is too broad or too obscure — adjust it and rerun rather than waiting it out.

#### Step 7: Qualify and export the lead list

Open the Dataset tab when the run completes. Sort or filter by `email_domain` to group contacts by company, and scan `title` and `description` to confirm the role and organisation before importing. Export as CSV or JSON, or pull the items through the API into your CRM or outreach tool.

***

### 🔌 API Access & Integrations

Run the LinkedIn B2B email scraper and get the leads back synchronously:

```bash
curl -X POST "https://api.apify.com/v2/acts/scrapers-hub~linkedin-b2b-email-scraper/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "keywords": ["saas founder"],
    "country": "United States",
    "scrapeFrom": "Profiles",
    "maxEmails": 100
  }'
```

The equivalent call in Python using `apify_client`:

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_TOKEN")

run = client.actor("scrapers-hub/linkedin-b2b-email-scraper").call(
    run_input={
        "keywords": ["logistics", "freight forwarding"],
        "country": "Germany",
        "scrapeFrom": "Companies",
        "maxEmails": 150,
    }
)

for lead in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(lead["email"], "|", lead["email_domain"], "|", lead["title"])
```

Results are stored in a standard Apify dataset, so they connect directly to Zapier, Make, Google Sheets or Slack, or you can attach a webhook to push new leads into your CRM the moment a run finishes.

***

### 💡 Best Use Cases for LinkedIn B2B Email Data

#### 🎯 Outbound prospect list building

Run several keywords describing your ideal customer profile with `scrapeFrom` set to `Profiles`, then filter the results on `email_domain` to keep corporate addresses only. The `title` field usually contains the person's headline, which gives you enough to personalise a first-touch message.

#### 🏢 Account-based marketing research

Setting `scrapeFrom` to `Companies` produces contacts tied to organisation pages rather than individuals. Grouping the output by `email_domain` gives you a per-account contact map, and `description` often reveals what the company positions itself as — the raw material for account-specific messaging.

#### 🧑‍💼 Recruitment and talent sourcing

Search on role keywords and skill terms to surface professionals publishing in a specialism. The `url` field takes you straight back to the LinkedIn page, so a recruiter can verify the person's background before reaching out through any channel.

#### 📊 Market and competitor mapping

Run the same keyword set across several values of `country` and compare the `email_domain` distributions. Which companies appear, how often, and in which markets is a fast way to sketch a competitive landscape without buying a market report.

#### 🤝 Partnership and business development

Partnership and BD contacts are frequently published deliberately on company pages and in posts. Filtering results where the `email` local part suggests a partnerships or business development function gives you a warm-ish list of people whose job is to take exactly this kind of call.

#### 📰 Content marketing and PR outreach

Targeting `Pulse` and `Posts` finds people actively publishing in your topic area. Their `description` text tells you what they write about, which lets you pitch a genuinely relevant story rather than a generic press release.

#### 🔍 CRM enrichment and gap filling

If your CRM has company records without contact addresses, run the scraper on those company names as keywords and match results back on `email_domain`. It is a practical way to fill gaps in an existing database rather than building a list from scratch.

***

### ⚙️ Tips for Better LinkedIn Email Scraping Results

- **Use several specific keywords rather than one broad term.** "Fractional CFO" will out-perform "finance" every time, because generic terms return pages that rarely expose a business email.
- **Match `country` to the market you sell into.** Search results are localised, and leaving the default in place while targeting a European market will quietly skew your list towards the wrong companies.
- **Start with a low `maxEmails` to validate keyword quality.** A 50-email test run tells you within minutes whether your keyword set is pulling the right audience, which is much cheaper than discovering it at 500.
- **Filter out free-mail domains after the run.** Check `email_domain` against the usual consumer providers and drop or down-rank them if you only want corporate contacts.
- **Vary `scrapeFrom` across runs rather than always using `All`.** Targeted runs per surface produce cleaner, more interpretable lists and make it obvious which surface is actually productive for your niche.
- **Verify addresses before sending.** Any email harvested from indexed content should be validated for deliverability before it enters a live campaign, to protect your sender reputation.

***

### 🛠️ Troubleshooting

**The run finished with very few emails.**
This almost always comes down to keyword breadth. Extremely broad terms return pages with no contact details, and extremely obscure terms return almost nothing at all. Try three to five mid-specificity keywords, and confirm that `scrapeFrom` is not restricting you to a surface where your audience does not publish.

**The scraper stopped before reaching `maxEmails`.**
That is deliberate. When several consecutive pages produce no new unique emails, the scraper ends that search branch rather than paginating into exhausted results. Add more keywords if you need a bigger list.

**I am seeing consumer email domains in the results.**
The extraction is tuned towards business domains, but publicly posted contact details sometimes use free providers. Filter on `email_domain` after the run to enforce a corporate-only list.

**Results look thin for a non-English market.**
Set `country` to the target market and use keywords in that market's language. Searching English terms against a localised index is a common cause of sparse results.

**The same company appears many times.**
That is expected when a company publishes several contact addresses across its pages. Deduplicate on `email_domain` rather than `email` if you want one contact per organisation.

***

### ❓ Frequently Asked Questions About LinkedIn B2B Email Scraping

**What does this LinkedIn B2B email scraper actually collect?**
It collects business email addresses that appear in publicly indexed LinkedIn content — profiles, company pages, posts and Pulse articles — along with the page title, description, source URL and the keyword that surfaced each result.

**Does the scraper log into LinkedIn?**
No. It works entirely from publicly indexed content and does not authenticate, access private profile data, or use any LinkedIn account.

**How do I target a specific job title or industry?**
Put the title or industry into the `keywords` array. Each keyword is searched separately, so you can combine several roles and verticals in one run.

**Can I restrict the search to LinkedIn company pages only?**
Yes. Set `scrapeFrom` to `Companies`. The other options are `Profiles`, `Posts`, `Pulse` and `All`.

**How many leads can I collect in a single run?**
As many as `maxEmails` allows. The default is 100, and the run stops as soon as that many unique addresses have been collected.

**Are duplicate email addresses removed?**
Yes. The actor tracks every address it has already emitted for the whole run, so each unique email appears once regardless of how many keywords or surfaces produced it.

**What is the difference between the cost-effective and legacy engines?**
`cost-effective` is the default and issues concurrent asynchronous requests. `legacy` processes searches sequentially with a different proxy strategy. Most users should stay on the default.

**Can I target leads in a specific country?**
Yes. The `country` input takes a country name and sets the search locale accordingly; the resolved code is returned in each record's `country` field.

**Do I need to configure proxies for this LinkedIn scraper?**
No. Proxy rotation is handled automatically by the actor and there is no proxy setting to configure.

**Are the extracted emails verified as deliverable?**
No. The scraper reports addresses as it finds them in public content. Run them through an email verification step before any live campaign.

**What does the `scrape_from` field tell me?**
It records the LinkedIn source domain the result came from, which is useful when you are searching several surfaces in one run and want to know where each lead originated.

**Can I use this LinkedIn email scraper for cold outreach?**
Only where the law allows it. Business-to-business email marketing rules differ sharply by jurisdiction — GDPR and PECR in Europe, CAN-SPAM in the United States — and compliance is your responsibility, not the tool's.

**How do I export the scraped LinkedIn leads to my CRM?**
Export the dataset as CSV, Excel or JSON from the console, or pull it through the Apify API. Webhooks, Zapier, Make and Google Sheets integrations all work with the standard dataset.

**Why is the `description` field empty on some records?**
Not every indexed page exposes a snippet. When no description text is available the field is null, while the email, URL and title are still returned.

**Can I schedule the LinkedIn B2B email scraper to run regularly?**
Yes. Apify's scheduler can run it on any cadence, which suits teams that want a steady trickle of new leads rather than one large batch.

***

### 🆘 Support & Feedback

If the LinkedIn B2B email scraper behaves unexpectedly for a particular keyword set or market, open a report on the actor's **Issues** tab and include the input you used. That makes it far easier to reproduce and fix.

For custom work — additional enrichment fields, a different targeting strategy, or a direct integration with your sales stack — email **scraperhubapi@gmail.com**.

If the actor helps your pipeline, please leave a review on the actor page. It genuinely helps other teams find it.

***

### ⚖️ Disclaimer

This LinkedIn B2B email scraper collects only publicly available, indexed information. It does not log in to LinkedIn, access private profiles or connections, or bypass any access control or paywall.

Email addresses and profile details are personal data under GDPR, the UK GDPR, CCPA and comparable laws. You are responsible for establishing a lawful basis before processing them, for honouring opt-out and erasure requests, and for complying with anti-spam legislation including CAN-SPAM, CASL and PECR before contacting anyone on a scraped list. Collecting an address is not the same as having permission to email it.

Your use of the actor must also comply with LinkedIn's terms of service, the terms of any search service involved, and Apify's platform terms. The output is provided as-is with no warranty of accuracy or deliverability.

If you believe personal data collected through this actor should be removed, contact **scraperhubapi@gmail.com** and the request will be handled.

# Actor input Schema

## `keywords` (type: `array`):

Enter one or more keywords to search for on Linkedin.

## `country` (type: `string`):

Specify the country to target for Google search results.

## `scrapeFrom` (type: `string`):

Choose one option — All, Profile, Company, Posts, or Pulse.

## `engine` (type: `string`):

Choose scraping engine. 🚀 Cost Effective (New): Uses residential proxies with async requests for faster, cheaper scraping. 🔧 Legacy: Uses GOOGLE\_SERP proxy with traditional selectors - more reliable but slower and more expensive.

## `maxEmails` (type: `integer`):

Enter the maximum number of emails to collect.

## Actor input object example

```json
{
  "keywords": [
    "developer",
    "founder"
  ],
  "country": "United States",
  "scrapeFrom": "All",
  "engine": "legacy",
  "maxEmails": 20
}
```

# Actor output Schema

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

Records scraped by Linkedin B2b Email Scraper, stored in the run's default dataset.

# 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 = {
    "keywords": [
        "developer",
        "founder"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapers-hub/linkedin-b2b-email-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 = { "keywords": [
        "developer",
        "founder",
    ] }

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

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

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

```

## CLI example

```bash
echo '{
  "keywords": [
    "developer",
    "founder"
  ]
}' |
apify call scrapers-hub/linkedin-b2b-email-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,scrapers-hub/linkedin-b2b-email-scraper"
        }
    }
}

```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/DQ2dr8pOYJ3kJJR4z/builds/cYVZRfQKh15NFctJp/openapi.json