# Mybuilder Email Scraper (`email_scraper/mybuilder-email-scraper`) Actor

Mybuilder Email Scraper extracts publicly indexed email addresses from Mybuilder search results using targeted keywords, locations, custom email domains, and exclusion filters. Build structured Mybuilder lead datasets for research, prospecting, and business data collection.

- **URL**: https://apify.com/email_scraper/mybuilder-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

### Mybuilder Email Scraper

**Mybuilder Email Scraper** is an Apify Actor designed to extract publicly listed email addresses associated with Mybuilder search results based on the keywords you provide. It helps turn targeted search terms into a structured dataset containing the matching keyword, result title, description, URL, and extracted email address.

The Actor is intended for users who need to collect contact information from Mybuilder-related search results for research, prospecting, market analysis, or dataset-building workflows. You can search with one or multiple keywords, optionally narrow results by country, state, or city, choose which email-domain suffixes to look for, and exclude descriptions containing unwanted words or phrases.

The workflow is straightforward: provide search terms, configure optional filters, start the run, and review the structured results in the Apify dataset. The Actor processes keyword and email-domain combinations separately, which allows you to target different search terms and address types within the same run.

### What Is the Mybuilder Email Scraper?

The Mybuilder Email Scraper is an email extraction tool focused on discovering email addresses that appear in publicly indexed Mybuilder-related search results.

Instead of manually searching for individual pages and copying contact details, you can provide a list such as:

- plumber
- builder
- kitchen fitter
- bathroom installer

The Actor then searches for relevant Mybuilder results using each keyword together with the selected email-domain suffixes. A geographic term can also be added when you want to narrow the search.

The resulting dataset is structured for convenient review and further processing. Each collected lead includes the original keyword, result title, result description, source URL, and email address.

### 🔍 Key Features

| Feature                      | Description                                                         | User Benefit                                            |
| ---------------------------- | ------------------------------------------------------------------- | ------------------------------------------------------- |
| Keyword-based search         | Search Mybuilder-related results using your own keywords or queries | Target specific services, professions, or niches        |
| Multiple keywords            | Provide an array of search terms in one run                         | Cover several search intents without separate runs      |
| Location filtering           | Optionally add a country, state, or city                            | Narrow searches toward a geographic market              |
| Custom email domains         | Specify email suffixes such as `@gmail.com` or `@yahoo.com`         | Focus collection on the address types you need          |
| Per-combination email target | Set `maxEmails` for each keyword and domain combination             | Control how deeply each search combination is processed |
| Exclude words filter         | Skip result descriptions containing selected words or phrases       | Reduce unwanted or irrelevant matches                   |
| Duplicate prevention         | Previously collected email addresses are tracked during the run     | Avoid repeatedly storing the same email                 |
| Structured dataset           | Results are pushed into the Apify dataset                           | Review collected leads in an organized format           |

### 📊 What Data Can You Extract?

The Actor returns structured contact records built from matching Mybuilder search results.

The main information available includes:

- **Network** — identifies the source as `Mybuilder.com`.
- **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 associated with the search result.
- **Email** — the email address identified in the result description.

The email field is produced by matching the selected email-domain suffixes against text available in the result description. This means the Actor focuses on email addresses that are publicly present in the indexed search content it processes.

### 🚀 Why Use This Actor?

Manual contact research can require repeatedly searching for businesses, opening results, checking snippets, identifying email addresses, and organizing the information into a usable list.

The Mybuilder Email Scraper provides a repeatable search-and-collection workflow instead.

Its keyword-based approach is useful when your research depends on specific service terms. For example, using several focused terms can cover different types of professionals more effectively than relying on one broad phrase.

The ability to add a location provides another practical layer of targeting. You can leave the location blank for a broader search or provide a country, state, or city when geographic relevance matters.

Custom domains and exclusion terms further refine the collection process without requiring you to manually inspect every search result.

### ✅ Benefits

The main practical benefits are:

- **Automation** — reduce repetitive search and copy-and-paste work.
- **Structured data** — receive results in a consistent dataset format.
- **Targeted discovery** — combine keywords, domains, and optional locations.
- **Flexible filtering** — exclude descriptions containing unwanted terms.
- **Multiple search combinations** — process several keyword and domain combinations in one run.
- **Dataset creation** — build a reusable collection of Mybuilder-related contact records.
- **Research support** — use the collected information for market, business, or competitor research.

Results remain dependent on what is publicly indexed and available for the search terms you provide.

### 📥 Input

The primary input is the `keywords` array. The remaining settings are optional and can be used to refine the search.

| Field           | Type    | Required | Default                  | Description                                                                               |
| --------------- | ------- | -------- | ------------------------ | ----------------------------------------------------------------------------------------- |
| `keywords`      | Array   | Yes      | `["plumber", "builder"]` | Search keywords or queries to use when finding relevant Mybuilder results                 |
| `location`      | String  | No       | `""`                     | Optional country, state, or city used to narrow the search                                |
| `customDomains` | Array   | No       | `["@gmail.com"]`         | Email-domain suffixes to search for                                                       |
| `maxEmails`     | Integer | No       | `5`                      | Maximum email target for each keyword and domain combination; supported range is 1–10,000 |
| `excludeWords`  | Array   | No       | `[]`                     | Words or phrases that cause a matching result description to be skipped                   |

Use several specific keywords when possible. For example, instead of only `builder`, you can provide more targeted terms such as `general builder`, `home builder`, `renovation builder`, or another relevant service phrase.

The `location` field can be left empty for searches without a geographic filter. You can manually enter a country, state, or city when geographic targeting is needed.

The `customDomains` array determines which email suffixes are considered during extraction. Examples include `@gmail.com`, `@yahoo.com`, `@outlook.com`, or a relevant company-domain suffix.

The `excludeWords` filter is case-insensitive. Single words are matched as whole words, while phrases are matched as phrases within the result description.

### 🧾 Input Example

```json
{
  "keywords": [
    "plumber",
    "builder",
    "kitchen fitter"
  ],
  "location": "London",
  "customDomains": [
    "@gmail.com",
    "@yahoo.com",
    "@outlook.com"
  ],
  "maxEmails": 20,
  "excludeWords": [
    "crypto",
    "onlyfans"
  ]
}
```

This configuration searches multiple service terms, focuses on London, checks several email-domain suffixes, targets up to 20 emails for each keyword-domain combination, and skips descriptions containing the specified exclusion terms.

### 📤 Output

The Mybuilder Email Scraper writes collected results to an Apify dataset. Each output record represents a newly identified email address associated with a matching search result.

| Field         | Description                                            |
| ------------- | ------------------------------------------------------ |
| `network`     | Source network identifier, returned as `Mybuilder.com` |
| `keyword`     | Search keyword associated with the result              |
| `title`       | Title of the matching search result                    |
| `description` | Search-result description or snippet                   |
| `url`         | URL associated with the result                         |
| `email`       | Extracted email address                                |

The Actor also configures the dataset view around the fields most useful for lead review: keyword, title, description, URL, and email.

### 📋 Output Example

```json
{
  "network": "Mybuilder.com",
  "keyword": "plumber",
  "title": "Example Plumbing Services - Mybuilder",
  "description": "Local plumbing services. Contact exampleplumbing@gmail.com for enquiries.",
  "url": "https://www.mybuilder.com/example-profile",
  "email": "exampleplumbing@gmail.com"
}
```

The example illustrates the structure returned by the Actor. Actual titles, descriptions, URLs, and email addresses depend on the search results available for the keywords and domain filters you use.

### ⚙️ How to Use the Mybuilder Email Scraper

Using the Actor requires only a few user-facing steps:

1. Enter one or more keywords in the `keywords` field.
2. Add a location when geographic targeting is useful.
3. Choose the email-domain suffixes you want to search for.
4. Set `maxEmails` to control the target for each keyword-domain combination.
5. Add `excludeWords` when certain descriptions should be skipped.
6. Start the Actor.
7. Review the collected records in the Apify dataset.

For larger searches, it is useful to begin with a smaller configuration and inspect the results before expanding the keyword, location, domain, or email target settings.

### 🎯 Use Cases

The Mybuilder Email Scraper can support several practical workflows where publicly indexed Mybuilder contact information is relevant.

**Lead research:** Find publicly indexed business contact addresses associated with specific service categories.

**Market research:** Collect examples of businesses appearing for particular trade or service keywords.

**Local business research:** Combine service-related keywords with a city, state, or country to focus the search geographically.

**Business intelligence:** Create structured datasets for analyzing the presence of service providers across search categories.

**Prospecting research:** Build an initial list of publicly discoverable contact information for further qualification.

**Dataset creation:** Collect keyword-linked records in Apify for later review or analysis.

**Competitive research:** Study which types of businesses and service descriptions appear for selected search terms.

### 🏆 Advantages

The Actor combines several useful controls in one workflow. Multiple keywords help broaden topic coverage, while locations can make a search more geographically focused. Custom domains provide control over which email suffixes the extractor looks for, and exclusion terms make it possible to skip descriptions containing unwanted content.

Another practical advantage is the structured result format. Instead of keeping search information in separate notes or spreadsheets, the Actor places the collected fields into the Apify dataset associated with the run.

### ⚖️ Pros and Cons

| Pros                                      | Cons                                                      |
| ----------------------------------------- | --------------------------------------------------------- |
| Supports multiple search keywords         | Results depend on publicly indexed search content         |
| Optional geographic targeting             | A narrow keyword or location may reduce available matches |
| Custom email-domain filtering             | Only matching email-domain suffixes are collected         |
| Exclude-word filtering                    | Excluded descriptions are skipped entirely                |
| Structured Apify dataset output           | Returned result information can vary by search result     |
| Configurable per-combination email target | Reaching the target is not guaranteed                     |

### 🔄 Comparison With Alternative Approaches

| Capability                   | This Actor | Manual / Typical Alternative                 |
| ---------------------------- | ---------- | -------------------------------------------- |
| Keyword-based discovery      | Supported  | Usually requires repeated manual searches    |
| Multiple keywords in one run | Supported  | Often handled one search at a time           |
| Location filter              | Supported  | Manually added to individual searches        |
| Custom email domains         | Supported  | Requires manual checking                     |
| Exclusion filtering          | Supported  | Usually performed during manual review       |
| Structured dataset           | Supported  | May require manual collection and formatting |
| Duplicate email tracking     | Supported  | Must often be handled manually               |

This comparison describes workflow differences rather than claiming that one approach is universally better.

### 💡 Best Practices

For more useful results, use keywords that closely describe the type of Mybuilder profile or service you are researching.

Prefer several specific search phrases over one extremely broad term when your goal is wider coverage. You can also combine different professional titles, service categories, or related phrases that represent the same research topic.

Use a location only when geographic filtering is useful. An overly specific location can reduce the number of matching results.

Select email domains that are relevant to your project. Adding more domain suffixes can create additional keyword-domain combinations, so start with the domains you actually need.

Use `excludeWords` for clearly unwanted categories or phrases. Review a small run before scaling up to make sure the filter is removing only the content you intend to exclude.

### 🛠️ Limitations

The Actor can only collect email addresses that are present in the result content available to it. It does not guarantee that every Mybuilder profile will contain a public email address.

Search coverage is influenced by the keywords, location, domain suffixes, and available indexed results. Highly specific queries may produce fewer matches, while broad queries can surface a wider range of results.

The `maxEmails` setting is a target for each keyword and domain combination, not a guarantee that the requested number will be found.

The exclusion filter operates on the available result description. When a description matches an exclusion term, the entire result is skipped and no email is taken from that description.

### 🔧 Troubleshooting

**Invalid input:** Check that `keywords` is an array and that each keyword is entered as a valid string. Confirm that `maxEmails` is an integer between 1 and 10,000.

**Empty results:** Try broader keywords, remove an overly restrictive location, or add additional email-domain suffixes.

**Fewer results than expected:** The requested target is not guaranteed. A search may simply contain fewer publicly indexed matching email addresses than the configured target.

**Missing email addresses:** A matching result may not contain a publicly listed address, or the address may not use one of the configured domain suffixes.

**Too many irrelevant results:** Use more specific keywords, add a suitable location, or add exclusion words for unwanted descriptions.

### ❓ Frequently Asked Questions

**What does the Mybuilder Email Scraper do?**
It searches for publicly indexed Mybuilder-related results using your keywords and extracts matching email addresses from the available result descriptions.

**What inputs does the Mybuilder Email Scraper support?**
The required input is `keywords`. Optional inputs are `location`, `customDomains`, `maxEmails`, and `excludeWords`.

**Can I use multiple keywords?**
Yes. The `keywords` field accepts multiple search terms, allowing several related searches within the same Actor run.

**Can I target a specific city or country?**
Yes. Enter a country, state, or city in `location` to narrow the search geographically. Leave it blank when no location filter is needed.

**Which email addresses can be extracted?**
The Actor searches for addresses matching the domain suffixes you provide through `customDomains`. The default domain is `@gmail.com`.

**What does `maxEmails` control?**
It sets the email target for each keyword and domain combination. It supports values from 1 through 10,000.

**Does the Actor guarantee the requested number of emails?**
No. The setting is a collection target. Actual results depend on the publicly available indexed content matching the search configuration.

**What is `excludeWords` used for?**
It lets you skip result descriptions containing unwanted words or phrases. Single words are matched case-insensitively as whole words, while phrases are matched as phrases.

**What output does the Mybuilder Email Scraper return?**
Each record contains `network`, `keyword`, `title`, `description`, `url`, and `email`.

**Is the Actor useful for automation?**
Yes. It is designed as an Apify Actor that accepts structured input and writes structured results to an Apify dataset, making it suitable for repeatable data-collection workflows.

### NLP Keywords

- Mybuilder email scraper
- Mybuilder email extraction
- Mybuilder contact data
- Mybuilder leads
- Mybuilder business contacts
- Mybuilder profile data
- Mybuilder search results
- Mybuilder contact information
- Mybuilder email addresses
- Mybuilder lead generation
- trade business contacts
- contractor email extraction
- builder contact discovery
- plumber lead research
- local trade leads
- service provider contacts
- email domain filtering
- keyword-based email search
- structured lead dataset
- public contact data extraction

### Related Keywords

- Mybuilder scraper
- Mybuilder data scraper
- Mybuilder lead scraper
- Mybuilder contact scraper
- scrape Mybuilder emails
- extract Mybuilder emails
- Mybuilder email finder
- Mybuilder business email finder
- Mybuilder prospecting tool
- Mybuilder lead extraction
- Mybuilder contact extractor
- contractor email finder
- builder email scraper
- plumber email scraper
- trade leads scraper
- local business email extraction
- service business lead scraper
- keyword email scraper
- public email data scraper
- Mybuilder business data extraction

### Final Overview

The Mybuilder Email Scraper provides a focused way to discover publicly indexed email addresses associated with Mybuilder search results. With keyword targeting, optional geographic filtering, custom email-domain selection, exclusion terms, configurable email targets, duplicate prevention, and structured Apify dataset output, it can support lead research, market research, business intelligence, and dataset-building workflows.

For the most useful results, use specific and relevant keywords, review your filters carefully, and validate the collected data before using it in downstream workflows.

*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": [
    "plumber",
    "builder"
  ],
  "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": [
        "plumber",
        "builder"
    ],
    "location": "",
    "customDomains": [
        "@gmail.com"
    ],
    "excludeWords": []
};

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

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

```

## MCP server setup

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