# Justdial Email Scraper (`email_scraper/justdial-email-scraper`) Actor

Extract publicly listed email addresses with the Justdial Email Scraper. Search by keywords, locations, and email domains, filter unwanted results, remove duplicates, and collect structured contact data from Justdial-related profile snippets for lead generation, research, and business intelligence.

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

### Justdial Email Scraper Overview

Justdial Email Scraper is designed to find publicly listed email addresses that appear in Justdial-related profile snippets surfaced by search-engine result pages. Instead of requiring users to browse profile pages one by one, this Justdial Email Scraper turns search terms, email-domain filters, an optional region, and exclusion words into a structured contact dataset.

The Justdial Email Scraper is useful for lead research, niche discovery, market research, and contact list building when the email is publicly visible in a result snippet. It is especially useful for searching several niches and domain suffixes systematically.

### Justdial Email Scraper Features

The Justdial Email Scraper focuses on a clear workflow rather than a large number of controls. You provide search terms such as “Fitness Coach,” choose one or more email suffixes such as `@gmail.com`, optionally add a country or city, and optionally exclude snippets containing words you do not want.

- **Search-term targeting:** Run multiple niches, job titles, or phrases in one actor run.
- **Email-domain filtering:** Keep only addresses ending with the suffixes you specify.
- **Regional targeting:** Narrow the search with a country, state, or city, or leave the region blank.
- **Exclusion filtering:** Skip an entire result snippet when an excluded word or phrase is detected.
- **Per-combination limits:** Set an address target independently for every search-term × email-domain combination.
- **Structured dataset output:** Each discovered address is written as a separate dataset row with its source context.
- **Checkpointing:** The Justdial Email Scraper stores its collected address set and progress position so an interrupted run can resume.
- **Proxy routing:** Requests are prepared through the Apify `GOOGLE_SERP` proxy pool, with exit-node rotation when an empty result page is retried.

### How to Use the Justdial Email Scraper

Using the Justdial Email Scraper starts with defining a search matrix. Each search term is paired with every email-domain suffix; three terms and two suffixes create six combinations.

1. Add specific phrases to **Search terms**. The Justdial Email Scraper accepts a string list and tidies entries by trimming whitespace and splitting comma-separated values.
2. Enter an optional **Region / Location** such as `New York` or `India`. Leave it blank to search without a geographic filter.
3. Add the email suffixes you want in **E-mail domain suffixes**, for example `@gmail.com` or `@company.com`.
4. Set **Address limit per keyword + domain combination** to control how many fresh addresses the Justdial Email Scraper targets for each combination.
5. Add **Exclude words** when snippets containing certain words or phrases should be ignored.
6. Start the run and review the resulting rows in the Apify dataset.

The Justdial Email Scraper constructs a site-restricted search such as `site:justdial.com Fitness Coach "@gmail.com" "New York"`, walks paginated result pages, reads result cards, checks snippets, extracts matching emails, and streams new addresses into the dataset.

### Justdial Email Scraper Data Extraction

The Justdial Email Scraper does not claim to extract private contact information. Its extraction logic looks for email addresses inside the text snippet attached to each search result. Only addresses whose suffix matches the active email-domain combination are accepted.

For each accepted address, the Justdial Email Scraper keeps search context with the source result, so you can see the matching keyword, headline, snippet, and source link.

Duplicate addresses are tracked in memory and are not added again across later combinations in the same run.

### Justdial Email Scraper Use Cases

The Justdial Email Scraper can support practical research workflows where publicly surfaced Justdial contact information is useful.

#### Lead generation

Use focused business niches, professional terms, or service phrases to discover publicly listed email addresses. Pairing several terms with multiple suffixes can broaden the contact pool without turning every target into a separate manual search.

#### Market research

Researchers can collect contact-level evidence around selected niches and locations. The `keyword` and `description` fields preserve the context that surrounded each email address in the search result.

#### Business intelligence

The Justdial Email Scraper can provide a structured starting point for analyzing which search terms surface the most contacts, which regions produce relevant results, and which email providers or domains appear in public snippets.

#### CRM enrichment and data analysis

When collected contact information matches an existing business research workflow, the structured rows can be exported or processed further through Apify dataset tooling. The Justdial Email Scraper only collects and outputs the fields shown below; it does not claim to validate, enrich, or verify the addresses.

### Justdial Email Scraper Input

The Justdial Email Scraper exposes five main input fields.

| Input          | Type             | Required | Default                        | Description                                                                                       |
| -------------- | ---------------- | -------- | ------------------------------ | ------------------------------------------------------------------------------------------------- |
| `searchTerms`  | Array of strings | No       | `["Fitness", "Fitness Coach"]` | Niches, job titles, or phrases searched against Justdial results. Multiple entries are supported. |
| `region`       | String           | No       | `""`                           | Optional country, state, or city used to narrow the search.                                       |
| `emailDomains` | Array of strings | No       | `["@gmail.com"]`               | Email suffixes that qualify for extraction.                                                       |
| `emailLimit`   | Integer          | No       | `10`                           | Target number of addresses for each search-term × domain combination. Range: 1–10,000.            |
| `excludeWords` | Array of strings | No       | `[]`                           | Words or phrases that cause a matching profile snippet to be skipped.                             |

`emailLimit` is a per-combination target, not a shared run-wide target. With three search terms, two suffixes, and a limit of 20, the Justdial Email Scraper works through six combinations and targets up to 20 fresh addresses for each combination. The final total can be lower because the available public results may contain fewer qualifying addresses, duplicates, excluded snippets, or blocked/empty result pages.

### Justdial Email Scraper Output Data

Every newly accepted address is pushed as one dataset row. The implementation also includes a `network` field in each pushed record, while the default Apify dataset view focuses on `keyword`, `title`, `description`, `url`, and `email`.

| Field         | Type   | Description                                                             |
| ------------- | ------ | ----------------------------------------------------------------------- |
| `network`     | String | Source network label. The Justdial Email Scraper writes `Justdial.com`. |
| `keyword`     | String | Search term responsible for the result.                                 |
| `title`       | String | Headline captured from the search result card.                          |
| `description` | String | Text snippet from the search result card.                               |
| `url`         | String | Link captured from the result card.                                     |
| `email`       | String | Publicly surfaced email address matching the selected suffix.           |

The `keyword` field identifies the search phrase. The `title`, `description`, and `url` fields preserve source context, while `email` contains the extracted address. The `network` field identifies the source label.

The Justdial Email Scraper streams rows as addresses are found instead of waiting until the complete matrix finishes. This means productive results can appear in the dataset during the run.

### Example Input

```json
{
  "searchTerms": [
      "Restaurant",
      "Hotel"
  ],
  "region": "New York",
  "emailDomains": [
    "@gmail.com"
  ],
  
  "emailLimit": 10,

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

### Example Output

```json
{
    "keyword": "Restaurant",
    "title": "Popular Restaurants Serving Chicken Tikka in Vashi, Navi ...",
    "description": "mukesh.indiafincapital@gmail.com Write for me 5 star rewiw for kshirsagar ... New York Waffles & Dinges · Starboy Pizza & Shakes · Winners Pizza - Fresh ...",
    "url": "/goto?url=CAEShAEB6zswFbP_DOJEDckq71JzkiMqDqOXIwWm13gabJChY5B5Vqxk5RlMxdNawrKerGsaFFEqqF4eMrM0W3l4pjVFCK_x8qAiNUgCuKbXT-DinxfUtlREU5FMKsM9YJ8HaDEkmikquXRKmdowFjESa4ImvNs7vOlkImXyyM8E2V7FBx4L8D4",
    "email": "mukesh.indiafincapital@gmail.com"
  }
```

The example represents the actual record shape produced by `main.py`. Real values depend on the public snippets returned for your selected search terms, suffixes, and region.

### Data Quality and Reliability

The Justdial Email Scraper is built around public search-result snippets, so result quality depends on what the search engine exposes for the requested query. An email address must be visibly present in the snippet and match the active suffix before it can become an output row.

The Justdial Email Scraper uses several safeguards during a run. It removes duplicate addresses across combinations, applies exclusion matching case-insensitively, retries some empty pages after changing proxy exits, and stops unproductive searches according to internal page-yield and repetition thresholds.

Pagination is bounded by an internal 1,000-page budget for a single search-term and email-domain combination. Additional stopping rules prevent the crawler from continuing indefinitely when pages repeatedly contain no new addresses, only previously collected addresses, or no usable result cards.

The Justdial Email Scraper also stores a checkpoint in the Apify key-value store. The checkpoint includes already collected addresses and the current term/suffix position, allowing the run to restore progress after an interruption or retry.

### Search Intent and Discovery

People searching for a Justdial email scraper often want public contact information without manually inspecting every result. The Justdial Email Scraper matches that intent with niche searches, domain filtering, location targeting, and structured extraction.

Common tasks include finding public Gmail contacts for a niche, narrowing results to a city, comparing terms across industries, and creating a dataset of public contact rows for later analysis. Specific phrases generally give the search engine clearer context than broad one-word queries.

### Frequently Asked Questions

#### What is the Justdial Email Scraper?

The Justdial Email Scraper collects publicly listed email addresses found in snippets from search-engine results restricted to `justdial.com`. It records each accepted email together with source context.

#### How does the Justdial Email Scraper find emails?

The Justdial Email Scraper sends site-restricted Google search queries, reads result cards, checks the snippet text, and extracts email addresses whose suffix matches the current domain filter.

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

The output contains `network`, `keyword`, `title`, `description`, `url`, and `email`. The email is taken from the visible result snippet rather than from private or authenticated account data.

#### Can I scrape multiple search terms?

Yes. `searchTerms` is an array, and the Justdial Email Scraper processes every search term against every configured email-domain suffix.

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

Yes. The `region` input can contain a country, state, or city. When it is empty, the search is not narrowed geographically.

#### Can I filter Gmail, Yahoo, or company domains?

Yes. Add the desired suffixes to `emailDomains`. Each suffix gets its own search combination.

#### What does the email limit control?

The `emailLimit` value is applied separately to each search-term × domain combination. It does not represent one shared total across the entire run.

#### Can I exclude unwanted profiles?

Yes. Add words or phrases to `excludeWords`. If an excluded item appears in a profile snippet, that entire snippet is skipped and no address is taken from it.

#### Does the Justdial Email Scraper remove duplicate emails?

Yes. The Justdial Email Scraper keeps a set of previously banked addresses and skips an address when it has already been collected earlier in the run.

#### Does the Justdial Email Scraper use proxies?

Yes. The implementation prepares an Apify proxy configuration using the `GOOGLE_SERP` pool and can request a fresh exit when an empty page needs a retry.

#### Will the Justdial Email Scraper always reach my email target?

No. `emailLimit` is a target, not a guarantee. The run can finish early when public results are exhausted, repeated, blocked, excluded, or otherwise unproductive.

#### What happens on a free Apify account?

When running on the Apify platform with the relevant free-account environment, the code applies a run-wide ceiling of 100 addresses. Local runs and subscribed runs are treated as unrestricted by this code.

#### Does the Justdial Email Scraper validate that an email address is active?

No. It extracts publicly surfaced email text that matches the requested suffix. It does not perform mailbox verification.

#### Can I use the output for further automation?

Yes. The Justdial Email Scraper writes structured records to its Apify dataset as results are found. Those dataset records can then be used in downstream workflows supported by your Apify setup.

### Why Use This Actor?

The main benefit of the Justdial Email Scraper is a focused search-to-dataset workflow. Instead of repeatedly forming site-restricted queries, scanning snippets, filtering domain suffixes, and copying addresses manually, the Justdial Email Scraper performs those steps consistently.

The Justdial Email Scraper combines multiple search terms and email domains in one run, while each combination receives its own target. Its exclusion filter improves snippet control, while duplicate suppression helps prevent the same address from filling multiple combinations.

The Justdial Email Scraper is also designed for long-running searches. Productive pages are checkpointed, and the stored cursor helps the run continue from its saved position. Internal stopping rules reduce wasted page walking when a search has stopped producing useful new contacts.

### API and Automation

Because the Justdial Email Scraper is an Apify Actor and writes its results to an Apify dataset, it can be incorporated into the normal Apify execution and dataset workflow available to your account. The Justdial Email Scraper does not define a custom external API or third-party integration layer beyond its Apify runtime behavior.

For automated jobs, the Justdial Email Scraper uses the same five fields documented above: `searchTerms`, `region`, `emailDomains`, `emailLimit`, and `excludeWords`. The output remains a structured dataset of rows, making the collected contact data suitable for subsequent processing outside the actor.

### Support

For questions, issue reports, input adjustments, or bespoke scraper requirements, use the support options available on the Actor's Apify page. You can also contact the developer at **<alphascraper69@gmail.com>** for a tweak or custom build request.

Use specific search terms, relevant email suffixes, and an appropriate region to make the Justdial Email Scraper more focused and useful for your research workflow.

# 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": [
    "Restaurant",
    "Hotel"
  ],
  "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": [
        "Restaurant",
        "Hotel"
    ],
    "location": "New york",
    "customDomains": [
        "@gmail.com"
    ],
    "excludeWords": []
};

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

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

```

## MCP server setup

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