# Naver Email Scraper (`email_scraper/naver-email-scraper`) Actor

Naver Email Scraper extracts publicly available email addresses from Naver search results using targeted keywords, locations, custom email domains, and exclusion filters. Build structured contact datasets for lead generation, outreach, market research, and prospecting.

- **URL**: https://apify.com/email\_scraper/naver-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

### 🔍 Naver Email Scraper – Overview

**Naver Email Scraper** helps you discover publicly listed email addresses associated with Naver pages by searching targeted keywords and email-domain combinations. It is designed for lead generation, contact discovery, market research, prospecting, and building structured business contact datasets.

The **Naver Email Scraper** works from search queries rather than requiring you to manually provide individual Naver URLs. Enter keywords such as `Blogger`, `Content Creator`, `Fitness Coach`, or `Software Developer`, optionally specify a country or city, and select the email domains you want to find.

> 💡 **Naver Email Scraper at a glance**
>
> - Search Naver-related results using multiple keywords
> - Target specific email domains such as `@gmail.com` or `@naver.com`
> - Optionally narrow searches by country, state, or city
> - Exclude unwanted profile descriptions with custom words or phrases
> - Collect structured title, description, URL, keyword, and email data
> - Remove duplicate email addresses across the run
> - Save results incrementally to an Apify Dataset
> - Resume progress after an interrupted run

The **Naver Email Scraper** is especially useful when your goal is to turn broad search intent into structured contact leads without manually reviewing large numbers of search results.

***

### 🔹 Naver Email Scraper – Key Features

The **Naver Email Scraper** combines keyword targeting, domain filtering, geographic targeting, exclusion filtering, duplicate prevention, and structured dataset output into one workflow.

> 🚀 **Key Features**
>
> - **Multiple keywords** — Run several search terms in one Actor execution.
> - **Multiple email domains** — Search for specific domain suffixes such as `@gmail.com`, `@naver.com`, `@yahoo.com`, `@outlook.com`, or other domains you provide.
> - **Location filtering** — Add a country, state, or city to narrow search intent.
> - **Exclusion words** — Skip profile snippets containing unwanted words or phrases.
> - **Per-combination limits** — `maxEmails` is applied independently to each keyword + domain combination.
> - **Duplicate protection** — Previously discovered email addresses are not collected again during the run.
> - **Structured output** — Results are saved with keyword, title, description, URL, and email fields.
> - **Incremental saving** — Found records are pushed to the Dataset as the run progresses.

The **Naver Email Scraper** is built for practical contact discovery. Instead of treating every search result as a lead, it can filter the result description before extracting an email that matches the selected domain suffix.

***

### 🔎 Naver Email Scraper – What Data Can You Extract?

The **Naver Email Scraper** returns structured information for each discovered email address. This makes the dataset suitable for filtering, sorting, enrichment, lead qualification, and downstream analysis.

> 📦 **Output Data**
>
> - `network` — Identifies the source network as Naver.com.
> - `keyword` — The search keyword associated with the result.
> - `title` — The title of the matched search result.
> - `description` — The available search-result description or snippet.
> - `url` — The URL associated with the search result.
> - `email` — The extracted email address matching the selected domain suffix.

The **Naver Email Scraper** does not claim that every email belongs directly to the page owner. The email is extracted when it appears in the available search-result text associated with a matching Naver result.

#### 📊 Naver Email Scraper – Example Output

```json
{
  "network": "Naver.com",
  "keyword": "Blogger",
  "title": "Example Naver Blogger Profile",
  "description": "Lifestyle blogger and content creator. Contact: example@gmail.com",
  "url": "https://example.naver.com/profile",
  "email": "example@gmail.com"
}
```

This structured format makes the **Naver Email Scraper** useful for creating clean lead lists and exporting data through the standard Apify Dataset interface.

***

### 🛠️ Naver Email Scraper – How to Use It

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

#### 📝 1. Add Your Keywords

Enter one or more keywords describing the people, businesses, roles, industries, or topics you want to discover.

Examples:

```text
Blogger
Content Creator
Fitness Coach
Digital Marketer
Travel Influencer
Photographer
```

Specific keywords usually provide more focused results. Combining related phrases can also improve coverage.

#### 🌍 2. Add a Location

The optional `location` field can contain a country, state, region, or city.

Examples:

```text
Japan
South Korea
Tokyo
Seoul
California
```

Leave the location empty when you want the **Naver Email Scraper** to search without a geographic restriction.

#### 📧 3. Choose Email Domains

Use `customDomains` to define the email suffixes you want to collect.

Example:

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

This lets the **Naver Email Scraper** focus on particular email providers or company-specific domains.

#### 🎯 4. Set the Maximum Email Target

`maxEmails` controls how many emails the Actor aims to collect for each **keyword + domain combination**.

For example, with:

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

the Actor processes six keyword/domain combinations, with a target of up to 20 emails per combination where matching public results are available.

#### 🚫 5. Add Exclusion Words

Use `excludeWords` to skip descriptions containing words or phrases you do not want.

Example:

```json
[
  "crypto",
  "onlyfans"
]
```

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

> ⚠️ **Important:** Exclusion filtering is applied to the available result description. It does not inspect the entire destination page.

***

### 🔍 How to Scrape Naver Email Addresses by Keyword

The **Naver Email Scraper** is most effective when your search terms reflect the type of contacts you want.

For example, instead of using only:

```text
Fitness
```

try several focused queries:

```text
Fitness Coach
Fitness Trainer
Fitness Influencer
Online Fitness Coach
Personal Trainer
```

You can combine these with domains such as:

```text
@gmail.com
@naver.com
@outlook.com
```

The **Naver Email Scraper** processes each keyword/domain combination separately, helping you build a broader set of targeted search opportunities.

> 💡 **Search quality tip**
>
> - Use role-specific keywords rather than extremely broad topics.
> - Add related keyword variations when coverage is limited.
> - Try multiple relevant email domains.
> - Use a location when geographic targeting matters.
> - Remove the location when results are too sparse.
> - Increase the target only when additional matching results are likely to exist.

***

### 🌐 Can Naver Email Scraper Search by Country or City?

Yes. The **Naver Email Scraper** supports an optional location field for geographic targeting.

For example:

```json
{
  "keywords": ["Blogger", "Content Creator"],
  "location": "Tokyo",
  "customDomains": ["@gmail.com", "@naver.com"],
  "maxEmails": 20
}
```

You can use countries, states, cities, or other geographic search terms. Leaving `location` empty performs the search without a geographic filter.

Location targeting is useful for regional prospecting, local market research, and country-specific contact discovery. However, results depend on what is publicly discoverable in search results for the selected terms.

***

### 🎯 Naver Email Scraper – Use Cases

The **Naver Email Scraper** can support several research and prospecting workflows where publicly available email information is relevant.

> 💼 **Common Use Cases**
>
> - **Lead generation** — Build structured contact lists from relevant Naver search results.
> - **Blogger outreach** — Find publicly listed email addresses associated with blogging profiles.
> - **Influencer research** — Discover contact information for creators and influencers.
> - **Business prospecting** — Search for people or organizations using industry-specific terms.
> - **Marketing research** — Build datasets around selected markets, roles, or locations.
> - **Agency prospecting** — Identify potential outreach contacts based on professional keywords.
> - **Creator discovery** — Search for content creators and related profiles.
> - **Market segmentation** — Compare contacts by keyword, location, email domain, or source result.
> - **Competitive research** — Study publicly discoverable contact information in specific niches.

The **Naver Email Scraper** is best used for legitimate research, outreach, and business workflows involving publicly available information.

***

### ⚙️ Input

The **Naver Email Scraper** accepts the following user-facing inputs.

| Input           | Type    | Required | Description                                                |
| --------------- | ------- | -------- | ---------------------------------------------------------- |
| `keywords`      | Array   | Yes      | Search keywords or queries                                 |
| `location`      | String  | No       | Country, state, city, or other geographic term             |
| `customDomains` | Array   | No       | Email domains or suffixes to include                       |
| `maxEmails`     | Integer | No       | Target emails for each keyword + domain combination        |
| `excludeWords`  | Array   | No       | Words or phrases that cause a result snippet to be skipped |

> 📥 **Example Input**
>
> ```json
> {
>   "keywords": [
>     "Blogger",
>     "Content Creator",
>     "Travel Influencer"
>   ],
>   "location": "Japan",
>   "customDomains": [
>     "@gmail.com",
>     "@naver.com"
>   ],
>   "maxEmails": 20,
>   "excludeWords": [
>     "crypto"
>   ]
> }
> ```

The only required field is `keywords`. The other fields let you refine the **Naver Email Scraper** according to your desired audience and search coverage.

***

### 📤 Output

The **Naver Email Scraper** stores its results in an Apify Dataset. The default dataset view is organized as a table for convenient inspection.

> 📋 **Output Schema**
>
> - `network`
> - `keyword`
> - `title`
> - `description`
> - `url`
> - `email`

#### 📄 Naver Email Scraper – Sample Dataset Record

```json
{
  "network": "Naver.com",
  "keyword": "Content Creator",
  "title": "Example Creator",
  "description": "Content creator based in Seoul. Contact example@naver.com",
  "url": "https://example.naver.com/",
  "email": "example@naver.com"
}
```

The dataset can be reviewed through the Apify platform and used with Apify's standard dataset export workflows for formats such as JSON, CSV, or Excel.

***

### 💰 Naver Email Scraper – Pricing

The provided Actor configuration does not define a fixed monetary price, currency amount, or cost per email, so no specific price should be stated in this README.

The runtime uses result-based charging for records that are successfully pushed to the Actor's dataset. The actual monetary cost depends on the pricing configured for the Actor and the applicable Apify plan.

> 💳 **Pricing Notes**
>
> - The provided configuration does not contain a fixed dollar price.
> - Free users are subject to a maximum `maxEmails` value of **100 per keyword + domain combination**.
> - Paid users are not subject to that code-level 100-email cap.
> - `maxEmails` controls the target for each combination rather than one shared target across the complete keyword/domain matrix.
> - A higher target does not guarantee more emails; the available public search results determine what can actually be found.

Always check the current Apify Store pricing page for the latest monetary pricing applicable to your account.

***

### 💡 Naver Email Scraper – Tips and Best Practices

Good input strategy can significantly affect the usefulness of your dataset.

> 🧠 **Best Practices**
>
> - **Use specific keywords:** `Wedding Photographer` is generally more targeted than only `Photographer`.
> - **Create keyword variations:** Try related job titles, specialties, and niche terms.
> - **Combine domain types:** Public contacts may use different providers.
> - **Use location strategically:** Add a city or country for local research, or remove it when coverage is too narrow.
> - **Use exclusions carefully:** Excluding common terms can remove unwanted results, but overly broad exclusions may reduce useful leads.
> - **Start with a moderate target:** Test a smaller `maxEmails` value before expanding larger runs.
> - **Review descriptions:** The description field provides context for understanding why a result was collected.
> - **Expect variable coverage:** Publicly discoverable emails differ by keyword, location, domain, and available search results.

The **Naver Email Scraper** also avoids collecting the same email address repeatedly within the same run. This helps reduce duplicate rows when multiple searches surface the same public email.

***

### ⏱️ What Happens When Results Run Out?

The **Naver Email Scraper** does not guarantee that the requested target will always be reached. A keyword/domain combination may contain fewer usable email results than the selected target.

The Actor stops searching when its result-yield conditions indicate that additional pages are no longer producing useful new email addresses. This means a request for 100 emails might return fewer than 100 when the available public search results do not contain enough matching addresses.

> ⚠️ **Result Expectations**
>
> - `maxEmails` is a target, not a guarantee.
> - Narrow keywords can produce sparse datasets.
> - Some search results may not contain an email address.
> - Existing duplicate emails are skipped.
> - Exclusion words can reduce the final count.
> - Geographic restrictions can reduce available results.

***

### ❓ Frequently Asked Questions

#### 🔍 What is Naver Email Scraper?

**Naver Email Scraper** is an Apify Actor for discovering publicly available email addresses associated with relevant Naver search results. It uses keywords, optional locations, selected email domains, and exclusion terms to create a structured contact dataset.

#### 📧 What email domains can Naver Email Scraper collect?

You can provide custom email suffixes through `customDomains`. Examples include `@gmail.com`, `@naver.com`, `@yahoo.com`, `@outlook.com`, and other domain suffixes you want to target.

#### 🌍 Can Naver Email Scraper target a specific country or city?

Yes. Enter a country, state, city, or other geographic search term in `location`. Leave it blank to search without a geographic restriction.

#### 🎯 How does maxEmails work?

`maxEmails` is applied independently to each keyword + domain combination. For example, two keywords and three domains create six combinations, each with its own target.

#### 🚫 Can I exclude unwanted Naver profiles?

Yes. Use `excludeWords` to skip result descriptions containing specified words or phrases. Matching is case-insensitive.

#### ♻️ Does Naver Email Scraper remove duplicate emails?

Yes. The Actor tracks discovered email addresses and skips emails that have already been collected during the run.

#### 📊 What data does Naver Email Scraper return?

The dataset includes `network`, `keyword`, `title`, `description`, `url`, and `email`, giving you both the contact address and context about the matched search result.

#### ❗ Why did my run collect fewer emails than requested?

The requested number is a target, not a guarantee. Limited public results, duplicate addresses, exclusion rules, narrow keywords, geographic filters, and unavailable matching emails can all reduce the final count.

#### 🔄 Can I use multiple keywords and domains together?

Yes. This is one of the main strengths of **Naver Email Scraper**. Combining several related keywords with multiple email domains can expand search coverage across different search-result patterns.

#### 📁 Where are the results stored?

Results are pushed incrementally into the Actor's Apify Dataset, where they can be reviewed and exported using the available Apify dataset tools.

***

### 🛡️ Naver Email Scraper – Responsible Use

The **Naver Email Scraper** is intended for legitimate research, prospecting, marketing, and business intelligence workflows involving publicly available information.

Use collected contact information responsibly and follow applicable privacy, data-protection, anti-spam, and outreach laws in the jurisdictions relevant to your activity. Respect applicable platform terms and only use data for lawful purposes.

***

### 📞 Support

Need help with the **Naver Email Scraper**, want a customization, or need a bespoke scraper for another website or workflow?

- 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": [
    "Blogger",
    "Content Creator"
  ],
  "location": "",
  "customDomains": [
    "@gmail.com",
    "@naver.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": [
        "Blogger",
        "Content Creator"
    ],
    "location": "",
    "customDomains": [
        "@gmail.com",
        "@naver.com"
    ],
    "excludeWords": []
};

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

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

```

## MCP server setup

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