# Zillow Email Scraper - Multi-Engine, Type Targeted (`scrapido/zillow-contact-extractor`) Actor

🏘️ Zillow Email Scraper runs multi-engine search with address-type filtering. 🌍 Country and region targeting keeps Zillow leads relevant, while alias merging and decoding keep the list clean. 🔑 Built for proptech sales.

- **URL**: https://apify.com/scrapido/zillow-contact-extractor.md
- **Developed by:** [Scrapido](https://apify.com/scrapido) (community)
- **Categories:** Lead generation, Real estate, Automation
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.50 / 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.

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

### Zillow Email Scraper

**Zillow Email Scraper** helps you automate Zillow email harvesting for lead generation—extracting contact emails and profile details from publicly available web sources. It works as a Zillow email extractor that supports targeted email-domain filtering and location targeting, so you can build targeted outreach lists at scale with less manual work.

### What Does Zillow Email Scraper Do? 🤖

Zillow Email Scraper takes your **search terms**, **country targeting**, and **email type** (B2C or B2B) to scrape and extract relevant contact information. During a run, it collects Zillow-related results, filters them according to the configuration, and exports structured records into your Apify dataset. Each record includes the profile context (title, description, and URL), the discovery keyword, and the extracted email details such as `email`, `email_domain`, and `email_type`. If you need to **extract emails from Zillow**, use this as your **Zillow contact scraper** to automate Zillow email collection and speed up your outreach pipeline.

### What Can Zillow Email Scraper Extract? 📊

Zillow Email Scraper focuses on contact and profile context for leads. It produces clean, structured dataset rows that combine identity + navigation details with extracted email fields, filtered by your settings.

| Data Type | Field Name | Description |
|---|---|---|
| Contact | `email` | Primary email address extracted from the Zillow profile-related data |
| Identity | `title` | Profile name or business handle as shown in the result |
| Context | `description` | Short bio, summary, or profile tagline text captured from the source |
| Discovery | `keyword` | The search term from your input that surfaced this profile |
| Navigation | `url` | Direct link to the Zillow profile page |

#### Key Features of Zillow Email Scraper ⚡

- ✅ **Keyword-Driven Search:** Uses your `searchTerms` to surface Zillow leads for targeted Zillow lead generation.
- 🌍 **Location Targeting via Country:** Select a `country` to focus results on the region you care about for property owner email lookup.
- 📧 **Email Type Control (B2C vs B2B):** Choose the audience type you want—helpful for agent email finder workflows.
- 🔄 **Proxy-Ready Engine Options:** Built to support reliable large-scale scraping runs through configurable engine modes.
- 📊 **Structured Dataset Export:** Produces labeled fields (email, domain, type, and profile context) ready for CRM enrichment and analysis.
- 💾 **Configurable Result Cap:** Use `maxEmails` to control output volume and keep runs predictable for email harvesting software use cases.
- ⚙️ **Region Index Selection:** Includes `sourceRegion` selection to target the region index (currently only `All`).
- 🔎 **Domain-Level Insight:** Captures `email_domain` to help you validate and segment your targeted outreach lists.

### How to Use Zillow Email Scraper 🚀

1. **Find the Actor** — Search **Zillow Email Scraper** on [Apify Store](https://apify.com/store).
2. **Open Input Tab** — Click the **Input** tab in the Apify Console.
3. **Add Search Terms** — Enter one or more values for **Search Terms** (`searchTerms`) to guide Zillow data extraction.
4. **Choose Target Settings** — Set `country`, `sourceRegion`, and whether you want `emailType` to be **B2C** or **B2B**.
5. **Set a Safety Limit** — Use `maxEmails` to cap how many email results you want back for the run.
6. **Start the Run** — Monitor logs in real time as the actor scrapes and exports results.
7. **Download Results** — Export from the **Dataset** tab (JSON/CSV) for your lead list building workflow.

### Zillow Email Scraper Output Format 📦

The actor saves results to your Apify dataset as structured JSON rows, ordered by the dataset field schema below.

#### ⬇️ Input Example

```json
{
  "searchTerms": ["realtor", "property manager", "real estate agent"],
  "country": "United States",
  "sourceRegion": "All",
  "emailType": "B2C",
  "maxEmails": 100,
  "engine": "legacy"
}
```

#### ⬆️ Output Example

```json
[
  {
    "keyword": "real estate agent",
    "title": "Alex Rivera - Licensed Real Estate Agent",
    "url": "https://www.zillow.com/profile/alex-rivera",
    "description": "Local listings • Negotiation-first strategy • Available for buyer and seller consultations.",
    "email": "alex.rivera@riverarealty.com",
    "email_domain": "riverarealty.com",
    "email_type": "B2B",
    "scrape_from": "Zillow",
    "country": "United States"
  }
]
```

| Field | Label | Format | Description |
|---|---|---|---|
| `keyword` | Keyword | text | Search term that surfaced this profile during the scrape |
| `title` | Title | text | Profile name or business handle |
| `url` | URL | link | Direct profile URL (clickable in the dataset UI) |
| `description` | Description | text | Profile bio/summary/tagline captured from the source |
| `email` | Email | text | Extracted contact email address |
| `email_domain` | Email Domain | text | Domain portion of the extracted email (e.g., company domain) |
| `email_type` | Email Type | text | The email type classification used by the actor (B2C or B2B) |
| `scrape_from` | Scrape From | text | Source label indicating where the record was collected from |
| `country` | Country | text | Target country used for the run |

### 🎯 Use Cases of Zillow Email Scraper

Zillow Email Scraper is built for teams that want Zillow scraping tools without spending weeks on manual research.

- **Zillow lead generation:** Turn Zillow profiles into targeted outreach lists for sales and partnerships.
- **Email database enrichment:** Add new contacts with extracted emails and segment by `email_domain` and `email_type`.
- **Broker contact scraping:** Collect business-oriented emails when you set `emailType` to match B2B outreach needs.
- **Proptech lead generation:** Source property-related contacts for app/platform partnerships and integrations.
- **Targeted outreach lists:** Combine your keywords with location (`country`) to focus on the exact market you want.

### How Much Will Zillow Email Scraper Cost You? 💰

Pricing on Apify is pay-per-result, so your cost scales with how many email records you request. Use `maxEmails` to cap output volume and control spending per run. For best planning, start small with a narrow `searchTerms` set, validate quality in the dataset, then scale up once you’re confident in the yield.

### Is It Legal to Scrape Zillow? ⚖️

Zillow Email Scraper is designed to work with **publicly available data** and does not require logins or access to private content. In general, scraping public web data may be lawful, but legality depends on your jurisdiction and how you use the results. You should also comply with Zillow’s terms of service and applicable privacy and anti-spam regulations. If you have compliance questions or concerns about data handling, contact <scrapidocontact@gmail.com>.

### Zillow Email Scraper Input Parameters 📋

#### Input Parameters

Use these settings in the Apify Console when you run the actor.

```json
{
  "searchTerms": ["fitness", "gym", "workout"],
  "country": "United States",
  "sourceRegion": "All",
  "emailType": "B2C",
  "maxEmails": 100,
  "engine": "legacy"
}
```

| Parameter | Type | Required | Default | Description |
|---|---|---|---|---|
| `country` | String | ✅ Yes | `United States` | Country targeting for the run (choose the region you want to focus on). |
| `emailType` | String | ✅ Yes | `B2C` | Choose one audience type: **B2C** or **B2B**. |
| `engine` | String | No | `legacy` | Select the scraping engine mode. “Cost Effective (New)” is optimized for faster, cheaper scraping; “Legacy” is described as more reliable but slower and more expensive. |
| `maxEmails` | Integer | ✅ Yes | `100` | Maximum number of emails to collect (bounded between 1 and 10,000). |
| `searchTerms` | Array | ✅ Yes | (prefilled) `["fitness","gym","workout"]` | List of queries to find Zillow profiles (your keyword-driven Zillow data extraction inputs). |
| `sourceRegion` | String | ✅ Yes | `All` | Select the regional index to target (currently only **All** is available). |

### During the Actor Run ⏱️

You’ll see live progress in the Apify Console while the Zillow scraping runs. Results are written into the dataset as the actor discovers matching profiles and extracts email fields. Your overall duration depends on the number of emails you allow via `maxEmails` and the speed of the browsing environment.

### Final Note ✉️

Get started with Zillow scraping tools that help you automate Zillow contact scraper workflows in minutes. Run **Zillow Email Scraper** on Apify, then export your dataset for enrichment and outreach. Questions or feedback? Write to <scrapidocontact@gmail.com>.

### FAQ — Zillow Email Scraper ❓

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

Zillow Email Scraper uses your provided `searchTerms` and run targeting settings (like `country` and `emailType`) to identify relevant Zillow profile-related results, then extracts email addresses and related contact fields from the gathered profile data. It outputs the extracted data into your dataset using the predefined schema.

#### What types of Zillow profiles can I scrape?

You can scrape Zillow profile-related results that match the profiles surfaced by your `searchTerms` and targeting configuration. The actor produces structured records for each result and includes email details when available in the source data.

#### What did your tests show about the Zillow Email Scraper?

Output quality depends on how many Zillow profiles match your `searchTerms` and how many of those profiles provide email information in the publicly available source content. In practice, result volume varies by niche, keyword specificity, and the `emailType` you select.

#### Why scrape Zillow for emails?

Zillow contains a large number of real estate professionals and property-related contacts. A Zillow email scraper helps you speed up Zillow scraping for outreach by automatically collecting email addresses and profile context into a structured dataset—far faster than doing it manually.

#### How much does it cost to use the Zillow Email Scraper?

Apify pricing is pay-per-result, and you control run output volume with `maxEmails`. Apify also provides a free tier for new users with monthly compute credits. For cost control, start with a smaller `maxEmails` value and expand once you confirm the email yield and data quality.

#### How does the Zillow Email Scraper help my business?

It accelerates lead list building by exporting a ready-to-use dataset that includes `email`, `email_domain`, `email_type`, and the supporting profile context (`title`, `description`, and `url`). That makes it easier to enrich CRM records, segment leads, and create targeted outreach lists for your real estate email scraping efforts.

#### What are the challenges of using a Zillow scraper?

Not every relevant profile will include an email address, so yield can fluctuate based on keywords and audience type. If you see low output, try adjusting your `searchTerms`, switching `emailType` between B2C and B2B, or changing `country` to broaden your targeting.

#### How do I choose the right Zillow Email Scraper setup?

Start by choosing `searchTerms` that closely match your ideal contact niche. Then set `country` and `emailType` to match your target audience. Finally, use `maxEmails` as your output cap to keep experiments controlled while you validate results.

### 🆘 Support & Feedback

Need help running Zillow Email Scraper or want improvements for your Zillow lead generation workflow? Contact us at <scrapidocontact@gmail.com>.

### Multiple Email Types

**Email Types** replaces the old single Audience Type choice: select as many
kinds of mailbox as you want and the run chases all of them together.

| Type | What it matches |
| --- | --- |
| Personal / free webmail | Gmail, Outlook, Yahoo, iCloud, AOL, Proton, ... |
| Business / corporate | Company domains - free webmail and institutions excluded |
| Education (.edu / .ac) | `.edu`, `.ac.uk`, `.edu.au`, `.ac.in` and other academic suffixes |
| Government (.gov / .mil) | `.gov`, `.mil`, `.gov.uk`, `.gc.ca`, ... |
| Non-profit (.org) | `.org`, `.ngo`, `.org.uk`, ... |

Each selected type contributes its own Google dork patterns *and* its own domain
test, so a result is only kept if it genuinely belongs to the type that found
it. Every row carries an `emailType` field recording which one that was.

Suffixes are matched as real domain suffixes, so `cs.mit.edu` counts as
Education while `notedu.com` does not.

Setting **Custom Email Domains** still overrides everything: an explicit domain
list is a manual override and replaces the type-driven patterns. The legacy
`audienceType` value is still accepted, so saved inputs keep working.

# Actor input Schema

## `country` (type: `string`):

Specify the country to target for Google search results.

## `emailType` (type: `string`):

Choose one — B2C or B2B.

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

Enter the maximum number of emails to collect.

## `searchTerms` (type: `array`):

List of queries to find Zillow profiles.

## `sourceRegion` (type: `string`):

Select the regional index to target.

## `emailTypes` (type: `array`):

Which kinds of mailbox to hunt for. Pick as many as you like - each type contributes its own set of Google search patterns and its own domain filter, and every result records the type it was found as. Personal = free webmail (Gmail, Outlook, Yahoo, iCloud). Business = company domains, excluding free webmail and institutions. Education = .edu / .ac.uk and friends. Government = .gov / .mil. Non-profit = .org.

## Actor input object example

```json
{
  "country": "United States",
  "emailType": "B2C",
  "maxEmails": 100,
  "searchTerms": [
    "Los Angeles",
    "Miami Real Estate",
    "78701"
  ],
  "sourceRegion": "All",
  "emailTypes": [
    "Personal",
    "Business"
  ]
}
```

# 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 = {
    "searchTerms": [
        "Los Angeles",
        "Miami Real Estate",
        "78701"
    ],
    "emailTypes": [
        "Personal",
        "Business"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapido/zillow-contact-extractor").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 = {
    "searchTerms": [
        "Los Angeles",
        "Miami Real Estate",
        "78701",
    ],
    "emailTypes": [
        "Personal",
        "Business",
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("scrapido/zillow-contact-extractor").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 '{
  "searchTerms": [
    "Los Angeles",
    "Miami Real Estate",
    "78701"
  ],
  "emailTypes": [
    "Personal",
    "Business"
  ]
}' |
apify call scrapido/zillow-contact-extractor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,scrapido/zillow-contact-extractor"
        }
    }
}

```

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/hpP7zO8xIKO3AbAhW/builds/Ze4AMWoo9BadkQ1d9/openapi.json