# Software Advice Email Scraper (`email_scraper/software-advice-email-scraper`) Actor

Software Advice Email Scraper extracts publicly listed email addresses from Software Advice search results using targeted keywords, locations, and custom email domains. Build structured lead datasets with titles, descriptions, URLs, and emails for research and B2B prospecting.

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

### 🔍 softwareadvice Email Scraper – Overview

**softwareadvice Email Scraper** is an Apify Actor designed to discover publicly listed email addresses associated with Software Advice search results. It searches Software Advice pages using your chosen keywords, optional location, and selected email-domain suffixes, then returns structured lead data including the matched email, profile title, description, URL, and search keyword.

This Actor is useful for lead generation, market research, prospect discovery, business intelligence, and building targeted contact datasets from publicly visible Software Advice information.

> **💡 softwareadvice Email Scraper at a glance**
>
> - Search Software Advice using multiple keywords
> - Filter searches by country, state, city, or other location text
> - Target specific email domains such as `@gmail.com`
> - Exclude unwanted words or phrases from profile descriptions
> - Collect structured email lead records
> - Deduplicate email addresses during the run
> - Resume progress after interruptions
> - Export collected results through the Apify dataset

The easiest workflow is simple: enter relevant keywords, optionally specify a location, select the email domains you want to find, choose your desired email target, and start the Actor.

### 🔍 softwareadvice Email Scraper – Key Features

The **softwareadvice Email Scraper** provides flexible controls for building more targeted Software Advice email searches rather than relying on one broad query.

> **✨ Key Features**
>
> - **Keyword-based search** — Search with one or many Software Advice-related terms.
> - **Location targeting** — Narrow results using a country, state, city, or another geographic phrase.
> - **Custom email domains** — Search for addresses matching selected domain suffixes.
> - **Exclude words** — Ignore search-result descriptions containing unwanted terms.
> - **Per-combination targeting** — The requested email target is applied independently to each keyword and domain combination.
> - **Structured datasets** — Results are written as individual structured records.
> - **Duplicate protection** — Previously collected email addresses are skipped.
> - **Progress persistence** — Run progress is saved so an interrupted workflow can continue from its stored position.

This combination makes the Actor practical for both highly specific searches and broader Software Advice email discovery campaigns.

### 🔍 softwareadvice Email Scraper – What Data Can You Extract?

The Actor extracts email information found within publicly visible search-result descriptions associated with Software Advice pages. Along with the email address, the dataset preserves useful context about where the contact was discovered.

The resulting records can therefore be used as more than a simple email list. The title, description, and source URL provide additional context for reviewing and qualifying individual leads.

> **📊 Output / Data Fields**
>
> - **network** — Identifies the source network as Software Advice.com.
> - **keyword** — The keyword used when the lead was discovered.
> - **title** — Title associated with the search result.
> - **description** — Textual description or snippet associated with the result.
> - **url** — Source URL for the result.
> - **email** — Extracted email address matching the selected domain suffix.

The primary dataset view presents these records in a table, making it easier to inspect, filter, and work with collected Software Advice leads.

### 🔍 softwareadvice Email Scraper – How to Use It

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

#### 🔹 1. Add your keywords

Enter the search terms you want the Actor to use on Software Advice.

Specific searches generally provide more focused results than extremely broad terms. For example, instead of searching only for `software`, you can use several more descriptive terms such as `software vendor`, `software contacts`, or other phrases that match the type of Software Advice pages you want to discover.

#### 🔹 2. Add a location when needed

The optional location field can narrow the search geographically.

You can enter a country, state, city, or another location phrase. Leaving it blank allows the search to run without a geographic restriction.

#### 🔹 3. Select email domains

Use the email-domain field to define which email suffixes should be searched.

For example:

```text
@gmail.com
@yahoo.com
@outlook.com
```

You can also provide other relevant domain suffixes according to your lead-generation requirements.

#### 🔹 4. Set the email target

`maxEmails` controls how many matching addresses the Actor aims to collect for each **keyword + domain combination**.

For example, with:

```text
Keywords:
contacts
software

Domains:
@gmail.com
@yahoo.com

maxEmails:
20
```

the Actor processes the combinations independently and aims for up to 20 matching emails for each combination, subject to the availability of qualifying public results and duplicate filtering.

#### 🔹 5. Add exclude words when necessary

Use `excludeWords` to remove unwanted results.

For example:

```text
crypto
onlyfans
```

When an excluded word or phrase appears in a result description, that result is skipped and an email from that snippet is not collected.

#### 🔹 6. Start the Actor

Start the run and review the results in the Apify dataset.

The Actor processes keyword and domain combinations systematically and writes discovered records incrementally.

### 🔹 How to Get Better Software Advice Email Results

The quality of your **softwareadvice Email Scraper** results depends heavily on the search terms and email domains you provide.

A useful strategy is to combine several related keywords rather than depending on one generic term.

For example, a Software Advice search focused on software businesses might use:

```text
software
software vendor
software contacts
software provider
business software
SaaS software
```

Using multiple terms gives the Actor more search opportunities and can help uncover different publicly indexed Software Advice results.

Email-domain coverage can also affect discovery. Searching only `@gmail.com` limits the Actor to that suffix. Adding additional relevant domains can broaden the search.

### 🔹 Can I Target a Specific Country or City?

Yes. The optional `location` field allows you to add geographic text to the search.

Examples include:

```text
United States
New York
California
London
Toronto
```

Location filtering is useful when you are building a geographically focused Software Advice contact dataset.

Keep in mind that adding a location makes a search narrower. When results are limited, removing the location or using a broader geographic term may provide greater coverage.

### 🔹 Can I Search Multiple Email Domains?

Yes. The `customDomains` field accepts multiple domain suffixes.

For example:

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

The Actor processes each selected domain together with your keywords. This allows you to create multiple search combinations in the same run.

### 🔹 Can I Exclude Certain Software Advice Profiles?

Yes. The `excludeWords` input can be used to filter out unwanted search-result descriptions.

Single words are matched without regard to capitalization and are treated as whole words. Phrases are matched as text within the description.

For example:

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

This is useful when you want to remove irrelevant categories or terms from a Software Advice lead search before an email is collected.

### 🔹 What Happens When Fewer Emails Are Available?

The **softwareadvice Email Scraper** does not guarantee that every configured target will be reached.

If Software Advice pages available through the search process do not contain enough publicly listed matching email addresses, the Actor may finish below your requested target.

Broadening keywords, adding relevant email domains, or removing an unnecessarily restrictive location can improve potential coverage. However, the Actor can only return qualifying information that is actually available in the searchable results.

### 🔹 Input

The Actor accepts the following inputs.

| Input           | Type    | Required | Description                                                                     |
| --------------- | ------- | -------- | ------------------------------------------------------------------------------- |
| `keywords`      | Array   | Yes      | Keywords or search queries used to discover Software Advice results.            |
| `location`      | String  | No       | Optional country, state, city, or other geographic search term.                 |
| `customDomains` | Array   | No       | Email-domain suffixes to search for, such as `@gmail.com`.                      |
| `maxEmails`     | Integer | No       | Target number of emails for each keyword + domain combination. Range: 1–10,000. |
| `excludeWords`  | Array   | No       | Words or phrases that cause matching result descriptions to be skipped.         |

#### 🔹 Example Input

```json
{
  "keywords": [
    "software",
    "software vendor",
    "software contacts"
  ],
  "location": "United States",
  "customDomains": [
    "@gmail.com",
    "@yahoo.com"
  ],
  "maxEmails": 20,
  "excludeWords": [
    "crypto",
    "onlyfans"
  ]
}
```

### 🔹 Output

Each discovered email is stored as a structured dataset record.

#### 🔹 Example Output

```json
{
  "network": "Software Advice.com",
  "keyword": "software vendor",
  "title": "Example Software Vendor",
  "description": "Example result description containing a public contact email.",
  "url": "https://softwareadvice.com/...",
  "email": "example@gmail.com"
}
```

The exact title, description, URL, and email values depend on the public search results discovered during the run.

### 🔹 Why Use softwareadvice Email Scraper?

The Actor is useful when manually searching Software Advice pages would be repetitive or difficult to scale.

> **🚀 Why Use This Actor**
>
> - Automate repetitive Software Advice email discovery
> - Search across many keywords from one run
> - Combine multiple email-domain targets
> - Refine searches by location
> - Filter unwanted result descriptions
> - Keep useful source context alongside each email
> - Reduce duplicate email collection
> - Continue processing from saved progress after interruptions
> - Store results in an Apify dataset for downstream workflows

Instead of collecting individual contacts manually, you can define a search strategy and let the Actor process the combinations automatically.

### 🔹 Use Cases

The **softwareadvice Email Scraper** can support several practical data-collection workflows.

#### 🔹 Lead Generation

Build targeted prospect lists from Software Advice results using industry, software, vendor, or other relevant keywords.

#### 🔹 Market Research

Collect public contact information alongside titles, descriptions, and source URLs to support market research and competitor discovery.

#### 🔹 B2B Prospecting

Use business-oriented keywords and company-related email domains to identify potential B2B contacts.

#### 🔹 Contact Database Building

Create structured datasets that can later be reviewed, filtered, enriched, or imported into another workflow.

#### 🔹 Geographic Research

Combine keywords with countries, cities, or regions when your research requires location-specific Software Advice results.

### 🔹 Pricing

The provided Actor configuration does not specify a fixed public monetary price, so no specific price is stated here.

> **💰 Pricing Note**
>
> - Check the current Software Advice Email Scraper pricing displayed on its Apify Store page before running large jobs.
> - The `maxEmails` setting controls the requested collection target and can affect how much search work a run performs.
> - Lower targets generally require less collection work than very high targets.

### 🔹 Tips and Best Practices

For stronger **softwareadvice Email Scraper** searches, start with focused keywords that closely describe the type of result you want.

Using several related search terms is often more useful than one extremely broad keyword. You can also combine those terms with multiple appropriate email domains to increase search coverage.

When results are sparse, review your location and keyword restrictions. A very narrow combination may naturally produce fewer qualifying addresses.

> **⚡ Important Notes**
>
> - `keywords` is required.
> - `maxEmails` accepts values from **1 to 10,000**.
> - The requested email target is applied independently to each keyword + domain combination.
> - Free runs are subject to the Actor's configured free-tier collection restriction.
> - Duplicate email addresses are skipped during collection.
> - The Actor may return fewer results than requested when matching public data is unavailable.
> - Excluded descriptions are skipped before email collection.
> - Broader or more specific search terms can be tested when a query produces sparse results.

### 🔹 Frequently Asked Questions

#### 🔹 What is softwareadvice Email Scraper used for?

The softwareadvice Email Scraper is used to discover publicly listed email addresses associated with searchable Software Advice results. It also returns contextual information such as the result title, description, keyword, and URL.

#### 🔹 How do I scrape emails from Software Advice?

Enter one or more keywords, optionally add a location, choose the email domains you want to search, set `maxEmails`, and run the Actor. Matching public email addresses are returned in the Apify dataset.

#### 🔹 Can I scrape Software Advice emails by keyword?

Yes. Keywords are the main search mechanism. You can provide multiple keywords so the Actor processes several Software Advice search terms within the same run.

#### 🔹 Can I target Software Advice contacts by location?

Yes. The optional `location` input can be used with a country, state, city, or other geographic term to narrow the search.

#### 🔹 Can I search Gmail addresses on Software Advice?

Yes. Add `@gmail.com` to `customDomains` to search for matching Gmail addresses.

#### 🔹 Can I search multiple email domains?

Yes. Multiple domain suffixes can be supplied in `customDomains`, and the Actor processes them as separate keyword + domain combinations.

#### 🔹 What happens when an excluded word is found?

When a result description contains a configured excluded word or phrase, that result is skipped and an email is not extracted from that description.

#### 🔹 Does the scraper remove duplicate emails?

Yes. The Actor tracks previously collected email addresses and skips duplicates during collection.

#### 🔹 Does softwareadvice Email Scraper guarantee my maxEmails target?

No. `maxEmails` is a target, not a guarantee. The actual number depends on the qualifying publicly available search results.

#### 🔹 What data does the Software Advice email scraper return?

Each record can contain the network name, search keyword, result title, result description, source URL, and extracted email address.

#### 🔹 Can I use the results in an automated workflow?

The Actor stores structured records in an Apify dataset, making the collected data available through Apify's dataset-based workflows and supported export options.

#### 🔹 Is `keywords` required?

Yes. The Actor requires the `keywords` input.

#### 🔹 What is the maximum value for `maxEmails`?

The configured maximum is **10,000** per keyword + domain combination. Actual collection can be lower depending on available matching results.

#### 🔹 Why did my run collect fewer emails than requested?

A search may contain fewer qualifying public email addresses than your target. Narrow keywords, restrictive locations, limited email domains, unavailable results, duplicates, and excluded descriptions can all reduce the final count.

### 🔹 Support

For questions, custom requirements, or Actor-related assistance, 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": [
    "contacts",
    "software",
    "vendor"
  ],
  "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": [
        "contacts",
        "software",
        "vendor"
    ],
    "location": "",
    "customDomains": [
        "@gmail.com"
    ],
    "excludeWords": []
};

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

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

```

## MCP server setup

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