# Redfin Email Scraper (`email_scraper/redfin-email-scraper`) Actor

Redfin Email Scraper extracts publicly indexed email addresses from Redfin search results using targeted keywords, locations, and custom email domains. Build structured real estate lead lists with titles, descriptions, URLs, and unique email contacts.

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

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

### 🔹 Redfin Email Scraper – Overview

The **Redfin Email Scraper** is an Apify Actor designed to find publicly listed email addresses associated with Redfin search results. It uses search keywords, optional locations, and selected email domains to discover relevant Redfin profile pages and extract matching contact emails.

Instead of manually opening search results one by one, the Redfin Email Scraper automates keyword-based discovery and organizes the collected leads into a structured Apify dataset.

It is useful for lead generation, real estate research, prospect discovery, market research, and building targeted contact lists from publicly available Redfin search-result information.

> **💡 Redfin Email Scraper at a glance**
>
> - Search Redfin using multiple keywords or queries
> - Narrow results with a country, state, or city
> - Target specific email domains such as `@gmail.com`
> - Exclude unwanted words or phrases from descriptions
> - Collect unique email addresses
> - Store structured results in an Apify dataset
> - Process multiple keyword + domain combinations
> - Resume progress after an interrupted run

### 🔍 Redfin Email Scraper – Key Features

The Redfin Email Scraper focuses on targeted email discovery rather than collecting unrelated information. You control the search terms, location, email domains, and result target.

#### 🎯 Targeted Keyword Search

Enter one or multiple keywords that describe the type of Redfin profiles or contacts you want to discover.

For example:

- Real Estate Agent
- Property Manager
- Realtor
- Real Estate Broker
- Property Investor
- Real Estate Company

Using several related keywords can increase search coverage because different profiles may appear for different search terms.

#### 📍 Location-Based Search

The optional **Region / Location** field lets you narrow the search geographically.

You can enter a:

- Country
- State
- City
- Other geographic search term

Leave the location empty when you want broader search coverage.

#### 📧 Custom Email Domains

The Redfin Email Scraper can target specific email-domain suffixes.

Examples include:

- `@gmail.com`
- `@yahoo.com`
- `@outlook.com`
- `@hotmail.com`
- `@icloud.com`
- Custom business domains

This makes it possible to focus your email extraction around the types of addresses most relevant to your campaign.

#### 🚫 Exclude Words

The **Exclude Words** filter helps remove unwanted search-result snippets.

If a description contains an excluded word or phrase, that result is skipped instead of extracting an email from it.

For example:

- crypto
- onlyfans
- unrelated
- unwanted phrases

Single words are matched as complete words, while phrases are matched as phrases without case sensitivity.

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

The Redfin Email Scraper produces structured lead records containing the information associated with each discovered email result.

The dataset fields are:

| Field         | Description                                                           |
| ------------- | --------------------------------------------------------------------- |
| `keyword`     | Keyword used to discover the result                                   |
| `title`       | Title associated with the search result                               |
| `description` | Search-result description containing the publicly indexed information |
| `url`         | URL of the discovered result                                          |
| `email`       | Email address matching the selected domain                            |
| `network`     | Identifies the source network as Redfin.com                           |

The primary contact value is the **email** field. The other fields provide context so you can understand where the email was discovered and which search keyword produced it.

> **📦 Output / Data Fields**
>
> - `keyword` — Search keyword
> - `title` — Result title
> - `description` — Result description
> - `url` — Result URL
> - `email` — Extracted email address
> - `network` — Redfin.com source identifier

### ⚙️ Redfin Email Scraper – How to Use It

Using the Redfin Email Scraper is straightforward.

#### 1. Enter Your Keywords

Add the keywords you want to search for.

For example:

```json
{
  "keywords": [
    "Real Estate Agent",
    "Property Manager",
    "Realtor"
  ]
}
```

More specific related keywords can provide different search coverage.

#### 2. Add a Location

If you need geographically targeted results, enter a location such as:

```text
New York
```

or:

```text
Texas
```

For a broad search, leave the location blank.

#### 3. Select Email Domains

Add the email domains you want the scraper to find:

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

Each keyword and domain combination is processed separately.

#### 4. Set the Maximum Email Target

The `maxEmails` setting controls the target number of new emails for each keyword + domain combination.

For example, with:

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

the Actor can work through the six keyword/domain combinations, targeting up to 20 new addresses for each combination, subject to available results and overall run conditions.

#### 5. Add Exclude Words if Needed

If certain descriptions should be ignored, add them to `excludeWords`.

Example:

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

#### 6. Start the Actor

Run the Actor in Apify. Results are pushed incrementally into the dataset as qualifying emails are discovered.

> **🚀 Quick-start configuration**
>
> - Keywords: `Real Estate Agent`, `Property Manager`, `Realtor`
> - Location: `New York`
> - Domains: `@gmail.com`, `@outlook.com`
> - Max Emails: `20`
> - Exclude Words: `crypto`, `onlyfans`

### 🔎 How to Scrape Redfin Emails with Multiple Keywords

For broader lead discovery, use several related search terms instead of relying on one generic keyword.

For example, a real estate campaign could use:

- Real Estate Agent
- Realtor
- Property Manager
- Real Estate Broker
- Real Estate Investor
- Property Management

This approach gives the Redfin Email Scraper multiple search combinations to process.

You can also combine several email domains. This is particularly useful when potential contacts use different personal or business email providers.

A practical strategy is to start with a focused keyword set, review the results, and then expand with closely related terms.

### 🧭 Can You Target a Specific City or Country?

Yes. The `location` input is designed to narrow the search geographically.

For example:

```json
{
  "keywords": [
    "Realtor",
    "Real Estate Agent"
  ],
  "location": "Chicago"
}
```

This helps focus discovery around the specified geographic term.

For nationwide or broader research, leave `location` empty.

> **📍 Location tip**
>
> - Use a city for local prospecting
> - Use a state for regional research
> - Use a country for broader geographic targeting
> - Leave the field empty for unrestricted geographic search

### 📥 Input

The Redfin Email Scraper accepts a JSON object with the following fields.

#### `keywords`

- **Type:** Array of strings
- **Required:** Yes
- **Purpose:** Search terms or queries used to discover relevant Redfin results
- **Default:** `Real Estate Agent`, `Property Manager`, `Realtor`

This is the most important input for determining what type of contacts the Actor searches for.

#### `location`

- **Type:** String
- **Required:** No
- **Purpose:** Optional country, state, or city filter
- **Default:** Empty

#### `customDomains`

- **Type:** Array of strings
- **Required:** No
- **Purpose:** Email-domain suffixes to extract
- **Default:** `@gmail.com`

Examples:

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

#### `maxEmails`

- **Type:** Integer
- **Minimum:** `1`
- **Maximum:** `10000`
- **Default:** `10`
- **Purpose:** Target number of emails for each keyword + domain combination

Higher targets can require more search processing and do not guarantee that the requested number will exist.

#### `excludeWords`

- **Type:** Array of strings
- **Required:** No
- **Default:** Empty

Use this input to skip descriptions containing specific unwanted words or phrases.

### 📤 Output

The Actor writes results to the Apify dataset as structured records.

Example output:

```json
{
  "keyword": "Real Estate Agent",
  "title": "Example Real Estate Agent",
  "description": "Example publicly indexed profile information ... agent@example.com",
  "url": "https://www.redfin.com/...",
  "email": "agent@example.com",
  "network": "Redfin.com"
}
```

The exact values depend on the publicly available search results returned for your selected keywords, locations, and domains.

The Actor also avoids storing the same email address repeatedly during the run, helping keep the resulting lead dataset focused on unique email addresses.

### 💼 Redfin Email Scraper – Use Cases

The Actor can support several practical research and lead-generation workflows.

#### Real Estate Lead Generation

- Find publicly indexed real estate-related contacts
- Build targeted prospect lists
- Search by professional role
- Narrow results by location

#### Property Management Research

- Discover property-management-related contacts
- Search specific cities or regions
- Separate results by keyword
- Target selected email providers

#### Real Estate Market Research

- Identify publicly indexed profiles
- Compare different geographic markets
- Collect search-result descriptions and URLs
- Organize discovered contacts in structured datasets

#### B2B Prospecting

- Search business-related real estate terms
- Target company or professional domains
- Combine multiple keywords with multiple email domains
- Export the resulting dataset for further analysis

> **🎯 Why use the Actor?**
>
> - Automates repetitive search work
> - Supports multiple keyword combinations
> - Supports multiple email-domain targets
> - Provides location-based targeting
> - Filters unwanted descriptions
> - Produces structured dataset records
> - Deduplicates discovered email addresses

### 💰 Pricing

The provided Actor configuration does not specify a monetary price, so no specific dollar amount should be assumed from the Actor files.

The Actor does, however, apply a result limitation for free users. The implementation limits free-tier runs to **100 unique emails**.

Paid users are not subject to that Actor-level 100-email restriction.

Your actual Apify platform usage cost can depend on the resources consumed by the run and the applicable Apify plan.

> **💡 Important pricing note**
>
> - Free users: maximum 100 unique emails under the Actor's free-tier logic
> - Paid users: no Actor-level 100-email restriction
> - `maxEmails` still controls the requested target for each keyword + domain combination
> - A larger target does not guarantee more available emails
> - Actual platform costs are separate from this Actor-level result limit

### 🛠️ Tips and Best Practices

Use several related keywords when you want broader coverage.

For example, instead of only:

```text
Realtor
```

consider:

```text
Realtor
Real Estate Agent
Property Manager
Real Estate Broker
```

For geographic campaigns, add the relevant city or region.

For broader email discovery, consider multiple domains such as:

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

If results are too limited, broaden the keywords or remove the location restriction.

If results contain unwanted categories, use `excludeWords` to filter descriptions before email extraction.

> **⚡ Result-quality tip**
>
> - Specific keywords can improve targeting
> - Related keywords can increase coverage
> - Multiple domains can find different email providers
> - Removing an overly narrow location can expand results
> - Exclude words can reduce unwanted matches
> - Higher `maxEmails` values do not guarantee additional addresses

### ❓ Frequently Asked Questions

#### 🔹 What is the Redfin Email Scraper?

The Redfin Email Scraper is an Apify Actor that searches publicly indexed Redfin results using your selected keywords and extracts email addresses matching the email domains you specify.

#### 🔹 What data does the Redfin Email Scraper provide?

The dataset contains the keyword, result title, description, URL, extracted email address, and Redfin.com source identifier.

#### 🔹 Can I search Redfin emails by location?

Yes. The optional `location` field lets you add a country, state, city, or other geographic search term.

#### 🔹 Can I use multiple keywords?

Yes. The `keywords` field accepts a list of search terms. Using multiple related keywords can provide broader search coverage.

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

Yes. Add multiple domain suffixes to `customDomains`, such as `@gmail.com`, `@yahoo.com`, or `@outlook.com`.

#### 🔹 What does `maxEmails` mean?

`maxEmails` sets the target number of emails for each keyword + domain combination. It is not simply one shared target across every combination.

#### 🔹 Does the scraper guarantee the requested number of emails?

No. The Actor can only extract addresses that are publicly available in the search results. Narrow keywords, locations, domains, or limited indexed results can produce fewer emails.

#### 🔹 Can I exclude unwanted results?

Yes. Add words or phrases to `excludeWords`. Matching descriptions are skipped before an email is collected.

#### 🔹 Are duplicate emails collected?

The Actor tracks discovered email addresses and avoids collecting the same email address repeatedly during the run.

#### 🔹 Can I use the results as structured data?

Yes. Results are pushed into an Apify dataset, making them available in structured records for further processing within the Apify platform.

#### 🔹 Why did my run return fewer emails than expected?

Possible reasons include limited publicly indexed results, narrow keywords, a restrictive location, selected domains with few matches, excluded descriptions, or the Actor's stopping conditions.

Try broader keywords, additional related terms, more email domains, or a less restrictive location.

#### 🔹 Is the Redfin Email Scraper suitable for real estate prospecting?

Yes. Its keyword and location inputs make it suitable for discovering publicly indexed real-estate-related contacts and organizing matching email addresses into structured lead records.

### 📌 Important Notes

The Redfin Email Scraper works with information that is publicly available through search results. Results depend on what is publicly indexed and discoverable for the search terms used.

The Actor does not guarantee that every Redfin profile contains an email address or that every requested target can be reached.

For better results, use focused but sufficiently broad keywords, relevant geographic terms, and multiple email domains when appropriate.

> **🔐 Data & privacy note**
>
> - Only publicly discoverable search-result information is targeted
> - Do not use the Actor to collect information in violation of applicable laws or website terms
> - Review and comply with applicable privacy, marketing, and data-protection requirements before using collected contact information

### 🆘 Support

If you need help using the Redfin Email Scraper, want to report an issue, or need a custom adjustment related to your workflow, contact me by email:

**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": [
    "Real Estate Agent",
    "Property Manager",
    "Realtor"
  ],
  "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": [
        "Real Estate Agent",
        "Property Manager",
        "Realtor"
    ],
    "location": "",
    "customDomains": [
        "@gmail.com"
    ],
    "excludeWords": []
};

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

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

```

## MCP server setup

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