# Meesho Email Scraper (`email_scraper/meesho-email-scraper`) Actor

Meesho Email Scraper extracts publicly indexed emails from Meesho using targeted keywords, location filters, custom email domains, and exclusion terms. Build structured contact datasets for seller research, supplier discovery, business leads, and marketplace research.

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

### Meesho Email Scraper

Meesho Email Scraper is an Apify Actor designed to extract publicly indexed email addresses associated with Meesho search results using targeted keywords and email-domain filters. It helps users turn keyword-based searches into structured contact datasets containing the search keyword, result title, description, URL, and extracted email address.

The Actor supports multiple keywords, optional location targeting, custom email domains, maximum email targets, and exclusion words. This makes it suitable for seller research, supplier discovery, marketplace research, business lead research, contact discovery, and structured dataset creation.

You provide search terms such as `supplier`, `seller`, `fashion seller`, or `manufacturer`, optionally narrow the search by country or city, and choose the email domains you want to collect. The resulting records are added to an Apify dataset in a structured format.

### What Is a Meesho Email Scraper?

A Meesho Email Scraper is a data extraction tool for finding publicly indexed email addresses associated with Meesho-related search results.

Instead of manually reviewing search results one by one, the Actor processes your configured keyword and email-domain combinations and collects matching contact information from available indexed result descriptions.

The workflow is straightforward:

- **Input:** Keywords, optional location, email-domain suffixes, an email limit, and optional exclusion words.
- **Search:** The Actor searches for relevant Meesho pages based on your configuration.
- **Filter:** Results can be narrowed by location, email domain, and exclusion terms.
- **Extract:** Matching email addresses are identified from available result descriptions.
- **Output:** Structured records are added to the Apify dataset with keyword, title, description, URL, and email fields.

The Actor is designed for users who need structured Meesho contact data for research and data collection workflows.

### Key Features

| Feature                      | Description                                                          | User Benefit                                             |
| ---------------------------- | -------------------------------------------------------------------- | -------------------------------------------------------- |
| Multiple keywords            | Process a list of search keywords or queries                         | Explore different seller, supplier, or business segments |
| Location filter              | Optionally specify a country, state, or city                         | Narrow searches geographically                           |
| Custom email domains         | Specify domains such as `@gmail.com` or `@yahoo.com`                 | Target the types of email addresses you need             |
| Per-combination email target | Set a maximum from 1 to 10,000 for each keyword + domain combination | Control collection depth                                 |
| Exclude words                | Skip result descriptions containing specified words or phrases       | Reduce unwanted matches                                  |
| Structured dataset           | Results contain consistent fields                                    | Simplify analysis and downstream workflows               |
| Duplicate prevention         | Previously collected email addresses are not added again             | Keep the resulting email collection cleaner              |
| Incremental results          | Results are pushed to the Apify dataset during processing            | Access collected records as the run progresses           |

### What Data Can You Extract?

The Meesho Email Scraper returns five user-facing data fields for each collected contact.

- **Keyword** — The keyword associated with the search that produced the result.
- **Title** — The title of the matching search result.
- **Description** — The available result description or snippet associated with the result.
- **URL** — The URL of the matching result.
- **Email** — The email address extracted from the result description according to the configured domain filters.

These fields provide both the contact information and the surrounding search-result context. The context can help users understand why a particular email address was collected and which keyword produced it.

The Actor does not promise that every Meesho profile or business will contain an email address. Results depend on publicly indexed information matching the configured searches.

### Why Use the Meesho Email Scraper?

Manual contact research can require repeatedly searching for businesses, sellers, suppliers, and other relevant Meesho-related profiles and checking available information individually.

The Meesho Email Scraper turns this repetitive search process into a configurable data-collection workflow.

It is particularly useful when you need to:

- Search multiple relevant keywords in one run.
- Focus on particular email domains.
- Narrow research to a geographic location.
- Exclude descriptions containing unwanted terms.
- Collect results into a structured Apify dataset.
- Build research datasets around Meesho-related businesses and contacts.
- Repeat similar searches with different keyword combinations.

The Actor also lets you control the collection target for each keyword and email-domain combination rather than relying on one shared target for the entire run.

### Benefits

Using a Meesho email extraction workflow can provide several practical benefits.

- **Less repetitive research:** Automate repeated keyword-based searches instead of manually checking every result.
- **Structured information:** Receive consistent keyword, title, description, URL, and email fields.
- **Flexible targeting:** Combine multiple search terms with different email-domain suffixes.
- **Geographic targeting:** Use the location field when research needs to focus on a particular region.
- **Cleaner results:** Exclusion words can remove descriptions that contain unwanted terms.
- **Scalable keyword research:** Add several specific keywords to cover different types of Meesho-related contacts.
- **Dataset creation:** Store collected records in an Apify dataset for later review and analysis.

### How to Use the Meesho Email Scraper

A typical Meesho Email Scraper workflow requires only a few steps:

1. Enter one or more keywords in the **Keywords or Queries** field.
2. Optionally enter a country, state, or city in **Region / Location**.
3. Select the email-domain suffixes you want to search for.
4. Set **Max Emails** for each keyword + domain combination.
5. Add exclusion words or phrases if certain descriptions should be skipped.
6. Start the Actor.
7. Review the structured records in the Apify dataset.

For initial testing, use a small number of focused keywords and a modest email target. After reviewing the results, you can broaden the keyword list, add additional domains, or adjust the location filter.

### Input

The Actor requires the `keywords` field. The remaining fields are optional and have documented defaults.

| Field           | Type             | Required | Default                  | Description                                                                           |
| --------------- | ---------------- | -------- | ------------------------ | ------------------------------------------------------------------------------------- |
| `keywords`      | Array of strings | Yes      | `["supplier", "seller"]` | Search keywords or queries to process                                                 |
| `location`      | String           | No       | `""`                     | Optional country, state, or city used to narrow the search                            |
| `customDomains` | Array of strings | No       | `["@gmail.com"]`         | Email-domain suffixes to include                                                      |
| `maxEmails`     | Integer          | No       | `5`                      | Maximum email target for each keyword + domain combination; allowed range is 1–10,000 |
| `excludeWords`  | Array of strings | No       | `[]`                     | Words or phrases that cause matching result descriptions to be skipped                |

#### Keywords

`keywords` is an array of search terms or queries. Using multiple specific terms can provide broader coverage than relying on one broad keyword.

For example, instead of only searching for `seller`, you could use terms such as:

- `seller`
- `supplier`
- `fashion seller`
- `clothing seller`
- `business owner`

The Actor processes the configured keyword list individually.

#### Location

`location` is optional. You can enter a country, state, city, or other geographic term to narrow the search.

Leave it empty when you do not want to apply a geographic filter.

#### Custom Email Domains

`customDomains` controls which email-domain suffixes the Actor looks for.

Examples include:

- `@gmail.com`
- `@yahoo.com`
- `@outlook.com`
- A relevant company domain such as `@example.com`

The default value is `@gmail.com`.

#### Max Emails

`maxEmails` accepts an integer from **1 to 10,000**.

The limit applies independently to each **keyword + email-domain combination**. For example, if you configure 3 keywords, 2 domains, and a target of 20, the Actor works through six combinations, with a target of up to 20 addresses for each combination.

This is not a guarantee that the Actor will find that many addresses. Available results depend on publicly indexed information.

For free users, the Actor applies a maximum collection limit of 100 emails when the requested setting exceeds that free-tier ceiling.

#### Exclude Words

`excludeWords` accepts words or phrases that should cause a matching result description to be skipped.

Matching is case-insensitive. Single-word exclusions use whole-word matching, while phrases are matched as phrases.

For example:

- `crypto`
- `onlyfans`
- `crypto trading`

If an exclusion term is found in a result description, that result is skipped and an email from that description is not collected.

### Input Example

```json
{
  "keywords": [
    "supplier",
    "seller",
    "fashion seller"
  ],
  "location": "India",
  "customDomains": [
    "@gmail.com",
    "@yahoo.com",
    "@outlook.com"
  ],
  "maxEmails": 10,
  "excludeWords": [
    "crypto",
    "onlyfans"
  ]
}
```

### Output

The Actor stores collected results in the **Meesho Emails Dataset**.

Each result is a structured record containing the search context and extracted contact information.

| Field         | Description                                                  |
| ------------- | ------------------------------------------------------------ |
| `keyword`     | Search keyword responsible for the result                    |
| `title`       | Title of the matching result                                 |
| `description` | Available description or search-result snippet               |
| `url`         | URL of the matching result                                   |
| `email`       | Extracted email address matching the configured email domain |

The dataset is presented as a table in Apify, making the collected records easier to review.

Email addresses are deduplicated across the run, so the same email is not intentionally added as a separate duplicate record when it has already been collected.

### Output Example

```json
{
  "keyword": "supplier",
  "title": "Example Supplier",
  "description": "Example supplier information with contact email seller@example.com",
  "url": "https://www.meesho.com/example",
  "email": "seller@example.com"
}
```

The example demonstrates the output structure only. Actual titles, descriptions, URLs, and email addresses depend on the available indexed results and your search configuration.

### Use Cases

The Meesho Email Scraper can support several research and data-collection workflows.

- **Seller research:** Find publicly indexed contact information associated with seller-focused searches.
- **Supplier discovery:** Research Meesho-related suppliers using targeted supplier keywords.
- **Marketplace research:** Build structured datasets around different Meesho-related search segments.
- **Business lead research:** Collect publicly indexed business contact information for further research.
- **Fashion research:** Search terms such as fashion seller, clothing seller, or related business categories.
- **Market analysis:** Compare datasets collected from different keyword and location combinations.
- **Contact research:** Identify email addresses appearing in relevant public search-result descriptions.
- **Dataset creation:** Build structured contact datasets for analysis or other user-managed workflows.

Use collected information responsibly and in accordance with applicable laws, website terms, and privacy requirements.

### Advantages

The Actor provides several configuration options without requiring users to manage the underlying search process themselves.

- Multiple keywords can be processed within one run.
- Email domains can be customized.
- Geographic targeting is optional.
- Exclusion terms can filter unwanted descriptions.
- Email collection targets can be configured from 1 to 10,000 per keyword + domain combination.
- Output uses consistent fields suitable for structured research.
- Duplicate email addresses are avoided during collection.
- Results are added incrementally to the Apify dataset.

These capabilities make the Actor adaptable to different Meesho contact research requirements.

### Limitations

The Meesho Email Scraper works with publicly indexed information available to its search process. Consequently, the Actor cannot guarantee that a particular seller, supplier, business, or profile will have a publicly discoverable email address.

Important limitations include:

- Results depend on available indexed Meesho information.
- A configured `maxEmails` value is a target, not a guarantee.
- Narrow keywords may produce fewer results.
- A restrictive location can reduce the available result set.
- Restrictive email-domain filters can reduce matches.
- Exclusion terms may intentionally remove otherwise relevant results.
- Search results can vary over time.
- The Actor only returns the documented output fields.

For broader research, consider using several relevant keywords and appropriate email-domain combinations rather than relying on a single query.

### Pros and Cons

| Pros                                      | Cons                                                          |
| ----------------------------------------- | ------------------------------------------------------------- |
| Supports multiple search keywords         | Results depend on publicly indexed information                |
| Optional geographic targeting             | A narrow search may return fewer contacts                     |
| Custom email-domain filtering             | Domain restrictions can reduce available matches              |
| Configurable per-combination email target | The target does not guarantee the requested number of results |
| Exclusion-word filtering                  | Exclusion terms can remove potentially relevant results       |
| Structured Apify dataset output           | Available information may vary between results                |
| Duplicate email prevention                | The same contact may not appear if it is not publicly indexed |

### Comparison With Alternative Approaches

| Capability               | Meesho Email Scraper          | Manual / Typical Alternative           |
| ------------------------ | ----------------------------- | -------------------------------------- |
| Keyword-based collection | Supported                     | Usually performed manually             |
| Multiple keywords        | Supported                     | Requires repeated searches             |
| Email-domain targeting   | Supported                     | Often requires manual filtering        |
| Location filtering       | Supported                     | Requires manual search refinement      |
| Exclusion terms          | Supported                     | Usually handled manually               |
| Structured output        | Dataset fields are provided   | May require manual formatting          |
| Duplicate email handling | Supported during collection   | Often requires manual cleanup          |
| Repeatable configuration | Supported through Actor input | Usually requires repeated manual setup |

The comparison describes workflow characteristics rather than a ranking of one approach over another.

### Best Practices

For better research workflows, consider the following practices:

- Start with a small test run before launching a broad collection.
- Use specific keywords that describe the type of contact you are researching.
- Combine related keywords rather than depending on one broad term.
- Use location only when geographic targeting is important.
- Add multiple relevant email domains when broader email coverage is needed.
- Set a practical `maxEmails` value for initial testing.
- Use exclusion terms when particular categories of descriptions should be ignored.
- Review the first results before expanding the search.
- If results are below your target, consider broader keywords or additional email domains.
- Remember that larger targets do not guarantee more results when the indexed source information is limited.

### Troubleshooting

**Invalid Input:** Check that `keywords` is an array of strings and that `maxEmails` is an integer between 1 and 10,000. Verify that optional arrays such as `customDomains` and `excludeWords` contain strings.

**Empty Results:** Try broader or more specific keywords depending on your research goal. You can also remove the location filter or test additional email domains.

**Fewer Results Than Requested:** `maxEmails` is a collection target rather than a guarantee. The available indexed results may not contain enough matching email addresses.

**Partial Results:** Search coverage can vary depending on the available indexed information. Additional keywords or domains may provide different coverage.

**Too Many Unwanted Results:** Add relevant terms to `excludeWords` or make the search keywords more specific.

**Location Results Are Too Narrow:** Check the spelling and scope of the location value. Removing the location filter can broaden the search.

**Email Results Are Limited:** Review `customDomains` and consider adding relevant domains such as `@yahoo.com` or `@outlook.com`.

**Large Runs Take Longer:** Wide searches can require more processing. The Actor input guidance recommends increasing the run timeout when necessary; the documented default timeout is 3600 seconds.

### Frequently Asked Questions

**What does the Meesho Email Scraper do?**

The Meesho Email Scraper searches for relevant publicly indexed Meesho results based on your keywords and extracts matching email addresses from available result descriptions.

**What input does the Actor require?**

The only required input is `keywords`, which is an array of search keywords or queries.

**Can I use multiple keywords?**

Yes. The `keywords` field accepts multiple search terms, allowing you to cover different seller, supplier, business, or marketplace-related searches in one run.

**Can I target a specific location?**

Yes. The optional `location` field accepts a country, state, or city and can be used to narrow the search.

**Can I choose which email domains are collected?**

Yes. Use `customDomains` to specify email-domain suffixes such as `@gmail.com`, `@yahoo.com`, or `@outlook.com`.

**What does `maxEmails` control?**

It controls the maximum email target for each keyword + domain combination. The permitted value is from 1 to 10,000.

**Does the Meesho Email Scraper guarantee the requested number of emails?**

No. The target does not guarantee a specific number of results. Collection depends on the publicly indexed information that matches the configured search.

**What happens when I use exclude words?**

If a result description contains an excluded word or phrase, that result is skipped and an email is not collected from that description.

**Are duplicate email addresses collected?**

The Actor tracks collected email addresses and avoids intentionally adding the same email address more than once during a run.

**What data appears in the output?**

Each record contains `keyword`, `title`, `description`, `url`, and `email`.

**Can I use the Actor for business research?**

Yes. The structured output can support seller research, supplier discovery, marketplace analysis, contact research, and other workflows involving publicly indexed Meesho-related information.

### NLP Keywords

- Meesho email scraper
- Meesho email extraction
- Meesho contact data
- Meesho seller emails
- Meesho supplier emails
- Meesho business contacts
- Meesho lead research
- Meesho contact discovery
- Meesho public email data
- Meesho seller research
- Meesho supplier research
- Meesho marketplace data
- Meesho business research
- Meesho email collection
- Meesho contact extraction
- Meesho structured data
- Meesho lead dataset
- Meesho email leads
- Meesho keyword search
- Meesho contact dataset

### Related Keywords

- Meesho seller email finder
- Meesho supplier email scraper
- Meesho business email extractor
- Meesho contact scraper
- Meesho lead scraper
- Meesho email finder
- Meesho seller contact research
- Meesho supplier contact discovery
- Meesho marketplace email extraction
- Meesho business lead collection
- Meesho public contact extraction
- Meesho email data collection
- Meesho seller lead research
- Meesho supplier research tool
- Meesho contact data extraction
- Meesho keyword email scraper
- Meesho email lead dataset
- Meesho business contact dataset
- Meesho marketplace research
- Meesho contact research automation

### Final Overview

Meesho Email Scraper provides a structured way to research publicly indexed Meesho-related contact information using configurable search keywords, optional geographic targeting, custom email domains, maximum collection targets, and exclusion terms.

Its output focuses on five practical fields: keyword, title, description, URL, and email. This gives users both the extracted contact address and the search-result context associated with it.

For the most useful results, start with focused keywords, test a small configuration, review the returned dataset, and then expand the keyword, location, or email-domain settings according to the research objective. Remember that collection targets depend on the amount of publicly indexed information available for the selected searches.

*Contact me:* <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": [
    "supplier",
    "seller"
  ],
  "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": [
        "supplier",
        "seller"
    ],
    "location": "",
    "customDomains": [
        "@gmail.com"
    ],
    "excludeWords": []
};

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

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

```

## MCP server setup

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