# LinkedIn Email Scraper (`email_scraper/linkedin-email-scraper`) Actor

LinkedIn Email Scraper finds publicly indexed email addresses from LinkedIn search results using targeted keywords, locations, and custom email domains. Extract structured LinkedIn contact data for lead generation, prospecting, market research, and CRM enrichment.

- **URL**: https://apify.com/email\_scraper/linkedin-email-scraper.md
- **Developed by:** [Email Scraper](https://apify.com/email_scraper) (community)
- **Categories:**
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.49 / 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.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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 Email Scraper Overview

**LinkedIn Email Scraper** is an Apify Actor designed to discover publicly indexed email addresses associated with LinkedIn profiles and pages through keyword-focused search. It is useful for lead generation, prospect research, market research, contact discovery, and building structured datasets from publicly available search results.

The **LinkedIn Email Scraper** accepts multiple keywords, optional geographic targeting, custom email domains, and exclusion terms. It then processes each keyword and email-domain combination, identifies matching LinkedIn search results, extracts publicly visible email addresses, removes duplicates, and stores the results in an Apify dataset.

This approach makes the **LinkedIn Email Scraper** useful when you need targeted contact discovery without manually reviewing large numbers of search results.

### LinkedIn Email Scraper Features

The **LinkedIn Email Scraper** provides several controls for refining search coverage and output quality.

- **Keyword-based discovery:** Search using job titles, professions, industries, skills, or other relevant terms.
- **Multiple keyword support:** Submit several search terms in a single run to expand coverage.
- **Location filtering:** Narrow results by country, state, city, or another geographic term.
- **Custom email domains:** Search for specific domains such as `@gmail.com`, `@yahoo.com`, or business domains.
- **Per-combination email target:** Set a maximum number of emails for each keyword and domain combination.
- **Exclude-word filtering:** Skip search-result snippets containing selected words or phrases.
- **Duplicate prevention:** The same email address is not added repeatedly during a run.
- **Structured dataset output:** Results are pushed incrementally into the Apify dataset.
- **Progress persistence:** Processing state is saved so work can continue from the stored position after an interruption.
- **Search pagination:** The Actor can continue through multiple search-result pages when additional matching data is available.

### How to Use the LinkedIn Email Scraper

Using the **LinkedIn Email Scraper** starts with defining the type of LinkedIn contacts you want to discover.

First, enter one or more values in the **Keywords or Queries** field. Specific combinations are generally more useful than a single broad word. For example, instead of only entering `Fitness`, you can use terms such as `Fitness Coach`, `Fitness Trainer`, `Fitness Influencer`, and `Online Fitness Coach`.

Next, optionally enter a **Region / Location**. A value such as `New York`, `United States`, or another geographic term can help narrow the search.

You can then specify one or more **email domain suffixes**. The Actor searches for email addresses matching those domains. This makes the **LinkedIn Email Scraper** useful for both consumer email discovery and targeted business-domain research.

The **Max Emails** setting controls the target for each keyword and domain combination. For example, with three keywords, two domains, and a limit of 20, the Actor works through six combinations and targets up to 20 addresses for each combination.

Finally, use **Exclude words** when you want to ignore snippets containing unwanted words or phrases. This can help remove irrelevant results before an email is collected.

### LinkedIn Email Scraper Data Extraction

The core purpose of the **LinkedIn Email Scraper** is to turn relevant search results into structured contact records.

For each qualifying result, the Actor can capture the search keyword, result title, descriptive text, LinkedIn-related URL, and matching email address. Each discovered email is checked against the selected domain filters before being stored.

The Actor also keeps track of previously collected email addresses during processing. This duplicate detection helps maintain a cleaner contact dataset when different keyword searches surface the same address.

Because the extraction is based on publicly indexed search-result information, the resulting dataset represents contact information that is publicly available through the searched results rather than private LinkedIn profile data.

### LinkedIn Email Scraper Use Cases

The **LinkedIn Email Scraper** can support several practical data collection workflows.

#### Lead Generation

Sales teams can use targeted keywords and locations to build prospecting datasets around specific roles, industries, or markets.

#### Market Research

Researchers can collect structured contact and profile-related search-result information for studying professional segments and market categories.

#### Competitor Research

Businesses can create focused datasets around job titles, industries, or geographic markets to better understand publicly discoverable professional activity.

#### CRM Enrichment

Existing prospecting workflows can use discovered email addresses alongside titles, descriptions, keywords, and URLs to create richer contact records.

#### Business Intelligence

Structured outputs can be exported into downstream analysis workflows for segmentation, filtering, and comparison.

#### Academic and Content Research

Researchers can collect targeted public contact information for studies, professional discovery, and niche research projects while respecting applicable privacy and data-use requirements.

### LinkedIn Email Scraper Input

The **LinkedIn Email Scraper** supports the following input parameters.

| Input           | Type             | Required | Default                            | Description                                                                          |
| --------------- | ---------------- | -------- | ---------------------------------- | ------------------------------------------------------------------------------------ |
| `keywords`      | Array of strings | Yes      | `["manager", "Assistant manager"]` | Search keywords or queries used to discover relevant LinkedIn results.               |
| `location`      | String           | No       | `""`                               | Optional country, state, city, or geographic term used to narrow searches.           |
| `customDomains` | Array of strings | No       | `["@gmail.com"]`                   | Email domain suffixes to search for, such as `@gmail.com` or `@yahoo.com`.           |
| `maxEmails`     | Integer          | No       | `10`                               | Maximum email target for each keyword + domain combination. Allowed range: 1–10,000. |
| `excludeWords`  | Array of strings | No       | `[]`                               | Words or phrases that cause matching search-result snippets to be skipped.           |

#### Keyword Input

The `keywords` parameter is the primary targeting mechanism for the **LinkedIn Email Scraper**.

Use multiple specific terms when you need broader or more specialized coverage. Different job titles, roles, industries, or descriptive phrases can create different search opportunities.

#### Location Input

The `location` field is optional. Leaving it empty allows searches without a geographic term. Providing a location adds that term to the search criteria and can help focus results on a particular market.

#### Email Domain Input

The `customDomains` field determines which email-domain suffixes are accepted. Multiple domains can be supplied, allowing the **LinkedIn Email Scraper** to process separate keyword-domain combinations.

#### Maximum Email Target

The `maxEmails` value is applied independently to each keyword and domain combination. It is not a single shared limit across the entire run.

The Actor can accept values from `1` through `10,000`. Actual results can be lower because the Actor only collects matching addresses that are discoverable in the available search results.

#### Exclusion Input

The `excludeWords` field accepts words or phrases. Matching is case-insensitive. Single words are evaluated as whole words, while phrases are matched as phrases within the result description.

### LinkedIn Email Scraper Output Data

The **LinkedIn Email Scraper** writes structured records to the Apify dataset.

| Field         | Type   | Description                                                  |
| ------------- | ------ | ------------------------------------------------------------ |
| `network`     | String | Identifies the source network as `LinkedIn.com`.             |
| `keyword`     | String | Keyword that produced the matching search result.            |
| `title`       | String | Title of the search result.                                  |
| `description` | String | Description or snippet associated with the result.           |
| `url`         | String | URL associated with the search result.                       |
| `email`       | String | Email address matching one of the requested domain suffixes. |

The main contact value is the `email` field, while the accompanying `keyword`, `title`, `description`, and `url` fields provide context about where the address was discovered.

This structure makes the **LinkedIn Email Scraper** suitable for filtering, exporting, reviewing, and transforming records after a run. The dataset view is configured to display the keyword, title, description, URL, and email as the primary visible fields.

### Example Input

The following example uses only supported input fields:

```json
{
  "keywords": [
    "Fitness Coach",
    "Fitness Trainer",
    "Online Fitness Coach"
  ],
  "location": "New York",
  "customDomains": [
    "@gmail.com",
    "@yahoo.com"
  ],
  "maxEmails": 20,
  "excludeWords": [
    "crypto",
    "onlyfans"
  ]
}
```

This configuration creates separate search combinations for each keyword and selected email domain while applying the optional location and exclusion filters.

### Example Output

A representative output record from the **LinkedIn Email Scraper** has this structure:

```json
{
  "network": "LinkedIn.com",
  "keyword": "Fitness Coach",
  "title": "Fitness Coach - LinkedIn",
  "description": "Example publicly indexed result containing contact information",
  "url": "https://www.linkedin.com/...",
  "email": "example@gmail.com"
}
```

The exact title, description, URL, and email depend on the search results available during the run. The Actor does not guarantee that every keyword will produce the requested target.

### LinkedIn Email Scraper Data Quality and Reliability

The **LinkedIn Email Scraper** uses multiple controls to improve result consistency.

Searches are processed across keyword and domain combinations rather than treating the entire run as one undifferentiated search. This helps maintain targeted coverage and makes the resulting dataset easier to interpret.

The Actor also uses pagination to continue searching beyond the first page when useful results remain available. Processing can stop when repeated pages produce no new emails, when result availability becomes too sparse, or when the configured target is reached.

Duplicate email detection is applied throughout the run. This helps prevent repeated addresses from being inserted when several searches discover the same contact.

The Actor stores progress information during processing and pushes records incrementally to the dataset. This means collected records are not dependent on waiting until the very end of the run before being written.

Actual result volume depends on the quality and breadth of the supplied keywords, domain filters, location criteria, and publicly indexed information.

### Search Intent with the LinkedIn Email Scraper

People searching for a **LinkedIn Email Scraper** often want more than a simple list of search results. They want actionable contact data that can be filtered, reviewed, exported, or incorporated into a larger prospecting workflow.

The **LinkedIn Email Scraper** is designed around this intent by combining search targeting with structured email extraction.

Common tasks include finding email addresses for a specific job role, discovering professionals in a particular city, searching for addresses under a selected email domain, and building a dataset from multiple related queries.

The combination of keyword targeting, location filtering, email-domain selection, exclusion rules, and structured output makes the Actor appropriate for both focused searches and broader contact discovery campaigns.

### Frequently Asked Questions

#### What is the LinkedIn Email Scraper?

The **LinkedIn Email Scraper** is an Apify Actor that discovers publicly indexed email addresses associated with LinkedIn search results using keyword-based searches and domain filters.

#### How does the LinkedIn Email Scraper work?

The **LinkedIn Email Scraper** processes each supplied keyword and email-domain combination, examines matching search results, extracts qualifying email addresses, removes duplicates, and stores structured records in the Apify dataset.

#### What data can the LinkedIn Email Scraper extract?

The Actor produces `network`, `keyword`, `title`, `description`, `url`, and `email` fields. The `email` field contains an address matching one of the configured domain suffixes.

#### Can I use multiple keywords?

Yes. The **LinkedIn Email Scraper** accepts an array of keyword values, allowing multiple roles, professions, industries, or search phrases to be processed within one run.

#### Can I target a city or country?

Yes. The optional `location` field can contain a country, state, city, or other geographic term. Leaving the field empty removes the location filter.

#### Can I search multiple email domains?

Yes. The `customDomains` field accepts multiple domain suffixes. Each selected keyword and domain is processed as its own combination.

#### Is `maxEmails` a global limit?

No. In the **LinkedIn Email Scraper**, the configured target applies independently to each keyword and email-domain combination. The final total can therefore be larger than the value entered in `maxEmails`.

#### Why did my run return fewer emails than requested?

The **LinkedIn Email Scraper** can only collect matching addresses that are publicly discoverable in the processed search results. Narrow keywords, restrictive locations, limited domains, or sparse indexed results can reduce the final count.

#### Can I exclude unwanted result categories?

Yes. The `excludeWords` input allows you to specify words or phrases. When a matching term appears in a result description, that snippet is skipped rather than being used for email extraction.

#### Does the Actor remove duplicates?

Yes. The **LinkedIn Email Scraper** tracks discovered email addresses and avoids adding the same address multiple times during processing.

#### What happens when there are no useful results?

The Actor can stop searching when repeated pages produce no new email addresses or when search-result availability becomes too low to justify continuing. This prevents unnecessary processing of consistently unproductive pages.

#### Does the output contain LinkedIn URLs?

Yes. The `url` field stores the URL associated with the search result from which the record was extracted.

#### Can I use the output for lead generation?

The structured email and contextual fields can support lead-generation workflows, prospect research, market segmentation, and CRM enrichment. Users should ensure that their use of collected information complies with applicable laws, platform rules, and privacy requirements.

### LinkedIn Email Scraper Limits and Result Expectations

The **LinkedIn Email Scraper** supports a configurable `maxEmails` value from 1 to 10,000 for each keyword and domain combination.

A requested target should be treated as a maximum collection goal rather than a guarantee of available data. The Actor may finish below that target when matching public results are limited or when search pages stop yielding new email addresses.

For free users, the implementation applies a maximum of **100 collected emails** when the requested target would otherwise exceed that threshold. Paid users are not subject to this code-level free-user ceiling.

Because result availability varies, broader but still relevant keywords can often provide more coverage than highly restrictive queries.

### Why Use the LinkedIn Email Scraper

The **LinkedIn Email Scraper** reduces repetitive manual search work by turning keyword-driven discovery into an automated dataset-building process.

Instead of opening individual results and manually copying contact information, users can define search criteria and let the Actor process multiple combinations automatically.

Its structured output makes downstream review easier, while duplicate detection helps keep records cleaner. Incremental dataset writes and saved progress also make longer runs easier to manage.

For users building targeted professional contact datasets, these capabilities can save time while preserving the ability to control exactly which keywords, locations, and email domains are searched.

### API and Automation

The **LinkedIn Email Scraper** runs as an Apify Actor, so it can be incorporated into workflows that use Apify's standard Actor execution and dataset capabilities.

A typical workflow is to provide the input JSON, start the Actor, monitor execution, and retrieve the resulting dataset after processing. The resulting records can then be reviewed or passed into other data-processing steps supported by your broader Apify workflow.

The Actor itself does not require additional custom input fields beyond those documented in this README.

### Best Practices for the LinkedIn Email Scraper

For stronger results, use multiple specific but relevant keywords instead of relying on one generic term.

Combine role-based terms with industry or specialization terms where appropriate. For geographic campaigns, use a location that matches the audience you are targeting.

When searching for several types of email addresses, provide multiple domain suffixes. For example, business-domain searches can complement common public email domains.

Use `excludeWords` selectively. Too many exclusion terms can remove potentially useful records, while focused exclusions can help reduce irrelevant snippets.

Finally, treat the requested email count as a target rather than an availability guarantee. Publicly indexed data naturally varies between searches and markets.

### Support

For technical issues, unexpected behavior, or feature requests related to the **LinkedIn Email Scraper**, use the support and issue-reporting options available on the Actor's Apify Store page.

When reporting an issue, include the relevant input configuration and a description of the observed behavior. This makes it easier to investigate problems without exposing private credentials or sensitive information.

- Contact : <alphascraper69@gmail.com>

# Actor input Schema

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

A list of keywords or queries to search for.

## `location` (type: `string`):

Optional country, state or city used to narrow the search. Leave it empty to search without a geographic filter.

## `customDomains` (type: `array`):

List of custom email domains

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

How many addresses each search keyword + domain suffix combination may collect before the finder moves on to the next one. This is a per-combination target, not a run-wide total: with 3 keyword and 2 Domains and a limit of 20, the run works through all 6 combinations and aims for up to 20 addresses in each, so up to 120 overall. Lower values finish sooner and cost less; higher values dig deeper but never guarantee a fuller result, since the run can only find what is publicly listed.

## `excludeWords` (type: `array`):

Words or phrases you do not want to see.

## Actor input object example

```json
{
  "keywords": [
    "manager",
    "Assistant manager"
  ],
  "location": "New york",
  "customDomains": [
    "@gmail.com"
  ],
  "maxEmails": 10,
  "excludeWords": []
}
```

# Actor output Schema

## `dataset` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "keywords": [
        "manager",
        "Assistant manager"
    ],
    "location": "New york",
    "customDomains": [
        "@gmail.com"
    ],
    "excludeWords": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("email_scraper/linkedin-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": [
        "manager",
        "Assistant manager",
    ],
    "location": "New york",
    "customDomains": ["@gmail.com"],
    "excludeWords": [],
}

# Run the Actor and wait for it to finish
run = client.actor("email_scraper/linkedin-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": [
    "manager",
    "Assistant manager"
  ],
  "location": "New york",
  "customDomains": [
    "@gmail.com"
  ],
  "excludeWords": []
}' |
apify call email_scraper/linkedin-email-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,email_scraper/linkedin-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/PWQXDuaxyBp3KitLg/builds/Z3HuNG7QUvdCTZz3e/openapi.json