# Npmjs Email Scraper (`email_scraper/npmjs-email-scraper`) Actor

npmjs Email Scraper finds publicly indexed npm contact emails using targeted keywords, locations, and custom email domains. Extract structured lead data with titles, descriptions, URLs, and emails for developer research, package outreach, and B2B prospecting.

- **URL**: https://apify.com/email\_scraper/npmjs-email-scraper.md
- **Developed by:** [Email Scraper](https://apify.com/email_scraper) (community)
- **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?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

### 🔍 npm Email Scraper – Overview

**npm Email Scraper** is an Apify Actor built to discover publicly indexed email addresses associated with npm search results using targeted keywords, email domains, and optional geographic terms.

Instead of manually searching npm-related pages one query at a time, the **npm Email Scraper** lets you define a list of keywords and email suffixes, then builds targeted searches around those combinations. Matching contact emails are collected into a structured Apify Dataset together with the search keyword, result title, description, and URL.

The Actor is especially useful for **developer research, npm package ecosystem research, technical prospecting, software-related lead discovery, developer outreach, and contact-data research** where publicly indexed information is relevant.

> 💡 **Why use npm Email Scraper?**
>
> - Search for npm-related contacts using specific keywords.
> - Target different email providers or custom domains.
> - Narrow searches by country, state, or city.
> - Exclude unwanted terms from search-result descriptions.
> - Collect structured email lead records in an Apify Dataset.
> - Automatically avoid duplicate email addresses during a run.

The easiest workflow is simple: enter your keywords, optionally add a location, select the email domains you want to find, choose an email target, and run the Actor.

***

### 🔹 npm Email Scraper – Key Features

The **npm Email Scraper** is designed around targeted search rather than broad, unfiltered contact collection. Its configuration gives you several ways to control search intent and improve the relevance of returned results.

> ⭐ **Key Features**
>
> - Keyword-based npm contact discovery
> - Multiple keywords per run
> - Optional location targeting
> - Multiple custom email domains
> - Configurable email collection target
> - Exclude-word and phrase filtering
> - Duplicate email prevention
> - Incremental Dataset output
> - Resume support for interrupted runs
> - Structured title, description, URL, and email fields

#### 🎯 Keyword-Based Search

The required `keywords` input accepts multiple search terms. This makes it possible to target different developer roles, technical specialties, or npm-related topics in one run.

For example, instead of using only `Developer`, you can provide:

- `Web Developer`
- `JavaScript Developer`
- `Node.js Developer`
- `Frontend Developer`
- `Backend Developer`
- `npm Package Developer`

More specific keywords can make search intent clearer and help you build a more focused dataset.

#### 📧 Custom Email Domains

The **npm Email Scraper** supports custom email suffixes instead of limiting searches to one provider.

Examples include:

- `@gmail.com`
- `@yahoo.com`
- `@outlook.com`
- `@hotmail.com`
- `@icloud.com`
- Custom business domains

Each selected domain is processed separately with each keyword.

#### 🌍 Location Filtering

The optional `location` field allows you to add a country, state, or city to the search.

For example:

- `United States`
- `California`
- `San Francisco`
- `London`
- `Canada`

You can leave the field empty when you want to search without a geographic filter.

#### 🚫 Exclude Unwanted Results

The `excludeWords` option helps remove search-result snippets containing terms you do not want.

For example:

- `crypto`
- `onlyfans`
- `gaming`

If an exclusion term appears in a matching result description, that entire snippet is skipped and no email is extracted from it.

***

### 🔹 npm Email Scraper – What Data You Can Extract

The **npm Email Scraper** produces structured records from matching search results.

The primary contact information is the extracted email address, while additional fields provide context about where the address was discovered.

> 📊 **Output Fields**
>
> - **keyword** — The keyword responsible for the search.
> - **title** — The title of the matching search result.
> - **description** — The publicly available search-result description or snippet.
> - **url** — The URL associated with the search result.
> - **email** — The discovered email address.
> - **network** — The source identifier included by the Actor in each pushed record.

The configured Dataset view displays `keyword`, `title`, `description`, `url`, and `email` as its main table columns.

#### 📋 Example Output

A representative record has this structure:

```json
{
  "network": "npm.com",
  "keyword": "Web Developer",
  "title": "Example npm Result",
  "description": "Developer contact information ... developer@example.com",
  "url": "https://www.npmjs.com/...",
  "email": "developer@example.com"
}
```

Actual values depend on the publicly indexed results available for your chosen search terms.

The Actor extracts emails from search-result descriptions. Therefore, the presence and quantity of contact information depend on what is publicly indexed and visible in matching results.

***

### 🔹 npm Email Scraper – How to Use It

Using the **npm Email Scraper** requires only a few input settings.

#### 1. Enter Keywords

Add one or more keywords to the `keywords` field.

Example:

```json
{
  "keywords": [
    "Developer",
    "Web Developer",
    "JavaScript Developer"
  ]
}
```

Using several related terms allows the Actor to search different combinations rather than relying on one broad phrase.

#### 2. Add a Location

If geographic targeting is useful, enter a country, state, or city.

Example:

```text
San Francisco
```

To search without geographic filtering, leave `location` empty.

#### 3. Select Email Domains

Add the email suffixes you want to target.

Example:

```json
{
  "customDomains": [
    "@gmail.com",
    "@outlook.com",
    "@yahoo.com"
  ]
}
```

Each domain is searched independently for each keyword.

#### 4. Set `maxEmails`

The `maxEmails` input controls the target for each keyword + domain combination.

For example, if you provide:

- 3 keywords
- 2 email domains
- `maxEmails = 20`

the Actor processes 6 separate combinations and targets up to 20 emails for each combination, subject to available results and duplicate handling.

#### 5. Add Exclusion Terms

If certain categories or words should be ignored, add them to `excludeWords`.

Example:

```json
{
  "excludeWords": [
    "crypto",
    "onlyfans"
  ]
}
```

#### 6. Start the Run

After configuring the inputs, start the Actor.

Results are pushed incrementally into the **npm Emails Dataset**, while discovered email addresses are tracked to help prevent duplicates.

***

### 🔹 How to Scrape npm Emails by Keyword

To **scrape npm emails by keyword**, use the required `keywords` field with specific search terms related to your research objective.

For example:

```json
{
  "keywords": [
    "Node.js Developer",
    "JavaScript Developer",
    "Frontend Developer"
  ],
  "customDomains": [
    "@gmail.com",
    "@outlook.com"
  ],
  "maxEmails": 10
}
```

The Actor creates targeted searches around each keyword and email-domain combination.

This approach can be useful for **developer discovery, software ecosystem research, technical outreach, package research, and prospecting**.

Keep in mind that `maxEmails` is a target rather than a guarantee. If publicly indexed search results do not contain enough matching addresses, the Actor cannot manufacture additional contacts.

***

### 🔹 How to Find npm Developer Emails

If your goal is developer contact discovery, use specific role or technology keywords.

Useful examples include:

- `Web Developer`
- `JavaScript Developer`
- `Node.js Developer`
- `Frontend Developer`
- `Backend Developer`
- `React Developer`
- `TypeScript Developer`
- `Software Developer`
- `npm Package Developer`

You can combine these keywords with multiple email domains to expand the range of publicly indexed contact addresses considered by the search.

For more geographically focused research, add a city or country through the `location` field.

***

### 🔹 Can I Search npm Contacts by Location?

Yes. The **npm Email Scraper** supports an optional `location` field.

You can enter a country, state, or city, such as:

```text
United States
```

or:

```text
New York
```

The location is incorporated into the targeted search.

If the resulting dataset is too small, try removing the location filter or using a broader geographic term. Narrow searches can naturally produce fewer publicly indexed results.

***

### 🔹 Can I Search Multiple Email Domains?

Yes. The `customDomains` input accepts multiple email suffixes.

For example:

```json
[
  "@gmail.com",
  "@yahoo.com",
  "@outlook.com",
  "@company.com"
]
```

The Actor processes each keyword and domain combination independently.

This can be useful when researching both common email providers and organization-specific domains.

***

### 🔹 Does npm Email Scraper Remove Duplicate Emails?

Yes. The Actor keeps track of email addresses already discovered during the run and does not register the same email address repeatedly.

This helps reduce duplicate contact records when the same address appears across multiple search results or search combinations.

Duplicate prevention does not mean every record represents a unique person or organization. One publicly listed address can legitimately appear in multiple relevant contexts.

***

### 🔹 npm Email Scraper – Use Cases

The **npm Email Scraper** can support research and prospecting workflows involving publicly indexed npm-related contact information.

> 💼 **Use Case Ideas**
>
> - Developer research
> - npm ecosystem research
> - Software developer discovery
> - JavaScript community research
> - Node.js ecosystem research
> - Technical prospecting
> - Developer outreach research
> - Software marketing research
> - Package ecosystem analysis
> - B2B technology research

#### 💻 Developer Discovery

Technology companies, agencies, and researchers can use role-specific keywords to discover publicly indexed developer-related contacts.

#### 📦 npm Ecosystem Research

Search terms related to developers, JavaScript, Node.js, packages, or other technical roles can help create focused research datasets.

#### 📣 Technical Outreach

Organizations conducting legitimate developer-focused outreach can use publicly available contact information as part of their research process, subject to applicable privacy and anti-spam requirements.

#### 🌎 Geographic Developer Research

Adding a location allows research to focus on particular cities, states, or countries.

***

### 🔹 npm Email Scraper – Input

The Actor provides five user-facing inputs.

| Input           | Type    | Required | Default                  | Purpose                        |
| --------------- | ------- | -------: | ------------------------ | ------------------------------ |
| `keywords`      | Array   |      Yes | Developer, Web Developer | Search queries                 |
| `location`      | String  |       No | Empty                    | Country, state, or city filter |
| `customDomains` | Array   |       No | @gmail.com               | Email suffixes                 |
| `maxEmails`     | Integer |       No | 5                        | Target per keyword + domain    |
| `excludeWords`  | Array   |       No | Empty                    | Skip unwanted snippets         |

#### `keywords`

This is the only required field.

It accepts a list of search keywords or queries. The Actor's configured examples focus on developer-related terms.

For broader coverage, provide several related terms.

#### `location`

An optional geographic filter.

Leave it blank when geographic targeting is unnecessary.

#### `customDomains`

A list of email suffixes to search for.

The default value is:

```text
@gmail.com
```

#### `maxEmails`

An integer from **1 to 10,000**.

The target applies independently to each keyword + domain combination.

#### `excludeWords`

An optional list of words or phrases.

Single words are matched as whole words, while phrases are matched as phrases. Matching is case-insensitive.

***

### 🔹 npm Email Scraper – Output Format

The Actor stores collected records in the **npm Emails Dataset**.

The configured default **Scraped Leads** view presents these columns:

| Field         | Description                          |
| ------------- | ------------------------------------ |
| `keyword`     | Keyword used for the search          |
| `title`       | Matching search-result title         |
| `description` | Search-result description or snippet |
| `url`         | Search-result URL                    |
| `email`       | Extracted email                      |

Each pushed record also includes a `network` value.

The `description` is particularly useful because it provides contextual information from the search result where the email was discovered.

The `url` provides the associated result destination, allowing users to review the source context when appropriate.

***

### 🔹 npm Email Scraper – Pricing and Limits

The provided Actor configuration does not define a fixed monetary price.

The relevant Actor-level limits and behavior are:

> 💰 **Pricing & Limit Information**
>
> - `maxEmails` accepts values from 1 to 10,000.
> - The requested email target applies per keyword + domain combination.
> - Free-tier runs cap the requested value at 100 emails per keyword + domain combination.
> - Paid runs are not restricted by this specific free-tier ceiling.
> - A higher target does not guarantee a higher number of results.
> - Actual collection depends on publicly indexed search results.
> - Wider searches may require more runtime.

The input documentation specifies a default run timeout of **3600 seconds**. For broad searches, users may need to increase the timeout through the applicable run options.

No fixed subscription or per-run monetary amount should be assumed from the Actor configuration alone.

***

### 🔹 npm Email Scraper – Tips and Best Practices

A strong search strategy starts with specific keywords and realistic targets.

> 💡 **Recommended Tips**
>
> - Use multiple specific keywords instead of one generic keyword.
> - Combine developer roles with technology-related terms.
> - Test a small `maxEmails` value before running a large search.
> - Add several relevant email domains when broader coverage is needed.
> - Use a location when regional targeting matters.
> - Remove the location when the search is too narrow.
> - Use `excludeWords` to filter unwanted categories.
> - Broaden your keywords when very few contacts are found.
> - Review result quality before increasing collection targets.

For example, searching only `Developer` may be broader than searching for `Node.js Developer`, `JavaScript Developer`, and `Web Developer`.

Similarly, a city-specific search can produce fewer results than an unrestricted search.

***

### 🔹 What Is npm Email Scraper Best Used For?

The **npm Email Scraper** is designed for targeted discovery of publicly indexed email addresses associated with npm-related search results.

It is particularly useful when you already know the type of developer, technical role, location, or email domain you want to research.

The combination of **keyword targeting, location filtering, custom domains, exclusion rules, and structured output** makes it possible to create focused contact datasets instead of manually collecting individual search results.

***

### 🔹 Frequently Asked Questions

#### ❓ What is npm Email Scraper?

**npm Email Scraper** is an Apify Actor that searches publicly indexed npm-related results and extracts matching email addresses based on keywords and selected email domains.

#### ❓ How does npm Email Scraper find email addresses?

The Actor performs targeted search queries for npm-related results using the supplied keyword, email domain, and optional location. Matching email addresses are extracted from search-result descriptions.

#### ❓ What data does npm Email Scraper extract?

The default Dataset view contains `keyword`, `title`, `description`, `url`, and `email`. Each pushed record also includes a network identifier.

#### ❓ Can I search for npm developer emails?

Yes. Use terms such as `Web Developer`, `JavaScript Developer`, `Node.js Developer`, or other relevant technical roles.

#### ❓ Can I use multiple keywords in npm Email Scraper?

Yes. `keywords` is an array, so multiple search terms can be processed in one run.

#### ❓ Can I search Gmail, Yahoo, and Outlook emails?

Yes. Add the desired suffixes to `customDomains`, such as `@gmail.com`, `@yahoo.com`, and `@outlook.com`.

#### ❓ Can I use a custom company email domain?

Yes. The `customDomains` field accepts custom email suffixes in addition to common providers.

#### ❓ Can npm Email Scraper target a city or country?

Yes. Enter the desired country, state, or city in the optional `location` field.

#### ❓ Why did my npm email search return fewer contacts?

The Actor depends on publicly indexed search results. A narrow keyword, location, or email-domain selection can reduce available results.

Try broader keywords, additional domains, or remove the location filter.

#### ❓ What does maxEmails mean in npm Email Scraper?

`maxEmails` is the target for each individual keyword + domain combination. It is not one shared target for the entire run.

#### ❓ Does npm Email Scraper remove duplicate emails?

Yes. The Actor tracks previously discovered email addresses and avoids registering the same address repeatedly during the run.

#### ❓ Can I exclude unwanted npm search results?

Yes. Add words or phrases to `excludeWords`. If a matching term appears in a result description, that snippet is skipped.

#### ❓ Does maxEmails guarantee the requested number of contacts?

No. It is a collection target. The Actor can only return matching addresses that are publicly available in relevant search results.

#### ❓ Is npm Email Scraper suitable for developer lead generation?

It can support developer research and prospecting workflows involving publicly indexed contact information. Always ensure your use complies with applicable privacy, anti-spam, and platform requirements.

***

### 🔹 Support

If you need help improving your **npm Email Scraper** search strategy, start by testing a few focused keywords and a small email target.

For sparse results, consider broadening your keywords, adding relevant email domains, or removing the location filter. For unwanted results, use `excludeWords` to refine the search.

For custom requirements, improvements, or a bespoke Actor build, contact:

contact me by email : <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": [
    "Developer ",
    "Web Developer "
  ],
  "location": "",
  "customDomains": [
    "@gmail.com"
  ],
  "maxEmails": 5,
  "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": [
        "Developer ",
        "Web Developer "
    ],
    "location": "",
    "customDomains": [
        "@gmail.com"
    ],
    "excludeWords": []
};

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

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

```

## MCP server setup

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