# Walmart Email Scraper (`email_scraper/walmart-email-scraper`) Actor

Extract public email addresses from Walmart.com search results with the Walmart Email Scraper. Search by keywords, target countries or cities, filter unwanted results, choose email domains, and collect structured Walmart lead data automatically.

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

### Walmart Email Scraper Overview

Walmart Email Scraper is an Apify Actor built to discover publicly indexed email addresses associated with Walmart.com search results. It turns keyword-based searches into structured lead records by querying Google SERPs through Apify's `GOOGLE_SERP` proxy, parsing organic results, filtering descriptions, and extracting emails that match the configured domain suffixes.

#### What the Walmart Email Scraper Searches

The Actor builds searches in the form `site:walmart.com <keyword> "<domain>"` and optionally adds the selected location. This means the extraction is based on information visible in Google search-result pages for Walmart.com content, not on private accounts or private contact databases.

The Walmart Email Scraper reads organic SERP result titles, URLs, and descriptions, then looks for email addresses matching the requested domains. Only addresses found in the parsed result descriptions are emitted.

### Walmart Email Scraper Features

The Walmart Email Scraper combines several practical controls for targeted public-data discovery:

- **Keyword search:** Submit one or many search terms, such as `gaming laptop`, `smart tv`, `supplier`, or `vendor`.
- **Location targeting:** Add a country, state, or city to narrow search intent.
- **Custom email domains:** Search for `@gmail.com`, `@yahoo.com`, `@outlook.com`, or other suffixes.
- **Exclude words:** Skip descriptions containing unwanted words or phrases before email extraction.
- **Per-combination limits:** `maxEmails` is applied independently to each keyword + domain pair.
- **Pagination:** Each keyword/domain combination can paginate through Google results until stopping conditions are reached.
- **De-duplication:** Previously seen email addresses are tracked so the same address is not emitted repeatedly.
- **Resume support:** Progress and seen-email state are persisted in Apify Key-Value Store.
- **Incremental output:** Records are pushed to the Apify dataset as they are found.
- **Proxy rotation:** The Actor uses the `GOOGLE_SERP` Apify proxy group and can rotate the proxy URL after request failures.

### How to Use the Walmart Email Scraper

Using the Walmart Email Scraper starts with the keywords you want to investigate. Add several specific search terms rather than relying on one broad word when you need more targeted discovery.

For example, a supplier research run could use `appliances supplier`, `electronics vendor`, `home goods supplier`, and `kitchen products vendor`. More focused terms can produce different indexed results and therefore different opportunities for finding public contact information.

Next, choose the email domains you want to match. The default is `@gmail.com`, but the Actor accepts multiple custom suffixes. Each keyword/domain combination is processed as its own search target.

You can optionally provide a region or location. When supplied, it is added to the Google query as another quoted term. Leave it blank when you want a broader search without a geographic filter.

The `excludeWords` input is useful when certain result descriptions should be ignored. Single words are matched case-insensitively as whole words, while phrases are matched as case-insensitive substrings.

Finally, set `maxEmails`. The Actor processes each keyword + domain combination with its own cap. For example, 3 keywords × 2 domains with a limit of 20 creates 6 combinations, each targeting up to 20 newly discovered addresses, subject to what Google results actually contain.

### Walmart Email Scraper Data Extraction

The Walmart Email Scraper extracts information from parsed organic Google results associated with Walmart.com pages. Each accepted result can produce a structured record containing the search keyword, result title, description snippet, URL, email address, and network identifier.

The extraction pattern is built from the selected email domains. This allows the run to focus on specific suffixes rather than returning every email address encountered in a snippet.

#### Walmart Email Scraper Email Matching Behavior

Email matching uses a regular expression that combines the selected custom domain suffixes with a standard local-part pattern. Because extraction is performed against result descriptions, the quality and quantity of returned addresses depend on what is publicly indexed and displayed by Google.

#### Walmart Email Scraper Filtering and De-duplication

Before extracting an address, the Actor checks the result description against every configured exclusion term. Matching is case-insensitive. A single-word exclusion uses whole-word matching; a multi-word phrase uses substring matching.

After extraction, the Actor checks the persistent seen-email set. Addresses already registered during the run are skipped, helping prevent duplicate output across pages, keywords, and domains.

### Walmart Email Scraper Use Cases

The Walmart Email Scraper can support practical research and prospecting workflows where publicly indexed Walmart-related pages contain contact information.

#### Walmart Email Scraper Supplier and Vendor Research

Use product and sourcing terms such as supplier, distributor, vendor, manufacturer, or category-specific phrases to discover public email addresses connected to indexed Walmart.com results.

#### Walmart Email Scraper Lead Generation

Sales and business development teams can use keyword combinations to discover publicly listed contact emails that are relevant to a product category, market segment, or search theme.

#### Market Research

Researchers can collect result titles, snippets, URLs, keywords, and matching emails to investigate how specific commercial topics appear across indexed Walmart.com content.

#### Competitor and Category Research

Keyword-driven searches can help identify public pages and contact signals around specific product categories, brands, or supplier-related terms.

#### Location-Based Research

Adding a country, state, or city can narrow search intent when the indexed result text contains matching geographic information.

### Walmart Email Scraper Input

The Walmart Email Scraper accepts a JSON object with one required field and four optional controls.

| Input           | Type             | Required | Default                                               | Description                                                                             |
| --------------- | ---------------- | -------- | ----------------------------------------------------- | --------------------------------------------------------------------------------------- |
| `keywords`      | Array of strings | Yes      | `["gaming laptop", "smart tv", "supplier", "vendor"]` | Search keywords or queries. Each keyword is combined with every selected email domain.  |
| `location`      | String           | No       | `""`                                                  | Optional country, state, or city used to narrow the Google search.                      |
| `customDomains` | Array of strings | No       | `["@gmail.com"]`                                      | Email suffixes to match during extraction.                                              |
| `maxEmails`     | Integer          | No       | `10`                                                  | Maximum target per keyword + domain combination. Allowed input range is 1–10,000.       |
| `excludeWords`  | Array of strings | No       | `[]`                                                  | Words or phrases that cause a result description to be skipped before email extraction. |

The `keywords` field is the core input. Since every keyword is combined with every domain, increasing both lists increases the number of search combinations the Actor processes.

For free-plan executions, the code lowers a requested `maxEmails` value above 100 to 100. Paid/local executions are treated as having no such code-level ceiling. The resulting target remains subject to the per-combination behavior described above.

### Walmart Email Scraper Output Data

The Walmart Email Scraper pushes records incrementally to the Apify dataset. The implementation creates the following fields:

| Field         | Type   | Description                                                                                  |
| ------------- | ------ | -------------------------------------------------------------------------------------------- |
| `network`     | String | Source network identifier. The Actor sets this to `Walmart.com`.                             |
| `keyword`     | String | Keyword used for the search combination that produced the record.                            |
| `title`       | String | Title extracted from the Google organic result.                                              |
| `description` | String | Description/snippet text parsed from the search result.                                      |
| `url`         | String | URL extracted from the organic search result.                                                |
| `email`       | String | Unique email address extracted from the description and matching the selected domain suffix. |

The Dataset view configured in `actor.json` displays `keyword`, `title`, `description`, `url`, and `email` in a table. The `url` column is rendered as a link, making it easier to inspect the indexed result behind an extracted address.

The `network` field is also pushed by the implementation, even though it is not included in the configured default table transformation. This field identifies the source context as `Walmart.com`.

### Walmart Email Scraper Example Input

The following input follows the exact schema exposed by the Actor:

```json
{
  "keywords": [
    "gaming laptop supplier",
    "smart tv vendor",
    "electronics distributor"
  ],
  "location": "United States",
  "customDomains": [
    "@gmail.com",
    "@yahoo.com",
    "@outlook.com"
  ],
  "maxEmails": 20,
  "excludeWords": [
    "crypto",
    "onlyfans"
  ]
}
```

This configuration creates 9 keyword/domain combinations. Each combination has a target of up to 20 matching addresses, subject to available Google results and the Actor's stopping logic.

### Walmart Email Scraper Example Output

A representative dataset row produced by the implementation looks like this:

```json
{
  "network": "Walmart.com",
  "keyword": "gaming laptop supplier",
  "title": "Example Walmart Supplier Result",
  "description": "Example public result snippet with contact seller@example.com information.",
  "url": "https://www.walmart.com/...",
  "email": "seller@example.com"
}
```

The example illustrates the actual field structure. Exact titles, descriptions, URLs, and email addresses depend on the public Google results available at run time.

### Walmart Email Scraper Data Quality and Reliability

The Walmart Email Scraper is designed around public SERP extraction rather than direct private-data access. Its reliability therefore depends on Google indexing, the visible text of result descriptions, matching email domains, and the availability of relevant Walmart.com pages.

Pagination is implemented per keyword/domain pair. The Actor requests Google search pages in ten-result increments and can examine up to 1,000 page positions for a pair, although normal stopping conditions usually end a search earlier.

The collector stops for several efficiency reasons, including three consecutive pages with no new emails, two consecutive empty-result pages after page 25, low recent email yield after page 25, or repeated fetch failures.

Requests use the `GOOGLE_SERP` Apify proxy group. When a request fails, the Actor retries after rotating the proxy URL. After three consecutive fetch cycles that still fail, the current keyword/domain pair is aborted.

Progress is persisted after material changes. The Actor stores the seen-email set and the current keyword/domain cursor in Apify Key-Value Store so a later execution can continue from the saved position rather than rebuilding all state from scratch.

### Walmart Email Scraper Search Intent

People searching for a Walmart Email Scraper typically want a way to turn Walmart-related search intent into structured public contact data. Common goals include discovering supplier emails, finding vendor contacts, researching commercial categories, collecting public business signals, and creating keyword-focused lead datasets.

For teams comparing public contact discovery options, the Walmart Email Scraper provides a focused workflow around Walmart.com search results.

The Actor is especially aligned with searches such as Walmart email extraction, Walmart contact scraper, Walmart lead generation, Walmart public data extraction, Walmart supplier email search, and Walmart vendor research.

Because the Actor searches Google with a `site:walmart.com` constraint, its results are specifically tied to publicly indexed Walmart.com content. The quality of the resulting dataset improves when keywords describe clear commercial intent and selected email domains match the contact types you are trying to find.

### Why Use the Walmart Email Scraper

The Walmart Email Scraper removes repetitive manual work from keyword-based Google result review. Instead of opening pages one by one, users define search terms, optional geography, domain suffixes, exclusions, and a per-combination target.

Its structured dataset output preserves the keyword context, result title, description, URL, and extracted email, making it easier to understand why a contact was returned and to continue analysis in Apify.

The Actor also provides persistent de-duplication and incremental writes. When a record is discovered, it is pushed to the dataset and the progress state is saved, helping long-running runs retain useful work.

### API and Automation with Walmart Email Scraper

The Walmart Email Scraper runs as an Apify Actor, so its inputs and dataset output can be used within standard Apify execution and automation workflows. The supplied implementation itself does not define a separate custom REST service; it relies on the Actor runtime, Apify dataset storage, and Key-Value Store for execution state.

Prepare the same JSON input structure shown above and run the Actor with the keywords, domains, location, exclusions, and target appropriate to your research task. The dataset is populated incrementally as matching addresses are found.

### Walmart Email Scraper FAQs

#### What is the Walmart Email Scraper and when should I use it?

The Walmart Email Scraper is an Apify Actor that searches Google for publicly indexed Walmart.com results and extracts matching email addresses from result descriptions.

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

It builds `site:walmart.com` Google queries using your keywords and selected domain suffixes, parses organic results, and extracts matching addresses from their descriptions.

#### Does the Walmart Email Scraper scrape private emails?

No. The implementation extracts emails visible in parsed public Google search-result descriptions. It does not describe or implement private-account access.

#### Can I search multiple keywords?

Yes. `keywords` is an array, so you can provide multiple search phrases. Every keyword is processed with every selected email domain.

#### Can I use multiple email domains?

Yes. `customDomains` accepts multiple suffixes. Each suffix becomes a separate keyword/domain search combination.

#### Is the maxEmails value global?

No. In the processing logic, the target is applied independently to each keyword + domain combination. Your total output can therefore exceed a single `maxEmails` value when you use multiple combinations.

#### Can I filter unwanted results?

Yes. `excludeWords` can contain single words or phrases. Matching is case-insensitive, and matching descriptions are skipped before email extraction.

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

Yes. Use the optional `location` string. The value is added to the Google query to narrow the search when relevant geographic text is indexed.

#### What happens when Google has few matching emails?

The Actor uses several stopping conditions to avoid continuing indefinitely through low-yield pages. A run can therefore finish with fewer results than the requested target.

#### Does the Walmart Email Scraper remove duplicates?

Yes. A persistent seen-email set is used to prevent already registered email addresses from being emitted again.

#### Does the Actor support long-running jobs?

The implementation includes pagination, proxy retry, incremental dataset writes, and persisted progress state. These features are intended to support larger search runs, while actual runtime depends on the number of keyword/domain combinations and available results.

#### What output fields should I expect?

The implementation pushes `network`, `keyword`, `title`, `description`, `url`, and `email`. The default dataset table highlights the last five fields except `network`.

#### Is the email extraction guaranteed to find every contact?

No. Extraction depends on public Google snippets and the configured domain pattern. An email that is not present in the parsed result description cannot be extracted by this implementation.

### Best Practices for the Walmart Email Scraper

Use several specific keywords instead of one generic term when you need wider coverage. Combining product categories, supplier roles, business types, and search intent can create more distinct SERP queries.

Choose domains that match your objective. Consumer domains such as Gmail, Yahoo, and Outlook can be useful for public contact discovery, while a custom company domain may be useful for specific B2B research.

Use location only when geography is important. Leaving it blank gives the query broader scope, while a country or city can improve relevance when the indexed text contains matching location information.

Keep `maxEmails` realistic. Higher targets can require more pagination, but the Actor cannot invent contacts that are not publicly surfaced in search results.

### Walmart Email Scraper Support

For questions, bug reports, improvement requests, or bespoke Actor development, use the support channel provided on the Actor page. The supplied Actor description also provides `alphascraper69@gmail.com` for custom tweaks or bespoke builds.

The Walmart Email Scraper is designed to make keyword-driven Walmart.com public contact discovery easier to automate, inspect, and export as structured Apify dataset records.

# 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": [
    "gaming laptop",
    "smart tv",
    "supplier",
    "vendor"
  ],
  "location": "",
  "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": [
        "gaming laptop",
        "smart tv",
        "supplier",
        "vendor"
    ],
    "location": "",
    "customDomains": [
        "@gmail.com"
    ],
    "excludeWords": []
};

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

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

```

## MCP server setup

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