# Aleo Email Scraper (`email_scraper/aleo-email-scraper`) Actor

Aleo Email Scraper extracts publicly available email addresses from Aleo using targeted keywords, locations, custom email domains, and exclusion filters. Build structured Aleo lead lists for prospecting, B2B research, marketing, and contact discovery.

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

### 🔎 Aleo Email Scraper – Overview

**Aleo Email Scraper** is an Apify Actor designed to discover email addresses associated with relevant Aleo search results using keywords, optional geographic targeting, selected email domains, and exclusion filters.

It is built for lead generation, contact discovery, prospecting, market research, and building structured Aleo contact lists. Instead of manually searching Aleo pages and copying contact information, the **Aleo Email Scraper** automates the search process and places matching results into an Apify Dataset.

> 💡 **Aleo Email Scraper at a glance**
>
> - Search Aleo pages using one or multiple keywords.
> - Narrow results with an optional country, state, city, or other location.
> - Filter for selected email domain suffixes such as `@gmail.com`.
> - Exclude unwanted profile snippets with custom words or phrases.
> - Collect structured fields including keyword, title, description, URL, and email.
> - Remove duplicate email addresses across the run.
> - Store discovered results directly in an Apify Dataset.

The easiest workflow is simple: enter your target keywords, optionally add a location, select the email domains you care about, choose the desired `maxEmails` target, and start the Actor.

The **Aleo Email Scraper** is especially useful when your research depends on combining search intent with contact discovery. More specific keyword combinations can help you identify more relevant Aleo pages than relying on a single broad term.

> 🎯 **Why use Aleo Email Scraper?**
>
> - Turn keyword ideas into a structured Aleo lead list.
> - Combine job titles, professions, industries, services, or business terms.
> - Focus searches geographically when a region or city matters.
> - Target specific public email domains.
> - Reduce irrelevant results with the exclusion filter.
> - Receive structured records ready for downstream lead management.

### ⚡ Aleo Email Scraper – Key Features

The **Aleo Email Scraper** focuses on configurable search and email extraction rather than generic page collection. Each option is designed to improve contact discovery while keeping the collected data organized.

#### 🔍 Keyword-Based Aleo Search

Enter one or many keywords or search queries. The Actor processes each keyword separately, making it possible to build a wider lead list from related search terms.

For example, instead of searching only for:

- `Fitness`

you can test more specific terms such as:

- `Fitness Coach`
- `Fitness Trainer`
- `Online Fitness Coach`
- `Fitness Influencer`

The same strategy works for professions, industries, services, company types, or niche-specific terms.

#### 📍 Optional Location Targeting

The **Aleo Email Scraper** supports an optional `location` field. You can enter a country, state, city, or another geographic term to narrow the search.

Examples include:

- `Germany`
- `Berlin`
- `Munich`
- `United Kingdom`

Leave the location field blank when geographic targeting is not required and you want a broader search.

#### ✉️ Custom Email Domain Filtering

The `customDomains` input lets you specify which email domain suffixes the Actor should search for.

Examples include:

- `@gmail.com`
- `@yahoo.com`
- `@outlook.com`
- `@hotmail.com`
- A business domain such as `@example.com`

Using multiple domains can expand contact discovery across different types of publicly listed email addresses.

#### 🎯 Per-Keyword + Domain Email Target

`maxEmails` controls the collection target for each keyword and email-domain combination.

For example, with:

- 3 keywords
- 2 email domains
- `maxEmails: 20`

the Actor processes all 6 keyword-domain combinations, targeting up to 20 matching addresses for each combination, subject to available results and duplicate detection.

Lower targets can make smaller searches easier to manage, while higher targets allow the **Aleo Email Scraper** to continue deeper into available search results.

#### 🚫 Exclude Unwanted Terms

The `excludeWords` field allows you to skip search-result descriptions containing unwanted words or phrases.

For example:

- `crypto`
- `onlyfans`
- `gambling`

The exclusion matching is case-insensitive. A single word is matched as a whole word, while a multi-word phrase is matched as a phrase within the description snippet.

> ⚠️ **Important:** When an exclusion term matches a description snippet, that entire snippet is skipped and no email is extracted from it.

#### ♻️ Duplicate Email Handling

The **Aleo Email Scraper** keeps track of already discovered email addresses during the run. When the same email appears again in another matching result, it is not added as a new lead.

This helps keep the final contact dataset cleaner and reduces repeated email addresses when multiple searches overlap.

### 📊 Aleo Email Scraper – What Data You Can Extract

The **Aleo Email Scraper** produces structured lead records containing the search context, page information, and discovered email address.

> 📦 **Stored output fields**
>
> - `network` — Identifies the source network as `Aleo.com`.
> - `keyword` — The keyword that produced the matching result.
> - `title` — The title of the search result.
> - `description` — The available search-result description or snippet.
> - `url` — The URL associated with the result.
> - `email` — The extracted email address matching the selected domain suffix.

The default Dataset view displays these fields:

| Field         | Description                     |
| ------------- | ------------------------------- |
| `keyword`     | Search term used for the result |
| `title`       | Result title                    |
| `description` | Result description/snippet      |
| `url`         | Result URL                      |
| `email`       | Extracted email address         |

The `network` field is present in the pushed record but is not included in the default Dataset table view.

#### 🧾 Sample Output Data

```json
{
  "network": "Aleo.com",
  "keyword": "Bauunternehmen",
  "title": "Example Construction Business",
  "description": "Example profile description containing contact@example.com",
  "url": "https://www.aleo.com/example",
  "email": "contact@example.com"
}
```

The exact title, description, URL, and email values depend on what matching public results are available during the run.

> ✅ **Output note:** The Actor only documents the fields actually produced by its record structure. It does not claim additional profile attributes such as phone numbers, addresses, social links, ratings, or company financial data.

### 🚀 Aleo Email Scraper – How to Use

Using the **Aleo Email Scraper** requires only a few configuration choices.

#### 1. 🔑 Enter Your Keywords

Add one or more terms in the `keywords` field.

Use specific and related phrases when possible. A combination of professional terms, services, industries, and niche keywords can improve the relevance of your lead list.

Example:

```json
"keywords": [
  "Bauunternehmen",
  "Einzelhandel",
  "Immobilienmakler"
]
```

#### 2. 📍 Add a Location When Needed

Use `location` to narrow the search geographically.

```json
"location": "Berlin"
```

Leave it empty for a wider search:

```json
"location": ""
```

#### 3. ✉️ Select Email Domains

Choose the email suffixes you want to collect.

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

#### 4. 🎯 Set the Email Target

Set `maxEmails` between 1 and 10,000 in the Actor input.

```json
"maxEmails": 10
```

The target applies independently to each keyword and domain combination.

#### 5. 🚫 Add Exclusion Terms

Use `excludeWords` to remove irrelevant snippets.

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

#### 6. ▶️ Start the Run

A complete example input looks like this:

```json
{
  "keywords": [
    "Bauunternehmen",
    "Einzelhandel"
  ],
  "location": "Germany",
  "customDomains": [
    "@gmail.com",
    "@outlook.com"
  ],
  "maxEmails": 10,
  "excludeWords": [
    "crypto"
  ]
}
```

After the run starts, matching records are added to the Apify Dataset as they are discovered.

> 📌 **Input summary**
>
> - `keywords` is required.
> - `location` is optional.
> - `customDomains` is optional and defaults to `@gmail.com`.
> - `maxEmails` accepts values from 1 to 10,000, with a default of 5 in the Actor input configuration.
> - `excludeWords` is optional and defaults to an empty list.

### 🔍 How to Scrape Aleo Emails with Keywords and Locations

The **Aleo Email Scraper** works best when the search strategy reflects the actual audience you are trying to identify.

For B2B lead generation, combine industry terms with professional or business terms. For example, a German prospecting campaign could use terms such as:

- `Bauunternehmen`
- `Architekt`
- `Immobilienmakler`
- `Einzelhandel`

For local lead generation, add a city or country in the `location` input.

For broader contact discovery, leave `location` blank and use several related keywords. This can expose more search variations while keeping each keyword independently measurable in the resulting dataset.

> 💡 **Search strategy tip**
>
> - Start with several focused keywords rather than one extremely broad term.
> - Add related job titles, services, and industry phrases.
> - Use a location when local targeting matters.
> - Add multiple email domains when your target audience is not limited to one provider.
> - Review sparse searches and broaden the terms when necessary.

The **Aleo Email Scraper** is designed around public search results, so results depend on what relevant pages and email addresses are publicly discoverable at run time.

### 🧩 Can Aleo Email Scraper Search Multiple Email Domains?

Yes. The `customDomains` field accepts multiple domain suffixes, and the Actor works through the combinations of your keywords and selected domains.

This is useful when your prospect list can contain both personal and business contact addresses.

For example:

```json
"keywords": [
  "Software Agency",
  "Digital Marketing"
],
"customDomains": [
  "@gmail.com",
  "@outlook.com",
  "@company.com"
]
```

This creates separate search targets for each keyword-domain combination.

However, duplicate emails are not repeatedly stored. The same address can be encountered from more than one search combination, but the Actor tracks previously discovered addresses and keeps them unique.

### 🎯 Aleo Email Scraper – Use Cases

The **Aleo Email Scraper** can support several practical research and lead-generation workflows.

#### 💼 B2B Lead Generation

Build targeted business contact lists by combining company, industry, or profession keywords with email-domain filtering.

#### 📈 Sales Prospecting

Sales teams can use keyword-based contact discovery to identify potential prospects matching a specific niche or market.

#### 📍 Local Business Research

Add cities, countries, or regions to focus contact research around a defined geographic market.

#### 🏢 Industry Research

Researchers can create structured contact datasets across sectors by running multiple industry-specific keyword searches.

#### 🧲 Marketing Lead Lists

Marketing teams can collect public email addresses associated with relevant search results and organize them by keyword and source URL.

#### 🔎 Niche Prospect Discovery

Highly specific keywords can help identify contacts in narrowly defined industries, professional roles, or service categories.

#### 🗂️ Market Mapping

Run several related searches to build a broader view of a market while retaining the original keyword in every output row.

> 📊 **Use-case note:** The Actor returns search-derived contact information. It should not be treated as a guaranteed source of complete profiles or complete business directories.

### ⚙️ Input Reference

| Input           | Type    | Required | Default                          | Purpose                                         |
| --------------- | ------- | -------: | -------------------------------- | ----------------------------------------------- |
| `keywords`      | Array   |      Yes | `Bauunternehmen`, `Einzelhandel` | Search terms or queries                         |
| `location`      | String  |       No | Empty                            | Country, state, city, or geographic filter      |
| `customDomains` | Array   |       No | `@gmail.com`                     | Email suffixes to include                       |
| `maxEmails`     | Integer |       No | `5`                              | Target per keyword + domain combination         |
| `excludeWords`  | Array   |       No | Empty                            | Words or phrases that exclude matching snippets |

`maxEmails` must be between **1 and 10,000** according to the Actor input configuration.

For free usage, the Actor applies an actor-level ceiling of **100** to the `maxEmails` target when a higher value is requested or no value is provided. Paid runs do not receive that specific actor-level restriction.

### 📦 Output Reference

Every stored result follows the same structured format:

| Field         | Type   | Meaning                           |
| ------------- | ------ | --------------------------------- |
| `network`     | String | Source network identifier         |
| `keyword`     | String | Keyword used for discovery        |
| `title`       | String | Search-result title               |
| `description` | String | Search-result description/snippet |
| `url`         | String | Result URL                        |
| `email`       | String | Matching extracted email address  |

The default Dataset table shows `keyword`, `title`, `description`, `url`, and `email`.

This structure makes the **Aleo Email Scraper** useful for organizing lead lists, filtering records by keyword, reviewing source pages, and connecting discovered contact data with downstream workflows.

### 💰 Aleo Email Scraper – Pricing

No actor-specific price is defined in the supplied Actor configuration, so this README does not state a fixed per-run or per-result price.

> 💳 **Pricing note**
>
> - The supplied Actor configuration does not publish a standalone Actor price.
> - Free usage applies the documented `maxEmails` ceiling of 100.
> - Paid runs are not restricted by that specific actor-level free ceiling.
> - Any broader Apify platform usage charges depend on the applicable Apify account and platform terms.

No internal billing event names or private pricing implementation details are exposed here.

### 🛠️ Tips and Best Practices

#### 🔑 Use Specific Keywords

Specific search terms usually make it easier to target the right type of Aleo contact. Instead of relying on one generic word, create several closely related searches.

#### 🌍 Broaden Location When Results Are Sparse

A very narrow location can reduce available results. Remove the location filter or use a broader region when discovery is too limited.

#### ✉️ Add More Relevant Email Domains

Searching only one domain can leave potential contacts undiscovered. Add other relevant public email suffixes when they match your research goals.

#### 🚫 Refine Exclusion Words Carefully

Exclusion terms operate on the description snippet. A matching term causes the whole snippet to be skipped, so avoid overly broad words that could remove useful records unintentionally.

#### 📊 Inspect Results Before Scaling

Start with a modest `maxEmails` value and a small keyword set. Review the returned keyword, description, URL, and email fields before expanding the search.

#### ⏱️ Allow More Time for Wide Searches

Large keyword and domain combinations can require more search activity. The supplied Actor configuration uses a default run timeout of 3600 seconds, so broader jobs may require appropriate run settings.

> ⚠️ **Important result-quality note**
>
> - The Actor cannot guarantee that every target produces the requested number of emails.
> - Results depend on publicly available matching pages and email addresses.
> - Narrow searches may return few or no usable emails.
> - Duplicate addresses may reduce the number of unique records.
> - Broader searches can increase coverage but may also increase irrelevant results.

### ❓ Frequently Asked Questions

#### 🔎 What is Aleo Email Scraper?

Aleo Email Scraper is an Apify Actor that searches for relevant Aleo results using your keywords and extracts publicly discoverable email addresses matching your selected domain suffixes.

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

You can provide custom email suffixes such as `@gmail.com`, `@yahoo.com`, `@outlook.com`, `@hotmail.com`, or a relevant business domain.

#### 📍 Can I scrape Aleo emails from a specific city or country?

Yes. Enter a country, state, city, or other geographic term in `location` to narrow the search.

#### 🎯 How does maxEmails work?

`maxEmails` is applied to each keyword and email-domain combination. It is not a single shared target across all keyword-domain combinations.

#### 🚫 Can I exclude unwanted profiles?

Yes. Add words or phrases to `excludeWords`. If an exclusion term appears in the result description snippet, that snippet is skipped.

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

Yes. Previously discovered email addresses are tracked, so duplicate addresses are not repeatedly stored as new results.

#### 🧾 What data does Aleo Email Scraper return?

The stored records contain `network`, `keyword`, `title`, `description`, `url`, and `email`. The default Dataset view displays all except `network`.

#### 📈 Why did my Aleo email search return fewer results than requested?

The requested target is not a guarantee. A search can return fewer emails because matching pages may be limited, selected domains may be uncommon, the location may be too narrow, or duplicate emails may have already been discovered.

#### 🌐 Can I leave the location blank?

Yes. An empty `location` means the search is not narrowed by a geographic term.

#### 🔍 How can I improve Aleo email scraping results?

Use several related keywords, broaden the location, add relevant email domains, and remove unnecessary exclusion terms when the result set is too small.

#### 🗃️ Where are the results stored?

The **Aleo Email Scraper** pushes structured records to the Actor's Apify Dataset. The default Dataset view presents the main lead fields in a table.

#### 📊 Can I organize results by keyword?

Yes. Every result includes the `keyword` that produced it, making it easier to group and analyze leads by search topic.

### 🆘 Support

For questions, improvements, custom requirements, or bespoke Actor development related to **Aleo Email Scraper**, contact:

- contact me by email : <alphascraper69@gmail.com>

# Actor input Schema

## `keywords` (type: `array`):

A list of keywords or queries to search for.

## `location` (type: `string`):

Optional country, state or city used to narrow the search. Leave it empty to search without a geographic filter.

## `customDomains` (type: `array`):

List of custom email domains

## `maxEmails` (type: `integer`):

How many addresses each search keyword + domain suffix combination may collect before the finder moves on to the next one. This is a per-combination target, not a run-wide total: with 3 keyword and 2 Domains and a limit of 20, the run works through all 6 combinations and aims for up to 20 addresses in each, so up to 120 overall. Lower values finish sooner and cost less; higher values dig deeper but never guarantee a fuller result, since the run can only find what is publicly listed.

## `excludeWords` (type: `array`):

Words or phrases you do not want to see.

## Actor input object example

```json
{
  "keywords": [
    "Bauunternehmen"
  ],
  "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": [
        "Bauunternehmen"
    ],
    "location": "",
    "customDomains": [
        "@gmail.com"
    ],
    "excludeWords": []
};

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

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

```

## MCP server setup

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